ROOT logo
#ifndef __TMrbEsone_h__
#define __TMrbEsone_h__

//_________________________________________________[C++ CLASS DEFINITION FILE]
//////////////////////////////////////////////////////////////////////////////
// Name:           esone/inc/TMrbEsone.h
// Purpose:        Interface to the ESONE client library
// Class:          TMrbEsone            -- base class
// Description:    Class definitions to establish an
//                 ESONE client/server connection.
// Author:         R. Lutter
// Revision:       $Id: TMrbEsone.h,v 1.10 2007-04-17 11:22:02 Rudolf.Lutter Exp $       
// Date:           
// Keywords:
//////////////////////////////////////////////////////////////////////////////

#include "TSystem.h"
#include "TString.h"
#include "TArrayI.h"
#include "TArrayL.h"

#include "TServerSocket.h"
#include "TSocket.h"
#include "TMessage.h"

#include "TMrbNamedX.h"
#include "TMrbLofNamedX.h"

#include "TMrbEsoneCommon.h"
#include "TMrbEsoneCnaf.h"

#include "TMrbC2Lynx.h"

#define C_CBV	5
#define C_CC32	11

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbEsone
// Purpose:        Esone client within MARaBOU
// Description:    Creates an ESONE client for MARaBOU.
// Keywords:
//////////////////////////////////////////////////////////////////////////////

class TMrbEsone : public TObject {

	public:
		enum EMrbEsoneServer	{	kES_MBS 					=	0,
									kES_MARABOU					=	1
								};
		
		enum EMrbCamacController	{	kCC_CBV 				=	C_CBV,
										kCC_CC32				=	C_CC32
									};
		
		enum					{	kBroadCastSetMask_N_CC32 	=	N(26)	};
		enum					{	kBroadCastExecCmd_N_CC32 	=	N(25)	};
		enum					{	kFastCamac_F	 			=	F(5)	};
		enum					{	kAutoRead_CC32	 			=	BIT(12)	};
		enum					{	kLastError					=	-1		};
	
	public:

		TMrbEsone(Bool_t Offline = kFALSE) {								// default ctor
			if (!this->Reset(Offline)) MakeZombie();
		};		

		TMrbEsone(const Char_t * HostName, Bool_t Offline = kFALSE) {		// ctor: connect to host
			if (this->Reset(Offline)) this->ConnectToHost(HostName);
			else this->MakeZombie();
		};

		~TMrbEsone() {};											// default dtor

		Bool_t StartServer(const Char_t * HostName); 				// start esone server

// cccc: clear dataway (CAMAC-C)
		Bool_t ClearDW(Int_t Crate);		
// cccz: initialize dataway (CAMAC-Z)
		Bool_t InitDW(Int_t Crate);
// ccci: set/clear dataway inhibit (CAMAC-I)
		Bool_t SetDWInhibit(Int_t Crate, Bool_t Flag = kTRUE);
// ctci: test dataway inhibit
		Bool_t DWIsInhibited(Int_t Crate);
// ccopen: connect to camac host
		UInt_t ConnectToHost(const Char_t * HostName, Bool_t Reconnect = kFALSE);
// cfsa/cssa: single camac action
		Bool_t ExecCnaf(const Char_t * Cnaf, Bool_t D16Flag = kFALSE);
		Bool_t ExecCnaf(Int_t Crate, Int_t Station, Int_t Subaddr, Int_t Function, Bool_t D16Flag = kFALSE);
		Bool_t ExecCnaf(const Char_t * Cnaf, Int_t & Data, Bool_t D16Flag = kFALSE);
		Bool_t ExecCnaf(Int_t Crate, Int_t Station, Int_t Subaddr, Int_t Function, Int_t & Data, Bool_t D16Flag = kFALSE);
		Bool_t ExecCnaf(TMrbEsoneCnaf & Cnaf, Bool_t D16Flag = kFALSE);
// cfga/csga: multiple camac action
		Int_t ExecCnafList(TObjArray & CnafList, Bool_t D16Flag = kFALSE);
// cfmad/csmad: adress scan
		Int_t AddressScan(const Char_t * Start, const Char_t * Stop, TArrayI & Data, TObjArray & Results, Bool_t D16Flag = kFALSE);
		Int_t AddressScan(Int_t Crate, Int_t Start, Int_t Stop, Int_t Function, TArrayI & Data, TObjArray & Results, Bool_t D16Flag = kFALSE);
		Int_t AddressScan(TMrbEsoneCnaf & Start, TMrbEsoneCnaf & Stop, TArrayI & Data, TObjArray & Results, Bool_t D16Flag = kFALSE);
// cfubc/csubc, cfubr/csubr: block transfer
		Int_t BlockXfer(const Char_t * Cnaf, TArrayI & Data, Int_t Start = 0, Int_t NofWords = -1, Bool_t D16Flag = kFALSE, Bool_t QXfer = kFALSE);
		Int_t BlockXfer(Int_t Crate, Int_t Station, Int_t Subaddr, Int_t Function, TArrayI & Data, Int_t Start = 0, Int_t NofWords = -1, Bool_t D16Flag = kFALSE, Bool_t QXfer = kFALSE);
		Int_t BlockXfer(TMrbEsoneCnaf & Cnaf, TArrayI & Data, Int_t Start = 0, Int_t NofWords = -1, Bool_t D16Flag = kFALSE, Bool_t QXfer = kFALSE);

// ctstat: get status of last camac action
		UInt_t GetStatus(Bool_t & XFlag, Bool_t & QFlag, Int_t & ErrorCode, TString & Error);
		const Char_t * GetError(TString & Error);

// camac host
		TMrbNamedX * GetHost(UInt_t HostAddr); 								// get host by addr
		TMrbNamedX * GetHost(const Char_t * HostName); 						// get host by name
		inline void SetOffline(Bool_t Offline = kTRUE) { fOffline = Offline; };
		inline Bool_t IsOffline() { return(fOffline); };			// hardware access simulated by software?
		
// camac data
		inline void ClearStatus() { fStatus = 0; };
		inline void SetX() { fStatus |= (UInt_t) kEsoneX; };
		inline void SetQ() { fStatus |= (UInt_t) kEsoneQ; };
		inline void SetXQ() { fStatus |= (UInt_t) (kEsoneQ|kEsoneX); };
		inline void SetError() { fStatus |= (UInt_t) kEsoneError; };

