simulator/Simulator.h (r4864/r4162)

Go to the documentation of this file.

#ifndef ROC_SIMULATOR_H
#define ROC_SIMULATOR_H

//============================================================================
//============================================================================

#define ROC_SIMULATOR_SW_VERSION 0x02000103
#define ROC_SIMULATOR_HW_VERSION 0x02000103
#define ROC_SIMULATOR_FPGA_TYPE 1

#include "roc/defines_roc.h"
#include "roc/defines_udp.h"
#include "base/defines_gpio.h"
#include "roc/defines_i2c.h"
#include "nxyter/defines_nxyter.h"

#include <list>
#include <stdint.h>

#include <netinet/in.h>

// #define ETHER_ADDR_LEN 6
// #define IP_ADDR_LEN 4

/*****************************************************
 *
 * roc::Board Configuration Structure adapted from firmware
 *
 *****************************************************/

/*****************************************************
 * SysCore Configuration Structure
 *****************************************************/
struct sc_config
{
   uint16_t   ctrlPort;
   uint16_t   dataPort;

   int        rocNumber;
   int        flushTimeout;
};

extern struct sc_config gC;


#define RESEND_MAX_SIZE 128

#define NX_REG_SIZE  8192

#define GPIO_REG_SIZE 256


struct sc_data
{
   uint32_t  headid;          // id of buffer which is now filled

   std::list<roc::UdpDataPacketFull>  buf;

   unsigned  high_water;      /* Maximum number of buffers to be used in normal situation */
   unsigned  low_water;       /* Number of buffers to enable data taking after is was stopped */

   uint32_t  cmdsList[ROC_CMD_LST_SIZE/4]; // memory for commands lists

   uint32_t  cmdListPtr; // pointer on current active command in the list,

   uint32_t  send_limit;      /* limit for sending - can be in front of existing header */
   uint32_t  next_send_id;    /* id of next packet to send */

   uint32_t   resend_indx[RESEND_MAX_SIZE]; /* indexes of buffers which should be resent */
   unsigned   resend_size;                  /* number of indexes to be resent */

   uint32_t   last_req_pkt_id; /* id of last request packet, should be always send back */

   bool         masterConnected; // 1 if master controller is connected
   int          masterDataPort;
   int          masterPort;
   in_addr_t    masterIp;
   sockaddr_in  masterDataAddr;
   double       lastMasterTime;

   bool         controlConnected;
   int          controlPort;
   in_addr_t    controlIp;
   double       lastControlTime;

   int          controlLocked;  // 0-off , 1-master, 2-controller
   double       lockedTime;

   unsigned     daqState;

   double       lastFlushTime;

   uint32_t     droppkt_id;

   bool         data_taking_on;  /* indicate if we can take new buffer */

   uint32_t     lastMasterPacketId;
   uint8_t      master_retry_buf[MAX_UDP_PAYLOAD];
   int          master_retry_buf_rawsize;

   uint32_t     lastControlPacketId;
   uint8_t      control_retry_buf[MAX_UDP_PAYLOAD];
   int          control_retry_buf_rawsize;
};

extern struct sc_data gD;


class UdpSimulator {
   private:
      uint32_t nxRegister[NX_REG_SIZE];
      uint32_t gpioRegs[GPIO_REG_SIZE];

      uint32_t& syncMDelay() { return gpioRegs[(base::GPIO_SYNCM_SCALEDOWN - base::GPIO_CONFIG) / 4]; }
      uint32_t& gpioConfig() { return gpioRegs[0]; }

      int      s_data; // data socket
      int      s_ctrl; // control socket

      long double clockScrewUp;     // coefficient (1. is normal), which indicate screwup of clock
      uint64_t nextTimeHit;   // when hit will be generated
      unsigned nextHitCounter;  // reverse counter for hits generation
      uint64_t nextEventNumber; // current event number
      uint64_t nextTimeNoise; // indicate when time stamp message should be
      uint64_t nextTimeSync;  // indicate when next time sync message should appear
      uint64_t nextTimeAUX0;   // when next AUX signal will be
      bool     nextAUX0Falling; // indicate if aux falling or rising
      uint64_t periodAUX0;      // period of AUX0 signal
      uint64_t nextTimeAUX1;    // when next AUX signal will be
      bool     nextAUX1Falling; // indicate if aux falling or rising
      uint64_t periodAUX1;      // period of AUX1 signal
      uint32_t lastEpoch;     // last epoch set in data stream
      uint64_t nextSyncEvent; // number of next sync event

      // list of last N packets send to PC, used in resubmit
      double recvLostRate; // relative loss rate of packets receive
      double sendLostRate; // relative loss rate of packets send

      unsigned recvLostCounter; // backward counter to next recv lost
      unsigned sendLostCounter; // backward counter to next send lost

      uint64_t totalSendCounter, totalSendLosts;
      uint64_t totalRecvCounter, totalRecvLosts;

      uint32_t recvDataSize;
      uint32_t sendDataSize;
      uint32_t takeDataSize;
      roc::BoardStatistic fStat;

      bool doRecvLost();
      bool doSendLost();

      void resetSimulator();

      bool sendDataPacket(uint32_t pktid);

   public:
      UdpSimulator(int rocid, int syncscale = 2, int period0 = 0, int period1 = 0, int ctrlport = 0);
      virtual ~UdpSimulator();

      bool initNewSockets();

      void dispatchNewSockets(int tmout = 1000);

      void OnRawData(int number, const char* buf, int len, struct sockaddr*, socklen_t);

      int checkCtrlOperationAllowed(roc::UdpMessageFull* pkt, in_addr_t src_ip, int src_port);

      void mainLoop();

      uint32_t PutReg(int nodekind, uint32_t addr, uint32_t val, uint8_t* rawdata);
      uint32_t GetReg(int nodekind, uint32_t addr, uint32_t *retVal, void* rawdata = 0, int* rawdatasize = 0);
      uint32_t NOper(int nodekind, uint32_t num, uint32_t* oper);

      void fillRareSyncData(uint8_t* target, uint16_t numOfDatas);

      void makeSysMessage(uint8_t typ, uint32_t arg = 0);

      void processDataRequest(roc::UdpDataRequestFull* pkt);

      void setLostRates(double recv = 0., double send = 0.);
};

#endif /*SYSCORESIMULATOR_H_*/