simpleComm.cpp

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////////
/*! \file simpleComm.cpp
 *  \brief This file provides an example of comm functionality.
 *  \author  $Author: rsharo $
 *  \version $Revision: 1.4 $
 *  \date    $Date: 2004/04/07 13:49:27 $
 *//////////////////////////////////////////////////////////////////////////////

#include "Whorl.h"
#include "WhorlSim.h"
#include "CfgParse.h"
#include "Measurement.h"
#include <iostream>
#include <sstream>

#include "ace/ACE.h"
#include "ace/Log_Msg.h"
#include "Utils/SystemProperties.h"
#include "Comm/CommFactory.h"
#include "Comm/MessageClient.h"
#include "Comm/MessageServer.h"

using namespace std;



//
// This class represents a client that generates
// Rate gyro readings.  For simplicity of this example, the messages are
// in the form of ASCII strings that the main() generates.
class RG_Writer : public MessageClient
{
public:
        //
        // This allows us to define the message ID for this client
        // right here in the class declaration.
        enum { MY_MSG_ID = 101 };

        //
        // The constructor establishes this client's ID field.
        // Messages with this ID will be read by this client.
        // We're also registering with the Comm system right out 
        // of the constructor for this example.
        RG_Writer(MessageServer *pMsgSvr) : MessageClient(MY_MSG_ID)
                 { Register(pMsgSvr); }

        //
        // This method is here to allow external code (like main())
        // to send messages as if they came from this client.
        // This method assumes the message is a null-terminated ASCII string.
        int SendMessage(const char *msg, u_int dest)
        {
                ACE_DEBUG((LM_DEBUG,
                         "Sending this message to the reader: %s\n", msg));

                return MessageClient::SendMessage(msg, strlen(msg)+1, dest);
        }

        //
        // All clients must implement this method.  This is the one that
        // is called when a message is routed to this client.
        // If this method ever returns -1, then the client is disconncted
        // and won't receive any more messages. This is a good idea
        // when the client has outlived its usefulness.
        // Clients can be reconnected later with another call to Register().
        int ReceiveMessage(const char *msg, size_t len)
        {
                // This client just prints the message it got.
                ACE_DEBUG((LM_DEBUG, "Writer got a message: %s\n", msg));

                return 0;
        }
};




//
// This class represents a client that generates
// Rate gyro readings.  For simplicity of this example, the messages are
// in the form of ASCII strings that the main() generates.
class RG_Reader : public MessageClient
{
public:
        //
        // This allows us to define the message ID for this client
        // right here in the class declaration.
        enum { MY_MSG_ID = 100 };

        //
        // The constructor establishes this client's ID field.
        // Messages with this ID will be read by this client.
        // We're also registering with the Comm system right out 
        // of the constructor for this example.
        RG_Reader(MessageServer *pMsgSvr) : MessageClient(MY_MSG_ID)
                 { Register(pMsgSvr); }

        //
        // All clients must implement this method.  This is the one that
        // is called when a message is routed to this client.
        // If this method ever returns -1, then the client is disconncted
        // and won't receive any more messages. This is a good idea
        // when the client has outlived its usefulness.
        // Clients can be reconnected later with another call to Register().
        //
        // This method parses the string and extracts the rate gyro
        // measurements. It then prints the measurements on the console.
        //
        // Finally, it sends the message 'OK' back to the writer so it
        // knows its message was received.
        int ReceiveMessage(const char *msg, size_t len)
        {
                ACE_DEBUG((LM_DEBUG, "Reader got a message: %s\n", msg));

                istringstream iss(msg);

                double rg[3];

                iss >> rg[0] >> rg[1] >> rg[2];

                ACE_DEBUG((LM_DEBUG, "   Rate gyro readings: %f %f %f\n",
                                         rg[0], rg[1], rg[2]));

                ACE_DEBUG((LM_DEBUG, "Sending the reply message 'OK' to the writer.\n"));

                this->SendMessage("OK", 3, RG_Writer::MY_MSG_ID);

                return 0;
        }
};