		inline Bool_t GetX() { return(IS_X(fStatus)); };
		inline Bool_t GetQ() { return(IS_Q(fStatus)); };
		inline Bool_t IsError() { return(IS_ERROR(fStatus)); };

		inline TMrbNamedX * GetAction() { return(fAction); };	// return action
		inline void SetAction(EMrbEsoneCamacAction Action) { fAction = fLofCamacActions.FindByIndex(Action); };

// broadcast
		Bool_t HasBroadCast();										// test broadcast capability
		Bool_t HasBroadCast(Int_t & NsetMask, Int_t & NexecCmd);
		Bool_t SetBroadCast(Int_t Crate, UInt_t BroadCast);			// write broadcast register
		inline Bool_t ClearBroadCast(Int_t Crate) { return(this->SetBroadCast(Crate, 0)); };
		Bool_t AddToBroadCast(Int_t Crate, Int_t Station); 			// add station to broadcast mask
		Bool_t RemoveFromBroadCast(Int_t Crate, Int_t Station); 	// remove station from broadcast mask
		UInt_t GetBroadCast(Int_t Crate);							// get bc mask register
		inline void UseBroadCast(Bool_t Flag) { fUseBroadCast = Flag; };	// turn bc on/off (if possible)
						
// special camac functions
		Bool_t HasFastCamac();										// test fast camac capability (returns function F)
		Bool_t SetAutoRead(Int_t Crate, Bool_t AutoRead = kTRUE);	// enable/disable auto-read (CC32 only)
		Bool_t ReadDoubleWord(Int_t Crate, Bool_t ReadDW = kTRUE);	// enable/disable 32 bit read (CC32 only)
		
// misc
		void Print(Option_t * Option) const { TObject::Print(Option); }
		void Print(TMrbEsoneCnaf & Cnaf);									// print single cnaf
		void Print(TObjArray & CnafList, Int_t From = 0, Int_t To = -1);	// print cnaf from list
		void PrintError(const Char_t * EsoneCall, const Char_t * Method);	// print error
		void PrintStatus(const Char_t * Method); 							// print status of last camac action

		Bool_t ReadFromFile(const Char_t * FileName) { return(kTRUE); };	// read cnaf list from file (not yet implemented)

		inline const Char_t * GetServerName() { return(fServerType.GetName()); };	// name/index of camac controller used
		inline Int_t GetServerIndex() { return(fServerType.GetIndex()); };
		inline Bool_t IsMarabouServer() { return(fServerType.GetIndex() == kES_MARABOU); };
		inline Bool_t IsMbsServer() { return(fServerType.GetIndex() == kES_MBS); };
		
		inline TSocket * GetSocket() { return(fSocket); };

