/users/dtb26/GITROOT/vs-vetserial-poc/src/vetprot.h

Go to the documentation of this file.

/*
* AUTHOR    : David Brooks (dtb26@cornell.edu)
* PLATFORM  : non-specific
* DATE      : 4/4/2012 9:18:44 AM
* COPYRIGHT : TBD
*
* File      : $Source:$
* Revision  : $Revision:$
* Author    : $Author:$
* Date      : $Date:$
* Tag name  : $Name:$
* Locker    : $Locker:$
* State     : $State: Exp $
*/

// MSVC++ 6.0  _MSC_VER = 1200
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
        #pragma once
        #pragma warning( disable : 4290 ) 
        #pragma warning( disable : 4996 ) 
#endif

#ifndef VET_SERIAL_H_INCLUDED
#define VET_SERIAL_H_INCLUDED
#include "excepts.h"
#include <math.h>
#include <string.h>
#include <sstream>
#include <queue>

extern "C" {
        #ifdef INTMAX_C
        #undef INTMAX_C
        #undef UINTMAX_C
        #endif
        #include "messaging.h"
}

#ifdef NULLPTR
#undef NULLPTR
#endif
#define NULLPTR 0 
typedef char               int8_;       
typedef unsigned char  uint8_;  
typedef short              int16_;      
typedef unsigned short uint16_; 
typedef int                        int32_;  
typedef unsigned int   uint32_; 
typedef int                        int64_;  
typedef unsigned int   uint64_; 
namespace cornelluniversity {

namespace vetserial {

static const uint8_ NUL = 0x00; 
static const uint8_ SOH = 0x01; 
static const uint8_ STX = 0x02; 
static const uint8_ ETX = 0x03; 
static const uint8_ EOT = 0x04; 
static const uint8_ ENQ = 0x05; 
static const uint8_ ACK = 0x06; 
static const uint8_ NAK = 0x07; 
static const uint8_ SYN = 0x0f; 
static const unsigned int MP3_TRACK_MAX = 0xFF; 
typedef enum STATUS_TYPE {
        STATUS_ERROR = 0x10,    
        STATUS_READY = 0x20,    
        STATUS_BUSY  = 0x40             
} status_t;

typedef enum COMMAND_ID {
        CMD_CNTRL    = 0x00, 
        CMD_REQSTAT  = 0x01, 
        CMD_RSPSTAT  = 0x02, 
        CMD_PLAY_MP3 = 0x03, 
        CMD_STOP_MP3 = 0x04, 
        CMD_MSG_PRXY = 0x05, 
        CMD_CPR_CMPR = 0x06, 
        CMD_MAXCMD   = 0xFF  
} cmnd_id;

typedef enum ERROR_CODE {
        E_NOERROR  = 0x00, 
        E_DATAOOB  = 0x01, 
        E_NULLPTR  = 0x02, 
        E_CHKSUM   = 0x03, 
        E_NONPROTO = 0xFE, 
        E_UNKNOWN  = 0xFF  
} err_code;

typedef enum FLAG_TYPE {
        FLAG_REQ    = 0x01,     
        FLAG_ACK    = 0x02,     
        FLAG_NAK    = 0x04,     
        FLAG_DATA   = 0x08,     
        FLAG_ERR    = 0x10,     
        FLAG_RDY    = 0x20,     
        FLAG_BUSY   = 0x40,     
        FLAG_RESRVD = 0x80      
} flag_t;

class base_command {
        public:
                static const unsigned int PKT_HEADER_SZ;        
                static const unsigned int PKT_TAIL_SZ;          
                static const unsigned int PKT_MAX_SZ;           
                base_command( const cmnd_id cid );
                base_command( const uint8_ * in_pkt, uint32_ nbytes );
                virtual ~base_command( void );
                inline const uint8_ * packet( void ) const { return( buffer_ ); }
        inline const int packet_size( void ) const { return( buffersz_ ); }
                inline void command_id( const cmnd_id cid ) { this->id_ = cid; }
                inline const cmnd_id command_id( void ) const { return(this->id_); }

