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