		inline const Char_t * GetControllerName() { return(fController.GetName()); };	// name/index of camac controller used
		inline Int_t GetControllerIndex() { return(fController.GetIndex()); };
		
		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

		inline void SetVerboseMode(Bool_t VerboseFlag = kTRUE) { fVerboseMode = VerboseFlag; };	// verbose mode on/off
		inline Bool_t IsVerbose() { return(fVerboseMode); };

		inline void Abort() { fAborted = kTRUE; };
		inline Bool_t IsAborted() { return(fAborted); };

		inline Bool_t IsConnected() { return(fHostAddr > 0); };

		inline void SetSingleStep(Bool_t Flag = kTRUE) { fSingleStep = Flag; };
		inline Bool_t IsSingleStep() { return(fSingleStep); };

	public:
		TMrbLofNamedX fLofCamacActions;								// list of camac actions
		TMrbLofNamedX fLofCnafNames;								// list of camac registers
		TMrbLofNamedX fLofCnafTypes;								// list of cnaf types
		TMrbLofNamedX fLofEsoneServers;								// list of esone servers available
		TMrbLofNamedX fLofControllers;								// list of camac controllers available
		TMrbLofNamedX fLofCamacFunctions;							// list of camac function types

	protected:
		Bool_t StartMbsServer(const Char_t * HostName); 			// start esone server (MBS)
		Bool_t StartMarabouServer(const Char_t * HostName); 		// ... (MARaBOU)

		Bool_t Reset(Bool_t Offline = kFALSE);						// reset internal data base
		Bool_t CheckConnection(const Char_t * Method);				// check if connected to host
		Bool_t CheckCrate(Int_t Crate, const Char_t * Method); 		// check if crate number is legal

		void PrintResults(const Char_t * Method, TMrbEsoneCnaf & Cnaf);
		void PrintResults(const Char_t * Method, TObjArray & CnafList);

	protected:																	// ESONE calls
		Bool_t EsoneCDREG(UInt_t & Handle, Int_t Crate, Int_t Station = 0, Int_t SubAddr = 0);	// [cdreg] encode cnaf + host addr	
		Bool_t EsoneCDREG(UInt_t & Handle, TMrbEsoneCnaf & Cnaf);	
		Bool_t EsoneCDCTRL();													// [cdctrl] define controller	
		Bool_t EsoneCCCC(Int_t Crate);											// [cccc] camac "c" (clear dataway)
		Bool_t EsoneCCOPEN(const Char_t * HostName, UInt_t & HostAddress);		// [ccopen] camac connect
		Bool_t EsoneCCCI(Int_t Crate, Bool_t Inhibit = kTRUE);					// [ccci] camac "i" (inhibit dataway)
		Bool_t EsoneCTCI(Int_t Crate);											// [ctci] test dw inh
		Bool_t EsoneCCCZ(Int_t Crate);											// [cccz] camac "z" (init dataway)
		UInt_t EsoneCTSTAT();													// [ctstat] test status
		Bool_t EsoneCXSA(TMrbEsoneCnaf & Cnaf, Bool_t D16Flag);					// [cssa, cfsa] exec single cnaf
		Int_t EsoneCXGA(TObjArray & CnafList, Bool_t D16Flag);					// [csga, cfga] exec cnaf list
		Int_t EsoneCXMAD(TMrbEsoneCnaf & Start, TMrbEsoneCnaf & Stop,			// [csmad, cfmad] adress scan
									TArrayI & Data, TObjArray & Results, Bool_t D16Flag);
																				// [csubr, cfubr, csubc, cfubc] block xfer
		Int_t EsoneCXUBX(TMrbEsoneCnaf & Cnaf, TArrayI & Data, Int_t First, Int_t Last, Bool_t D16Flag, Bool_t QXfer);

		Bool_t EsoneSpecial(EMrbEsoneCnafType Type, Int_t Crate, Int_t Station, Int_t Subaddr, Int_t Function, Int_t & Data, Bool_t D16Flag);

		const Char_t * EsoneCERROR(TString & ErrMsg, Int_t ErrorCode, Bool_t DateFlag);
 
		inline void SetCB(TArrayI & CB, Int_t Repeat = 0, Int_t Tally = 0, Int_t Lam = 0, Int_t DMA = 0)  {
			CB[0] = Repeat; CB[1] = Tally; CB[2] = Lam; CB[3] = DMA;
		};

	protected:
		Bool_t fVerboseMode;						// kTRUE if verbose mode on
		Bool_t fUseBroadCast;						// kTRUE if broadcast mode is to be used
		Bool_t fOffline;							// access camac hardware?
		Bool_t fAborted;							// kTRUE if operation aborted
		Bool_t fSingleStep; 						// kTRUE if in single step mode

