/users/dtb26/GITROOT/VetSim-Core/src/vetserial/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 <string.h>
#include <sstream>

#ifdef NULLPTR
#undef NULLPTR
#endif
#define NULLPTR 0 
typedef unsigned char  uint8_;  
typedef unsigned short uint16_; 
typedef unsigned int   uint32_; 
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_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 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_ ); }
        virtual void execute( void ) = 0;

        protected:
                uint8_ * buffer_;        
                uint8_ * packet_;        
                uint32_  buffersz_;  
                uint32_  pktsz_;     
                uint16_ crc16( const uint8_ * indata, const uint32_ nbytes );
                bool verify_crc16( const uint8_ * full_packet, 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 ){;}

                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){;}
        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 execute( void ){ this->header(); }
};//eoc control_request

class status_request : public base_command {
        public:
        status_request( void ) : base_command(CMD_REQSTAT){;}
        virtual ~status_request( void){;}
        virtual void execute( 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 );
        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 execute( 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) {;}
        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 execute( 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){;}
        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 execute( void );

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

}//eon vetserial
}//eon cornelluniversity

#endif /*VET_SERIAL_CMD_H_INCLUDED*/

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

*/

---