DummyHardware.hpp

Go to the documentation of this file.

/*
---------------------------------------------------------------------------

    This file is part of uHAL.

    uHAL is a hardware access library and programming framework
    originally developed for upgrades of the Level-1 trigger of the CMS
    experiment at CERN.

    uHAL is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    uHAL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with uHAL.  If not, see <http://www.gnu.org/licenses/>.


      Andrew Rose, Imperial College, London
      email: awr01 <AT> imperial.ac.uk

      Marc Magrans de Abril, CERN
      email: marc.magrans.de.abril <AT> cern.ch

---------------------------------------------------------------------------
*/

#ifndef _uhal_tests_DummyHardware_hpp_
#define _uhal_tests_DummyHardware_hpp_


#include <deque>
#include <vector>

#include <boost/chrono/chrono_io.hpp>
#include <boost/thread/thread.hpp>

#include "uhal/IPbusInspector.hpp"


namespace uhal
{
  namespace tests 
  {

    static const uint32_t ADDRESSMASK = 0x00FFFFFF;
    static const uint32_t REPLY_HISTORY_DEPTH = 5;
    static const uint32_t BUFFER_SIZE = 100000;
  

    class DummyHardwareInterface {
    public:
      DummyHardwareInterface(const boost::chrono::microseconds& aReplyDelay) :
        mReplyDelay(aReplyDelay)
      {
      }

      virtual ~DummyHardwareInterface() {}

        virtual void run() = 0;

        virtual void stop() = 0;

        template <class DurationType>
        void setReplyDelay(const DurationType& aDelay)
        {
          mReplyDelay = aDelay;
        }

      protected:
        boost::chrono::microseconds mReplyDelay;
    };


    template< uint8_t IPbus_major , uint8_t IPbus_minor >
    class DummyHardware : public DummyHardwareInterface, public HostToTargetInspector< IPbus_major , IPbus_minor >
    {
        typedef HostToTargetInspector< IPbus_major , IPbus_minor > base_type;
  
      public:
        DummyHardware ( const uint32_t& aReplyDelay, const bool& aBigEndianHack );
  
        virtual ~DummyHardware();

      protected:
        void AnalyzeReceivedAndCreateReply ( const uint32_t& aByteCount );
  
        void SetEndpoint( const uint32_t& aAddress , const uint32_t&  aValue );

      private:

        uint32_t GetEndpoint( const uint32_t& aAddress );

        void bot();

        void ni_read ( const uint32_t& aAddress );

        void read ( const uint32_t& aAddress );

        void readConfigurationSpace ( const uint32_t& aAddress );

        void ni_write ( const uint32_t& aAddress , std::vector<uint32_t>::const_iterator& aIt , const std::vector<uint32_t>::const_iterator& aEnd );
  
        void write ( const uint32_t& aAddress , std::vector<uint32_t>::const_iterator& aIt , const std::vector<uint32_t>::const_iterator& aEnd );
  
        void rmw_sum ( const uint32_t& aAddress , const uint32_t& aAddend );
  
        void rmw_bits ( const uint32_t& aAddress , const uint32_t& aAndTerm , const uint32_t& aOrTerm );
  
        void unknown_type();
  
        bool control_packet_header();
  
        void status_packet_header();
  
        void resend_packet_header();
  
        void unknown_packet_header();
  
  
      private:
        std::vector< uint32_t > mMemory;

        std::vector< uint32_t > mConfigurationSpace;
  
      protected:
        std::vector< uint32_t > mReceive;
        std::vector< uint32_t > mReply;
  
        std::deque< std::pair< uint32_t , std::vector< uint32_t > > > mReplyHistory;
        
        uint32_t mLastPacketHeader;
        
        std::deque< uint8_t > mTrafficHistory;
  
        std::deque< uint32_t > mReceivedControlPacketHeaderHistory;
        std::deque< uint32_t > mSentControlPacketHeaderHistory;
  
      private:
        bool mBigEndianHack;
  
    };
  }

}

#endif