                inline const uint8_ flags( void ) const { return(flags_); }
                inline void set_flag( const uint8_ f ){ flags_ |= f; }
                inline void clr_flag( const flag_t f ){ flags_ -= f; }
                inline bool flag_enabled( const flag_t f ) const { return( (flags_ & f) > 0 ? true : false ); }
                inline void error_code( const err_code id ){ this->err_ = id; }
                inline const err_code error_code( void ) const { return(this->err_); }
                inline void data_id( const uint8_ id ){ data_id_ = id; }
                inline const unsigned char data_id( void ) const { return(data_id_); }
                inline void payload_size( const uint16_ sz ){ this->payloadsz_ = sz; }
                inline const uint16_ payload_size( void ) const { return( this->payloadsz_ ); }
                bool verify_crc16( const uint8_ * full_packet, const uint32_ nbytes );
                inline const bool failed_tail_crc( void ) const { return( tail_crc_err_ ); }
        virtual void serialize( void ) = 0;
                virtual void deserialize( void ) = 0;

        protected:
                uint8_ * buffer_;        
                uint8_ * packet_;        
                uint32_  buffersz_;  
                uint32_  pktsz_;     
                uint16_ crc16( const uint8_ * indata, const uint32_ nbytes );
                void header( void );
                void tail( const uint8_ * payload, const uint32_ payload_sz = 0 );

        private:
                base_command( void ){;}
                base_command( const base_command & cpyref ){;}

                bool     tail_crc_err_; 
                bool     head_crc_err_; 
                uint8_   flags_;                
                uint8_   data_id_;              
                uint16_  payloadsz_;    
                cmnd_id  id_;                   
                err_code err_;                  
};//eoc base_command

class control_request : public base_command {
        public:
        control_request( void ) : base_command(CMD_CNTRL){;}
        control_request( const uint8_ * in_pkt, uint32_ nbytes ) : base_command(in_pkt, nbytes){;}
        virtual ~control_request( void ){;}

        inline void ack_request( void ){ this->set_flag(FLAG_REQ|FLAG_ACK); }

        inline void ack_response( void ){ this->set_flag(FLAG_ACK); }
        
        inline void nak_request( void ){ this->set_flag(FLAG_REQ|FLAG_NAK); }
        
        inline void nak_response( void ){ this->set_flag(FLAG_NAK); }
        
        inline void set_responsive( void ){ this->set_flag(FLAG_REQ|FLAG_ACK|FLAG_NAK); }
        virtual void serialize( void ){ this->header(); }
        virtual void deserialize( void );

};//eoc control_request

class status_request : public base_command {
        public:
        status_request( void ) : base_command(CMD_REQSTAT){;}
        status_request( const uint8_ * in_pkt, uint32_ nbytes ) : base_command(in_pkt, nbytes){;}
        virtual ~status_request( void){;}
        virtual void serialize( void );
        virtual void deserialize( void );
};//eoc status_request

class status_response : public base_command {
        public:
        status_response( void ) : base_command(CMD_RSPSTAT), status_(STATUS_READY){;}
        status_response( const status_t s );
        status_response( const uint8_ * in_packet, uint32_ in_packet_sz ) : base_command(in_packet, in_packet_sz){;}
        virtual ~status_response( void){;}
        inline const status_t status( void ) const { return(this->status_); }
        void status( const status_t t ) { this->status_ = t; this->set_flag(this->status_); }
        virtual void serialize( void );
        virtual void deserialize( void );
        
        private:
        status_t status_;       
};//eoc status_request

class mp3_play_request : public base_command {
        public:
        mp3_play_request( void ) : base_command(CMD_PLAY_MP3), device_(0), track_(0), duration_(0) {;}
        mp3_play_request( const uint8_ dev, const uint8_ trk, const uint16_ dur = 0) : base_command(CMD_PLAY_MP3), device_(dev), track_(trk), duration_(dur) {;}
        mp3_play_request( const uint8_ * in_pkt, uint32_ nbytes ) : base_command(in_pkt, nbytes), device_(0), track_(0), duration_(0) {;}