		TMrbNamedX * fAction;						// last camac action
		UInt_t fStatus;								// status of last camac action

		TMrbNamedX fServerType; 					// server type (name+index)
		TMrbNamedX fController; 					// camac controller used (name+index)
		
		TString fHost;								// host name
		TString fHostInet;							// full inet address
		Int_t fHostAddr;							// ESONE host address
		TString fSetupPath;							// where to fond setup files
		TString fServerPath;						// where to start server from
		TString fServerProg;						// server program
		TMrbC2Lynx * fLynxClient;					// client to lynxos/vme
		TSocket * fSocket;							//! connection to server
		Int_t fPort;								// port number
		Int_t fNofCrates;							// number of crates in use
		Int_t fCC32Base; 							// base address (CC32 only)
		Int_t fBufferSize;							// tcp buffer size		

	ClassDef(TMrbEsone, 1)		// [Access to CAMAC] Establish connection via ESONE calls
};

#endif
 TMrbEsone.h:1
 TMrbEsone.h:2
 TMrbEsone.h:3
 TMrbEsone.h:4
 TMrbEsone.h:5
 TMrbEsone.h:6
 TMrbEsone.h:7
 TMrbEsone.h:8
 TMrbEsone.h:9
 TMrbEsone.h:10
 TMrbEsone.h:11
 TMrbEsone.h:12
 TMrbEsone.h:13
 TMrbEsone.h:14
 TMrbEsone.h:15
 TMrbEsone.h:16
 TMrbEsone.h:17
 TMrbEsone.h:18
 TMrbEsone.h:19
 TMrbEsone.h:20
 TMrbEsone.h:21
 TMrbEsone.h:22
 TMrbEsone.h:23
 TMrbEsone.h:24
 TMrbEsone.h:25
 TMrbEsone.h:26
 TMrbEsone.h:27
 TMrbEsone.h:28
 TMrbEsone.h:29
 TMrbEsone.h:30
 TMrbEsone.h:31
 TMrbEsone.h:32
 TMrbEsone.h:33
 TMrbEsone.h:34
 TMrbEsone.h:35
 TMrbEsone.h:36
 TMrbEsone.h:37
 TMrbEsone.h:38
 TMrbEsone.h:39
 TMrbEsone.h:40
 TMrbEsone.h:41
 TMrbEsone.h:42
 TMrbEsone.h:43
 TMrbEsone.h:44
 TMrbEsone.h:45
 TMrbEsone.h:46
 TMrbEsone.h:47
 TMrbEsone.h:48
 TMrbEsone.h:49
 TMrbEsone.h:50
 TMrbEsone.h:51
 TMrbEsone.h:52
 TMrbEsone.h:53
 TMrbEsone.h:54
 TMrbEsone.h:55
 TMrbEsone.h:56
 TMrbEsone.h:57
 TMrbEsone.h:58
 TMrbEsone.h:59
 TMrbEsone.h:60
 TMrbEsone.h:61
 TMrbEsone.h:62
 TMrbEsone.h:63
 TMrbEsone.h:64
 TMrbEsone.h:65
 TMrbEsone.h:66
 TMrbEsone.h:67
 TMrbEsone.h:68
 TMrbEsone.h:69
 TMrbEsone.h:70
 TMrbEsone.h:71
 TMrbEsone.h:72
 TMrbEsone.h:73
 TMrbEsone.h:74
 TMrbEsone.h:75
 TMrbEsone.h:76
 TMrbEsone.h:77
 TMrbEsone.h:78
 TMrbEsone.h:79
 TMrbEsone.h:80
 TMrbEsone.h:81
 TMrbEsone.h:82
 TMrbEsone.h:83
 TMrbEsone.h:84
 TMrbEsone.h:85
 TMrbEsone.h:86
 TMrbEsone.h:87
 TMrbEsone.h:88
 TMrbEsone.h:89
 TMrbEsone.h:90
 TMrbEsone.h:91
 TMrbEsone.h:92
 TMrbEsone.h:93
 TMrbEsone.h:94
 TMrbEsone.h:95
 TMrbEsone.h:96
 TMrbEsone.h:97
 TMrbEsone.h:98
 TMrbEsone.h:99
 TMrbEsone.h:100
 TMrbEsone.h:101
 TMrbEsone.h:102
 TMrbEsone.h:103
 TMrbEsone.h:104
 TMrbEsone.h:105
 TMrbEsone.h:106
 TMrbEsone.h:107
 TMrbEsone.h:108
 TMrbEsone.h:109
 TMrbEsone.h:110
 TMrbEsone.h:111
 TMrbEsone.h:112
 TMrbEsone.h:113
 TMrbEsone.h:114
 TMrbEsone.h:115
 TMrbEsone.h:116
 TMrbEsone.h:117
 TMrbEsone.h:118
 TMrbEsone.h:119
 TMrbEsone.h:120
 TMrbEsone.h:121
 TMrbEsone.h:122
 TMrbEsone.h:123
 TMrbEsone.h:124
 TMrbEsone.h:125
 TMrbEsone.h:126
 TMrbEsone.h:127
 TMrbEsone.h:128
 TMrbEsone.h:129
 TMrbEsone.h:130
 TMrbEsone.h:131
 TMrbEsone.h:132
 TMrbEsone.h:133
 TMrbEsone.h:134
 TMrbEsone.h:135
 TMrbEsone.h:136
 TMrbEsone.h:137
 TMrbEsone.h:138
 TMrbEsone.h:139
 TMrbEsone.h:140
 TMrbEsone.h:141
 TMrbEsone.h:142
 TMrbEsone.h:143
 TMrbEsone.h:144
 TMrbEsone.h:145
 TMrbEsone.h:146
 TMrbEsone.h:147
 TMrbEsone.h:148
 TMrbEsone.h:149
 TMrbEsone.h:150
 TMrbEsone.h:151
 TMrbEsone.h:152
 TMrbEsone.h:153
 TMrbEsone.h:154
 TMrbEsone.h:155
 TMrbEsone.h:156
 TMrbEsone.h:157
 TMrbEsone.h:158
 TMrbEsone.h:159
 TMrbEsone.h:160
 TMrbEsone.h:161
 TMrbEsone.h:162
 TMrbEsone.h:163
 TMrbEsone.h:164
 TMrbEsone.h:165
 TMrbEsone.h:166
 TMrbEsone.h:167
 TMrbEsone.h:168
 TMrbEsone.h:169
 TMrbEsone.h:170
 TMrbEsone.h:171
 TMrbEsone.h:172
 TMrbEsone.h:173
 TMrbEsone.h:174
 TMrbEsone.h:175
 TMrbEsone.h:176
 TMrbEsone.h:177
 TMrbEsone.h:178
 TMrbEsone.h:179
 TMrbEsone.h:180
 TMrbEsone.h:181
 TMrbEsone.h:182
 TMrbEsone.h:183
 TMrbEsone.h:184
 TMrbEsone.h:185
 TMrbEsone.h:186
 TMrbEsone.h:187
 TMrbEsone.h:188
 TMrbEsone.h:189
 TMrbEsone.h:190
 TMrbEsone.h:191
 TMrbEsone.h:192
 TMrbEsone.h:193
 TMrbEsone.h:194
 TMrbEsone.h:195
 TMrbEsone.h:196
 TMrbEsone.h:197
 TMrbEsone.h:198
 TMrbEsone.h:199
 TMrbEsone.h:200
 TMrbEsone.h:201
 TMrbEsone.h:202
 TMrbEsone.h:203
 TMrbEsone.h:204
 TMrbEsone.h:205
 TMrbEsone.h:206
 TMrbEsone.h:207
 TMrbEsone.h:208
 TMrbEsone.h:209
 TMrbEsone.h:210
 TMrbEsone.h:211
 TMrbEsone.h:212
 TMrbEsone.h:213
 TMrbEsone.h:214
 TMrbEsone.h:215
 TMrbEsone.h:216
 TMrbEsone.h:217
 TMrbEsone.h:218
 TMrbEsone.h:219
 TMrbEsone.h:220
 TMrbEsone.h:221
 TMrbEsone.h:222
 TMrbEsone.h:223
 TMrbEsone.h:224
 TMrbEsone.h:225
 TMrbEsone.h:226
 TMrbEsone.h:227
 TMrbEsone.h:228
 TMrbEsone.h:229
 TMrbEsone.h:230
 TMrbEsone.h:231
 TMrbEsone.h:232
 TMrbEsone.h:233
 TMrbEsone.h:234
 TMrbEsone.h:235
 TMrbEsone.h:236
 TMrbEsone.h:237
 TMrbEsone.h:238
 TMrbEsone.h:239
 TMrbEsone.h:240
 TMrbEsone.h:241
 TMrbEsone.h:242
 TMrbEsone.h:243
 TMrbEsone.h:244
 TMrbEsone.h:245
 TMrbEsone.h:246
 TMrbEsone.h:247
 TMrbEsone.h:248