JanzCanIo.h

Go to the documentation of this file.

#ifndef CARMA_CANBUS_JANZCANIO_H
#define CARMA_CANBUS_JANZCANIO_H

#include "carma/canbus/CanIo.h"
#include "carma/canbus/Message.h"

#include <pthread.h>
#include <queue>
#include <string>

namespace carma {

namespace util {
    template <class ElementType> class IPQreader;
    template <class ElementType> class IPQwriter;
}

namespace canbus {

    class JanzMessage;

    class JanzCanIo : public CanIo {
        public:

            // Constructors...

            JanzCanIo ();

            JanzCanIo (const char * deviceName, bool terminate);

            JanzCanIo (const char* dev0, bool term0, const char* dev1, bool term1);
            
            typedef 
            ::std::vector< ::std::pair< ::std::string, bool > > NameTermPairVec;

            JanzCanIo ( const NameTermPairVec & nameTermPairs );

            virtual ~JanzCanIo ();

            // Input methods.

            carma::canbus::Message getMessage();

            void postMessage(
                const carma::canbus::Message &msg,
                carma::canbus::txPriorityType prio = carma::canbus::NORMAL); 

            void echoAll(bool enable);

            BusStatusMap getBusStatus() const;

            // Utilities...

            void clearReadQueue();
            
            void queueMessage(const Message &msg);

            void setTimestampEchoLatency(int tsLatency, busIdType busId);
        
        protected:

        private:
            

            // Local structure typedefs for busses, devices and queue 
            // information...
            // A bus is a single physical CAN bus and contains information
            // pertinent to the bus and CAN messages.  The device is mutex
            // protected to synchronize access to it.
            
            typedef struct {
                bool terminate;     
                int rxCount;        
                int txCount;        
                int oneMinRxCount;  
                int oneMinTxCount;  
                busIdType id;       
                timespec lastUpdateTime; 
                timespec lastOneMinUpdate; 
                carma::canbus::busStatusType status; 
            } busType;

            typedef struct {
                std::string name;            
                int fd;                  
                bool initialized;        
                pthread_mutex_t mutex;   
                pthread_t threadId;      
                void * arg;              
                busType bus;             
            } deviceType;

            typedef struct queueAccessStruct {
                pthread_mutex_t mutex;
                pthread_cond_t cond;
                std::queue<carma::canbus::Message> messageQueue;
            } queueAccessType;

            // Private member data

            pthread_t updateThreadId_;         // Thread Id for update thread
            pthread_t writeThreadId_;          // Thread Id for write thread
            queueAccessType rxQueueAccessor_;  // Received CAN message queue 
            // Direct CAN IPQs.
            carma::util::IPQwriter<carma::canbus::Message> * writeIpq_; 
            carma::util::IPQreader<carma::canbus::Message> * readIpq_;  
            
            typedef std::map<busIdType, deviceType*> DeviceMap;
            
            DeviceMap devices_;
            const bool emulate_;               
            bool echo_; // Echo messages posted to canbus?
            
            // CanOutput routines
            
            void addDevice(busIdType busId);

            virtual void canFastSend(busIdType busId, const JanzMessage &jmsg,
                txPriorityType prio);
            
            // Initialization and startup routines...

            void initialize();

            void initializeIpqs();

            void createThreads();

            // Utility routines...

            // The following two methods are protected to avoid cluttering the
            // interface.  They are implemented in the getMessage variants.

            bool waitForMessage(double maxWaitInSeconds = -1.0);

            static void waitCleanupHandler(void *arg);

            void processFastMessage(deviceType &dev);

            void processPlainMessage(deviceType &dev);

            JanzCanIo (const JanzCanIo &);

            JanzCanIo &operator=(const JanzCanIo &);

            // Utilities...

            void updateBusStatus();

            // Thread based utilities...

            static void *readThreadEntry(void *arg);

            void runReadThread(deviceType &dev);

            static void *writeThreadEntry(void *arg);

            void runWriteThread();

            static void *updateThreadEntry(void *arg);

            void runUpdateThread();

    };
  } // namespace canbus
} // namespace carma
#endif // CARMA_CANBUS_JANZCANIO_H