Device.h

Go to the documentation of this file.

#ifndef CARMA_CANBUS_DEVICE_H
#define CARMA_CANBUS_DEVICE_H

// C++ STL includes
#include <vector>
#include <map>
#include <string>

// Carma includes
#include "carma/canbus/CanOutput.h"
#include "carma/canbus/Message.h"
#include "carma/canbus/Types.h"

namespace carma {
namespace canbus {

    typedef ::std::map< ::carma::canbus::msgType, ::std::string > MsgIdInfoMap;

    class Device {
    public:

        Device(apiType api, nodeType node, CanOutput &io);

        virtual ~Device();

        apiType getApi() const;

        nodeType getNode() const;

        keyType getKey( ) const;

        static keyType createKey( apiType api, nodeType node );

        boardType getBoardType() const;

        serialNumberType getSerialNumber() const;

        busIdType getBusId() const;

        deviceStateType getState() const;

        double getLastRxTime() const;

        unsigned int getNlatePackets() const;

        char getApiVersion() const;

        virtual MsgIdInfoMap getControls() const;

        virtual MsgIdInfoMap getHalfSecMonitors() const = 0;

        virtual MsgIdInfoMap getSlowMonitors() const = 0;

        virtual void setState(deviceStateType state);

        void setBusId(busIdType busId);

        void setSerialNumber(serialNumberType sn);

        void setBoardType(boardType bt);

        virtual void setLastRxTime(double rxMjd);
        
        virtual void processMsg(msgType messageId, 
                                std::vector<byteType>& data,
                                bool sim) = 0;

        virtual carma::canbus::Message simulateMsg(msgType messageId) = 0;

        carma::canbus::Message createMsgToHost(msgType messageId) const;

        carma::canbus::Message createMsgToNode(msgType messageId) const;

        carma::canbus::Message createMsgToAllNodes(msgType messageId) const;
        
        carma::canbus::Message createDummyMsg( ) const;

        // Standard Control messages.
        void reset();

        void stopChannelOneFastSampling();

        void stopChannelTwoFastSampling();

        void startChannelOneFastSampling(unsigned short fastItem);
        
        void startChannelTwoFastSampling(unsigned short fastItem);

        virtual void updateFrameData();

    protected:
        
        // This is shared data but it never changes. Let inherited classes 
        // use directly if they want.  
        const apiType api_;  
        const nodeType node_;
        const keyType key_;

        // Standard controls.
        // These controls are common message id's shared by all CANbus 
        // Devices.  Note that not all devices will implement fast
        // sampling.  Also note that RESET refers to a software reset
        // message, not a 'hardware reset' which is performed by the 
        // canbus::Dio class.
        
        static const msgType RESET                         = 0x0000;
        static const msgType STOP_CHANNEL_1_FAST_SAMPLING  = 0x0002; 
        static const msgType STOP_CHANNEL_2_FAST_SAMPLING  = 0x0003;
        static const msgType START_CHANNEL_1_FAST_SAMPLING = 0x0004; 
        static const msgType START_CHANNEL_2_FAST_SAMPLING = 0x0005; 
        
        // Member objects
        CanOutput& io_; 

        // Helper functions for derived classes
        void incrementLatePacketCount();

        void resetLatePacketCount();

        bool isPacketLate(double window = 100.0);

        void setApiVersion(char api);

    private:

        // Structure to hold shared data and associated mutex. 
        struct {
            carma::canbus::boardType boardType;      
            serialNumberType serialNumber;
            busIdType busId; 
            deviceStateType state;
            unsigned int nLatePackets;
            double lastRxMjd;
            char apiVer;
            mutable pthread_mutex_t mutex; // Mutable to allow const func access
        } sharedData_;
        
        // Prevent assignment and copy construction
        Device(const Device &);
        Device &operator=(const Device &);

    };
  } // End namespace canbus
} // namespace carma
#endif // CARMA_CANBUS_DEVICE_H