        virtual ~mp3_play_request( void){;}
        inline const uint8_ track( void ) const { return(this->track_); }
        inline void track( const uint8_ track_number ) { this->track_ = track_number; }
        inline const uint8_ device( void ) const { return(this->device_); }
        inline void device( const uint8_ device_number ) { this->device_ = device_number; }
        inline const uint16_ duration( void ) const { return(this->duration_); }
        inline void duration( const uint16_ duration ) { this->duration_ = duration; }
        virtual void serialize( void );
        virtual void deserialize( void );

        private:
        uint8_  device_;        
        uint8_  track_;         
        uint16_ duration_;      
};//eoc mp3_play_request

class mp3_stop_request : public base_command {
        public:
        mp3_stop_request( void ) : base_command(CMD_STOP_MP3), device_(0), track_(0){;}
        mp3_stop_request( const uint8_ dev, const uint8_ trk ) : base_command(CMD_STOP_MP3), device_(dev), track_(trk){;}
        mp3_stop_request( const uint8_ * in_pkt, uint32_ nbytes ) : base_command(in_pkt, nbytes), device_(0), track_(0){;}

        virtual ~mp3_stop_request( void){;}
        inline const uint8_ track( void ) const { return(this->track_); }
        inline void track( const uint8_ track_number ) { this->track_ = track_number; }
        inline const uint8_ device( void ) const { return(this->device_); }
        inline void device( const uint8_ device_number ) { this->device_ = device_number; }
        virtual void serialize( void );
        virtual void deserialize( void );

        private:
        uint8_  device_; 
        uint8_  track_;  
};//eoc mp3_stop_request

class pubsub_message : public base_command {

        public:
        pubsub_message( void ) : base_command(CMD_MSG_PRXY), msg_(NULLPTR), msg_byte_count_(0){;}
        pubsub_message( Message * m );
        pubsub_message( const uint8_ * in_pkt, uint32_ nbytes ) : base_command( in_pkt, nbytes ), msg_(NULLPTR), msg_byte_count_(0){;}
        virtual ~pubsub_message( void);
        void set_message( Message * m );
        Message * get_message( void );
        inline const uint16_ message_length( void ) const { return(msg_byte_count_); }
        virtual void serialize( void );
        virtual void deserialize( void );

        private:
        uint16_  byte_size( const Message_content_type mct );
        uint16_  msg_size( void );
        void msgcpy( const Message * orig, Message * copy );
        inline void msgcpy( const Message * orig ){ this->msgcpy( orig, this->msg_ ); }
        void msgdestroy( Message * m );
        inline void msgdestroy( void ){ this->msgdestroy( this->msg_ ); }

        Message * msg_;                         
        uint16_   msg_byte_count_;      
};//eoc pubsub_message

class cpr_compression_state : public base_command {

        public:
        cpr_compression_state( void );
        cpr_compression_state( const uint16_ pos );
        cpr_compression_state( const uint16_ * cpy, const int arraysz );
        cpr_compression_state( const uint8_ * in_pkt, uint32_ nbytes );

        virtual ~cpr_compression_state( void ) { if(positions_) delete positions_; positions_ = NULLPTR; }
        void position( const uint16_ pos );
        inline void position( const int pos ) { this->position( static_cast<uint16_>(pos) ); }
        void position( const uint16_ * cpy, const int arraysz );
        const uint16_ position( const bool pop_position = false );
        inline const std::queue<uint16_>* all_positions( void ) const { return(positions_); }
        inline const size_t position_count( void ) const { return(positions_->size()); }

        virtual void serialize( void );
        void deserialize( void );

        private:
        std::queue<uint16_> *positions_;

};//eoc pubsub_message

}//eon vetserial
}//eon cornelluniversity

#endif /*VET_SERIAL_CMD_H_INCLUDED*/

/*
VERSION LOG
===========
$Log:$

*/

---