int main() {

        //
        // Disable purely informational log messages. The just clutter
        // the console.
        {
                u_long mask = 
                        ACE_Log_Msg::instance()->priority_mask(ACE_Log_Msg::PROCESS);

                ACE_Log_Msg::instance()->priority_mask(mask & ~LM_INFO,
                         ACE_Log_Msg::PROCESS);
        }


        cout << "Code is running." << endl;

        //
        // Load the system configuration from an INI-style
        // config file.
        SystemProperties *props = SystemProperties::Instance("System.config");

        //
        // All you need to do to set up comm is construct a factory
        // and tell it to open. Then all the clients can use
        // the factory to connect to the network.
        PropertyBasedCommFactory commFact;

        //
        // This tells the factory to get its properties from the
        // section of the config file labeled "Typhon\Comm".
        if (commFact.Open(*props, "Typhon\\Comm") == -1)
        {
                ACE_ERROR_RETURN((LM_ERROR, "Comm setup failed.\n"), -1);
        }

        //
        // Get the message server from our factory. We use this to connect
        // our clients to the network.
        MessageServer *pMsgSvr = commFact.GetMessageServer();

        //
        // Construct a client that will be sending rate gyro messages
        // over the network.
        RG_Writer myWriter(pMsgSvr);

        //
        // Construct a client that will be reading rate gyro messages
        // from the network.
        RG_Reader myReader(pMsgSvr);

        
        /** Prepare for parsing */
        cfgBody *cfgDat;
        CfgParse parser;
        
        /** Parse out configuration files */
        cout << "Parsing Whorl configuration file." << endl;
        cfgDat = parser.go("simpleComm.cfg");

        Whorl whorlOne;
        whorlOne.Initialize(cfgDat);
  
        timeval t;
        whorlOne.GetRateGyro(string("dmu_rg1"))->GetMeasurement().GetTime(t);
        whorlOne.SetTimeOfEstimate(t);  // it doesn't make sense to set time in the config file!


        Measurement rateGyroMeasurements[3];
        Vector rateGyroDoubles(3);
        
        cout << "Entering the loop." << endl;

        ACE_OS::sleep(5);

        for ( int ii = 1; ii <= 100; ii++ ) {
                
                //
                // Get the measurement from the rate gyros
                rateGyroMeasurements[0] =
                         whorlOne.GetRateGyro(string("dmu_rg1"))->GetMeasurement();
                rateGyroMeasurements[1] =
                         whorlOne.GetRateGyro(string("dmu_rg2"))->GetMeasurement();
                rateGyroMeasurements[2] =
                         whorlOne.GetRateGyro(string("dmu_rg3"))->GetMeasurement();
        

                //
                // Use the ostringstream class to build a message
                // in the form of an ASCII string...
                ostringstream oss;
                oss << rateGyroMeasurements[0].GetAsDouble() << " "
                        << rateGyroMeasurements[1].GetAsDouble() << " "
                        << rateGyroMeasurements[2].GetAsDouble();

                //
                // Convert the ostringstream into a C++ string,
                // and then convert that C++ string into a C string.
                const char *msg = oss.str().c_str();

                //
                // Send the string out to everyone who wants it.
                if (myWriter.SendMessage(msg, RG_Reader::MY_MSG_ID) == -1)
                {
                        ACE_ERROR_RETURN((LM_ERROR,
                                "***Sending a message failed. Aborting.\n"), -1);
                }

                cout << " Sent." << endl;
                
        };

        
        cout << "Out of the loop." << endl;

        //
        // Give the clients time to process all the messages.
        ACE_OS::sleep(3);
        
                
        return 0;
        
};



// Do not change the comments below - they will be added automatically by CVS
/*****************************************************************************
*       $Log: simpleComm.cpp,v $
*       Revision 1.4  2004/04/07 13:49:27  rsharo
*       Completely redone to demonstrate the MessageServer/MessageClient comm scheme.
*       System.config is now an INI-style configuration file.
*
*       Revision 1.3  2003/12/17 22:42:31  rsharo
*       Addes more comments.
*
*       Revision 1.2  2003/12/17 21:00:37  rsharo
*       Added communication code.
*
*       Revision 1.1  2003/12/08 13:54:51  simpliciter
*       First cut of sample Comm files.
*
*       
*
******************************************************************************/

---