BaseComponent.h

Go to the documentation of this file.

/***************************************************************
 
 Mini Grand Challenge 2010
 Pennsylvania State University - Robotics Club
 Learn more at www.psurobotics.org
 Protected by the GNU General Public License
 
 This source file is developed and maintained by:
 + Jeremy Bridon jgbridon@gmail.com
 
 File: BaseComponent.cpp/h
 Desc: The base class that all components should derive from.
 This class is a pure virtual class and cannot be instantiated.
 To create a component, you must create your own class and derive
 from this class. You must overload the "Update" function with
 your own code. Update is managed, such that it is only called when
 there is new data and/or when the allocated time block is appropriate.
 The interla I/O is managed with the communications class.
 
 A configuration file may also be loaded by this base component.
 The config file loaded is "[component name].cfg". The component name
 for the file *must* be all lowercase. The contents of the config
 file must be key-data pairs. The key string must not be spaced and
 then followed by any data form (int, float, string) that ends with
 the newline (or end of file). There is a finite number of data pairs
 that can be saved (see the constant), but length is of variable size.
 You must use the "LoadInt", "LoadFloat", or "LoadString" functions.
 The only pre-defined string/data pair is the server IP (defined as
 "ServerIP") and the port (defined as "ServerPort").
 
 BaseComponent does spit out three data types that are associated
 with performance measuremens. This is send out every one (1) seconds.
 These data type names are as follows, with the respective data type
 and description:
 
 PerformanceInputTime is of type float - Average time recieved input took
 PerformanceCycleCount is of type int - Update call count in one (1) seconds
 PerformanceCycleTime is of type float - The time each update call took
 
 More performance variables may be posted as this class is still under
 development.
 
 NOTE:
 THIS CURRENT IMPLEMENTATION *DOES* FULLY SUPPORT MULTI-PAGE DATA,
 but it is not yet checked!
 
 NOTE 2:
 WE MUST VALIDATE THE NEW DICTIONARY USE! Validation and performance
 testing is needed!
 
 NOTE 3:
 There is a possible performance / query issue which is if multiple
 components query the same data, does only one get it or both get it?
 
***************************************************************/

// Inclusion guard
#ifndef __BASECOMPONENT_H_
#define __BASECOMPONENT_H_

// Standard includes
#include "Utilities.h"
#include "Dictionary.h"

#include <string.h>             // Used as the key-type for the internal map / dictionary

#define COMMODEL_QUEUE_SIZE 1

// Define some special constants that are used for all IPC communications
#define COMMODEL_NAME "ComModelData"

#define COMMODEL_STRUCT "{[char: 64], [char: 64], [char: 1024], int, int, int, int, int, int}"

// Define the sizes which are seen above in COMMODEL_STRUCT
#define COMMODEL_DATATYPE_NAMELENGTH 64         
#define COMMODEL_DATAPAGE_SIZE 1024                     

// Define the look-up table of the config file
#define CONFIG_TABLE_LENGTH 32                          

// Define the performance counter size
#define INPUT_TIMES_MAX 16                                      


struct ComModelDataPage
{
        // Buffers
        char OriginComponent[COMMODEL_DATATYPE_NAMELENGTH];     
        char DataType[COMMODEL_DATATYPE_NAMELENGTH];            
        char Data[COMMODEL_DATAPAGE_SIZE];                                      
        
        // Lengths
        int DataLength;                         
        int TotalDataLength;            
        int PageID;                                     
        int PageCount;                          
        
        // Time that this message is posted (Specific to the sent-system info); Since OS epoch time
        unsigned int Seconds;
        unsigned int Milliseconds;
};

struct ComModelBlock
{
        // Buffers
        char* DataBuffer;                                               
        int BufferByteSize;                                             
        
        // Time the message is posted (Specific to the sent-system info); Since OS epoch time
        unsigned int Seconds;
        unsigned int Milliseconds;
};

class BaseComponent
{

protected:
        
        BaseComponent(const char* ComponentName, float AllocatedTime, const char* CentralIP = NULL, int Port = 1381);
        
        ~BaseComponent();
        
        void SetDependency(const char* GivenComponentName);
        
        virtual int Update() = 0; // Pure virtual function
        
        
        bool LoadInt(const char* Key, int* Data);
        
        bool LoadFloat(const char* Key, float* Data);
        
        bool LoadString(const char* Key, char** Data);
        
        static void __Run();
        
public:
        
        void Stop();
        
        void Run();
        
        /* I don't like putting these files in public, but the choice is to
         * either put general image sending code in BaseComponent, or let
         * functions outside BaseComponent send and receive data.
         */

        int GetDataByteCount(const char* ComponentName, const char* DataType);
        
        int GetData(const char* ComponentName, const char* DataType, void* DataBuffer, unsigned int* SecondsSent = NULL, unsigned int* MillisecondsSent = NULL);
        
        int SendData(const char* DataType, const void* DataBuffer, int BufferByteSize);
private:
        
        ComModelBlock* GetDataBlock(const char* GivenComponentName, const char* GivenDataType);
        
        int LoadConfig(const char* FileName);
        
        char* ConfigTable[CONFIG_TABLE_LENGTH][2];
        
        bool RunLoop;
        
        float AllocatedTime;
        
        // Client / server info for CMU IPC
        char* ComponentName;    
        char* CentralIP;                
        int Port;                               
        
};

// End of inclusion guard
#endif

---