#define RESET   "\033[0m"
#define BLACK   "\033[30m"      /* Black */
#define RED     "\033[31m"      /* Red */
#define GREEN   "\033[32m"      /* Green */
#define YELLOW  "\033[33m"      /* Yellow */
#define BLUE    "\033[34m"      /* Blue */
#define MAGENTA "\033[35m"      /* Magenta */
#define CYAN    "\033[36m"      /* Cyan */
#define WHITE   "\033[37m"      /* White */
#define BOLDBLACK   "\033[1m\033[30m"      /* Bold Black */
#define BOLDRED     "\033[1m\033[31m"      /* Bold Red */
#define BOLDGREEN   "\033[1m\033[32m"      /* Bold Green */
#define BOLDYELLOW  "\033[1m\033[33m"      /* Bold Yellow */
#define BOLDBLUE    "\033[1m\033[34m"      /* Bold Blue */
#define BOLDMAGENTA "\033[1m\033[35m"      /* Bold Magenta */
#define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
#define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */

using namespace std;

#include "RootHeader.h"

#include "Riostream.h"

#include "signal.h"

#include "Bytes.h"

#include "VMERemote.h"

#include "TProfile.h"

#include <sys/stat.h>

#define  MAXCH  16

#define  DETECTOR   "fcal"


/*
 * VMERemote
 *
 */

class VMERemote  : public TObject {
  
public:
  VMERemote(const char *pHost, int port) 
  {
    host = pHost;
    this->port = port;
    
    //    Socket = new TSocket(host, port, 32768);
    Socket = new TSocket(host, port, 32900);

    if(!Socket->IsValid())
      {
	printf("Failed to connected to host: %s\n", pHost);
	
      }
    else
      printf("Successfully connected to host: %s\n" , pHost);
    /* set board type */
    BoardType = 5;  
  }
  
  /********/
  Bool_t Reconnect() {
    if(Socket) {
      Socket->Close("force");
    };
    //    Socket =  Socket = new TSocket(host, port, 32768);
    Socket = new TSocket(host, port, 32900);
    return (Socket->IsValid());
  }
  
  /********/
  Bool_t WriteVME_SC(unsigned int addr, unsigned int val, unsigned int Status = 0, unsigned int Slot = 0)
  {
    if(!Socket->IsValid())
      {
	printf("WriteVME_SC FAILED\n");
	return kFALSE;
      }
    
    Cmd_Write_SC *pCmd_Write32;
    OutgoingMsg.Length = HTONL(REMOTE_MSG_SIZE(Cmd_Write_SC)-4);
    OutgoingMsg.BoardType = HTONL(BoardType);
    OutgoingMsg.MsgType = HTONL(REMOTE_CMD_WRITE_SC);
    pCmd_Write32 = (Cmd_Write_SC *)OutgoingMsg.Msg;

    pCmd_Write32->ID = HTONL(Slot);
    pCmd_Write32->Status = HTONL(Status);
    pCmd_Write32->Address = HTONL(addr);
    pCmd_Write32->Value = HTONL(val);

    Socket->SendRaw(&OutgoingMsg, REMOTE_MSG_SIZE(Cmd_Write_SC));
    
    
    cout << " REMOTE_MSG_SIZE = " << REMOTE_MSG_SIZE(Cmd_Write_SC) << endl;
		
    
    cout << " Outgoing: Length = " << OutgoingMsg.Length <<  " " << 
      REMOTE_MSG_SIZE(Cmd_Write_SC)-4 <<
      " Board Type = " << OutgoingMsg.BoardType <<  " " << BoardType << 
      " MsgType = " << OutgoingMsg.MsgType << " " << REMOTE_CMD_WRITE_SC << 
      " Slot = " << pCmd_Write32->ID << " " << Slot << 
      " Status = " << pCmd_Write32->Status << "  " << Status <<
      " Address = " << pCmd_Write32->Address << " " << addr << 
      " Value = " << pCmd_Write32->Value << "  " << val << endl;
    
    //		Close();
    return kTRUE;
  }

  /********/
  Bool_t ReadVME32(unsigned int addr, unsigned int *val, unsigned int Status = 0)
  {
    if(!Socket->IsValid())
      {
	printf("ReadVME32 FAILED\n");
	return kFALSE;
      }
    
    Cmd_Read32 *pCmd_Read32;
    OutgoingMsg.Length = HTONL(REMOTE_MSG_SIZE(Cmd_Read32)-4);
    OutgoingMsg.BoardType = HTONL(BoardType);
    OutgoingMsg.MsgType = HTONL(REMOTE_CMD_READ32);
    pCmd_Read32 = (Cmd_Read32 *)OutgoingMsg.Msg;
    pCmd_Read32->Address = HTONL(addr);

    Socket->SendRaw(&OutgoingMsg, REMOTE_MSG_SIZE(Cmd_Read32));       
    
    if( (Socket->RecvRaw(&IncomingMsg.Length, 4) == 4) &&
	(NTOHL(IncomingMsg.Length) <= sizeof(RemoteMsgStruct)) &&
	(Socket->RecvRaw(&IncomingMsg.BoardType, NTOHL(IncomingMsg.Length)) == (int)NTOHL(IncomingMsg.Length)) )
      {	       	
	IncomingMsg.Length = NTOHL(IncomingMsg.Length);
	IncomingMsg.BoardType = NTOHL(IncomingMsg.BoardType);
	IncomingMsg.MsgType = NTOHL(IncomingMsg.MsgType);
	unsigned int *p = (unsigned int *)IncomingMsg.Msg;
	//			if(IncomingMsg.MsgType == CMD_RSP(REMOTE_CMD_READ32))
	//			{
	*val = HTONL(*p);
	return kTRUE;
	//			}
      }
    //    Close();
    return kFALSE;
  }
  


  Bool_t ReadVME_SC_ALL(unsigned int *val, unsigned int Status = 0, unsigned int sl_first = 0, unsigned int sl_last = 0 )
  {
    if(!Socket->IsValid())
      {
	printf("ReadVME_SC_ALL FAILED\n");
	return kFALSE;
      }
        
    Cmd_Read_SC_ALL *pCmd_Read_SC_ALL;
    pCmd_Read_SC_ALL = (Cmd_Read_SC_ALL *)OutgoingMsg.Msg;
    
    OutgoingMsg.Length     = HTONL(REMOTE_MSG_SIZE(Cmd_Read_SC_ALL)-4);
    OutgoingMsg.BoardType  = HTONL(BoardType);
    OutgoingMsg.MsgType    = HTONL(REMOTE_CMD_READ_SC_ALL);
    

    pCmd_Read_SC_ALL->IDF = HTONL(sl_first);
    pCmd_Read_SC_ALL->IDL = HTONL(sl_last);

    pCmd_Read_SC_ALL->Status = HTONL(Status);
    
    Socket->SendRaw(&OutgoingMsg, REMOTE_MSG_SIZE(Cmd_Read_SC_ALL));
    
    cout << "   ReadVME_SC_ALL  SEND request.  Length = " <<  REMOTE_MSG_SIZE(Cmd_Read_SC_ALL) << endl;
    
    if( (Socket->RecvRaw(&IncomingMsg.Length, 4) == 4) &&
	(NTOHL(IncomingMsg.Length) <= sizeof(RemoteMsgStruct)))
      {
	
	Socket->RecvRaw(&IncomingMsg.BoardType, NTOHL(IncomingMsg.Length));		    
       
	cout << " ReadVME_SC_ALL receive Scalers " << endl;
	
	
	IncomingMsg.Length    = NTOHL(IncomingMsg.Length);
	IncomingMsg.BoardType = NTOHL(IncomingMsg.BoardType);
	IncomingMsg.MsgType   = NTOHL(IncomingMsg.MsgType);
	
	cout << " Length = " <<  IncomingMsg.Length  << " Board = " << 
	  IncomingMsg.BoardType  <<  " Type = " << IncomingMsg.MsgType  << endl;
	
	
	Cmd_Read_SC_ALL *p = (Cmd_Read_SC_ALL *)IncomingMsg.Msg;
	
	int status = 0;
	int slotf =  NTOHL(p->IDF);
	int slotl =  NTOHL(p->IDL);
	status =  NTOHL(p->Status);
	
	cout << " Incoming SLOT FIRST: "<< slotf <<  "   LAST: "  << slotl  <<   "    Incoming SATUS: " << status << endl;
	
	if(status < 0) return kFALSE; 	
	
	for(unsigned int bd = 0; bd < 16; bd++){

	  int bd_slot;
	  if(bd < 8) bd_slot = bd + 3;
	  else bd_slot = bd + 5;
	  
	  cout << "  FADC in slot  " <<  bd_slot  <<  endl; 
	  for(unsigned int ch = 0; ch < 17; ch++){
	    
	    val[bd*17 + ch] = NTOHL(p->Value[bd*17 + ch]);
	    cout << val[bd*17 + ch] << "  ";
	  }
	  cout << endl;
	}	
	
	return kTRUE;
      }
    
    return kFALSE;
  }



  Bool_t ReadVME_SC(unsigned int *val, unsigned int Status = 0, unsigned int Slot = 0 )
  {
    if(!Socket->IsValid())
      {
	printf("ReadVMESC FAILED\n");
	return kFALSE;
      }
    
    //    unsigned int fadc_id = 16;

    Cmd_Read_SC *pCmd_Read_SC;
    pCmd_Read_SC = (Cmd_Read_SC *)OutgoingMsg.Msg;
    
    OutgoingMsg.Length     = HTONL(REMOTE_MSG_SIZE(Cmd_Read_SC)-4);
    OutgoingMsg.BoardType  = HTONL(BoardType);
    OutgoingMsg.MsgType    = HTONL(REMOTE_CMD_READ_SC);
    
    cout<< "SLOT :"<<Slot<<endl;
    pCmd_Read_SC->ID = HTONL(Slot);
    pCmd_Read_SC->Status = HTONL(Status);
    
    Socket->SendRaw(&OutgoingMsg, REMOTE_MSG_SIZE(Cmd_Read_SC));
    
    cout << "   ReadVME_SC  SEND request.  Length = " <<  REMOTE_MSG_SIZE(Cmd_Read_SC) << endl;
    
    if( (Socket->RecvRaw(&IncomingMsg.Length, 4) == 4) &&
	(NTOHL(IncomingMsg.Length) <= sizeof(RemoteMsgStruct)))
      {
	
	// cout << "  TEST = " <<  NTOHL(IncomingMsg.Length) <<  endl;
	
       Socket->RecvRaw(&IncomingMsg.BoardType, NTOHL(IncomingMsg.Length));		    
	
	//		    cout << "  TEST = " << RecvRaw(&IncomingMsg.BoardType, NTOHL(IncomingMsg.Length)) << endl;
	
	//		  (RecvRaw(&IncomingMsg.BoardType, NTOHL(IncomingMsg.Length)) == (int)NTOHL(IncomingMsg.Length)) )
	//		{
	
	cout << " ReadVME_SC receive Scalers " << endl;
	
	
	IncomingMsg.Length    = NTOHL(IncomingMsg.Length);
	IncomingMsg.BoardType = NTOHL(IncomingMsg.BoardType);
	IncomingMsg.MsgType   = NTOHL(IncomingMsg.MsgType);
	
	cout << " Length = " <<  IncomingMsg.Length  << " Board = " << 
	  IncomingMsg.BoardType  <<  " Type = " << IncomingMsg.MsgType  << endl;
	
	
	Cmd_Read_SC *p = (Cmd_Read_SC *)IncomingMsg.Msg;
	
	int status =0;
	int fslot =  NTOHL(p->ID);
	status =  NTOHL(p->Status);
	
	cout << " Incoming SLOT: "<< fslot <<"    Incoming SATUS: " << status << endl;
	
        if(status < 0) return kFALSE; 	
	
	for(unsigned int ch = 0; ch < 17; ch++){
	  
	  val[ch] = NTOHL(p->Value[ch]);
	  cout << val[ch] << "  ";
	}
	cout << endl;
	

	return kTRUE;
      }
    
    //		Close();
    return kFALSE;
  }
  
  
  TSocket *Socket; /* socket for connection */
  const char *host;
  int port;  
  int BoardType;

private:
  RemoteMsgStruct		IncomingMsg;
  RemoteMsgStruct		OutgoingMsg;
};



class My_test  : public  TGMainFrame{
  
public: 

  My_test(const TGWindow *p) : TGMainFrame(p, 900, 450){
    
    FILE   *fd;
    char   rname[20] = "rocfcal6";    
    SetCleanup(kDeepCleanup);


    // Check if client program is already running somewhere

    CHECK_CLIENT_RUNNING(DETECTOR)

    
    // Determine port number
    
    sprintf(fname,"%s/%s.gui", fGUI_dir, rname);

    if((fd = fopen(fname,"r")) == NULL){
      printf(BOLDRED "\n  Can't open config file >%s<\n\n" RESET, fname);
      printf("\n Try to connect using the default port 9090 \n");
      Port = 9090;       
    }  else {
      fgets(str_tmp, 255, fd);
      sscanf (str_tmp, "%d\n", &Port);
      printf(BOLDBLUE "\n get Port = %d  for %s from file >%s<\n\n" RESET,Port, 
	     rname, fname);
      fclose(fd);                
    }   
    
    
    pClient  = new VMERemote(rname, Port);
     

    int nch = 32;
    Float_t x_min = 0.5, x_max = 32.5, y_min = -10,  y_max = 1000000;

        
    hfadc = new TProfile(rname,rname, nch, x_min, x_max, y_min, y_max,"");	
    hfadc->GetYaxis()->SetTitle("  Rate (Hz) ");
    hfadc->GetXaxis()->SetTitle("  Channel");
    
    hfadc->SetLabelSize(0.06,"xy");
    hfadc->SetTitleSize(0.075,"xy");
    hfadc->SetTitleOffset(0.7,"x");   
    hfadc->SetTitleOffset(0.5,"y");

    //    hfadc[11]->GetXaxis()->SetRangeUser(0.,20);

    gStyle->SetOptStat(0);
    
    gStyle->SetLineWidth(1.5);
    gStyle->SetTextSize(1.5);
    
    gStyle->SetTitleFont(30,"xy");
    gStyle->SetLabelFont(30,"xy");
    
    
    AddFrame(pFrameTop = new TGVerticalFrame(this), new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
    
    //| kLHintsCenterY
    pFrameTop->AddFrame(pFrameTimer = new TGHorizontalFrame(pFrameTop), new TGLayoutHints(kLHintsExpandX  | kLHintsTop, 0, 0, 40, 40 ));
    

    pFrameTimer->AddFrame(fTStartButton = new TGTextButton(pFrameTimer, " &Exit ", 515), 
			  new TGLayoutHints( kLHintsRight | kLHintsTop, 0, 20, 0, 0));

        
    pFrameTimer->AddFrame(pLabelTimer1 = new TGLabel(pFrameTimer, new TGString("Update Timer (sec): ")), 
			  new TGLayoutHints(kLHintsLeft, 20, 2, 2, 0));


    pFrameTimer->AddFrame(pValueTimer = new TGNumberEntry(pFrameTimer, 0, 5, 500, TGNumberFormat::kNESInteger, 
   							  TGNumberFormat::kNEAAnyNumber, TGNumberFormat::kNELLimitMinMax, 
    							  1, 20), new TGLayoutHints(kLHintsLeft, 0, 20, 0, 0));
    
    pFrameTimer->AddFrame(fExitButton = new TGTextButton(pFrameTimer, " &Start ", 510), 
			  new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 20, 0, 0));


    pFrameTimer->AddFrame(fTResetButton = new TGTextButton(pFrameTimer, " &Stop ", 511), 
			  new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 20, 0, 0));


    pFrameTimer->AddFrame(fTStopButton = new TGTextButton(pFrameTimer, " &Reset ", 512), 
			  new TGLayoutHints( kLHintsLeft | kLHintsTop, 0, 20, 0, 0));


    pValueTimer->SetIntNumber(1);       
    pValueTimer->SetWidth(50);
    
    
    
    pFrameTop->AddFrame(fF1 = new TGCompositeFrame(pFrameTop, 100,200,kHorizontalFrame), new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX |
													   kLHintsExpandY, 5, 5, 0, 0));     
    
    fF1->AddFrame(fEcanvas[0] = new TRootEmbeddedCanvas("ST",fF1,100,200), new TGLayoutHints(kLHintsLeft | kLHintsExpandX 
											     | kLHintsExpandY , 20, 0, 0, 10));
    
    
    
    //    gStyle->SetOptStat(0);   
    gStyle->SetTitleFontSize(0.08);
    
    fCanvas[0] = fEcanvas[0]->GetCanvas();
    fCanvas[0]->cd();
    hfadc->GetXaxis()->SetNdivisions(508,-1); 
    hfadc->Draw();     
    gPad->SetBottomMargin(0.16);
    gPad->SetLeftMargin(0.1);


    pValueTimer->Associate(this);

    fTStartButton->Associate(this);
    fTStopButton->Associate(this);
    fTResetButton->Associate(this);
    fExitButton->Associate(this);

    my_timer = new TTimer(this, 10, kTRUE);
    
    MapSubwindows();
    Resize(GetDefaultSize());
    Resize(900,450);
    MapWindow();


  };
  

  
  /*******/
  
  Bool_t ProcessMessage(Long_t msg, Long_t parm1, Long_t){
    
    cout << " I am here " << GET_MSG(msg) << endl;
    
    
    switch (GET_MSG(msg)) {
    case kC_COMMAND:
      {
	switch (GET_SUBMSG(msg)) {
	case kCM_BUTTON: 
	  {
	    
	    switch (parm1) {
	    case 510:
	      {
		cout << " Clicked Start Timer Button:  Activate Timer "  << "  " << pValueTimer->GetIntNumber() <<  " s " << endl;
		my_timer->Stop();
		// SASCHA
		my_timer->Start(1000*pValueTimer->GetIntNumber(),kFALSE);
		//		my_timer->Start(100*pValueTimer->GetIntNumber(),kFALSE);
		break;
	      }
	    case 511:
	      {
		cout << "  Clicked Stop Timer Button  " << endl;
		my_timer->Stop();	      
		break;
	      }
	    case 512:
	      {
		cout << " Clicked Reset Button. Reset Plots  " << endl;
		hctp_ps_nleft->Reset();
		hctp_ps_nright->Reset();
		hctp_psc_nleft->Reset();
		hctp_psc_nright->Reset();
		hctp_en->Reset();
		break;
	      }
	    case 515:
	      {
		cout << " Exit  " << endl;

                sprintf(fname,"%s/%s_client.log", fGUI_dir, dname);
                if((remove(fname)) == 0)
                    printf(" Log file deleted successfully \n\n");
                else 
                    printf(" Error: unable to delete log file \n\n");

		gApplication->Terminate();
		break;
	      }
	      break;
	    }  
	    break;
	  }
	}
	break;
      }
    case kC_TEXTENTRY:
      {
	switch(GET_SUBMSG(msg))
	  {
	  case kTE_TEXTCHANGED:
	    {
	      switch(parm1)
		{
		case 500:
		  {
		    cout << " Timer rate will be set after pressing Start button :  " << pValueTimer->GetIntNumber() << endl;
		    break;
		  }
		}
	      break;
	    }
	    break;
	  }
	break;
      }
    }
    
    return kTRUE;
    
  };


  int read_fadc_sc(VMERemote *pClient_tmp, unsigned int slot_min, unsigned int slot_max, float rate_tmp[256], int  fadc_time_prev[16][16], 
		   int fadc_sc_prev[16][256], int crate){

    Float_t  time = 0.;

    int fadc_time;

    unsigned int sc_all[272];
    
    memset(sc_all, 0, sizeof(sc_all));

    //    cout << " I am here ==== " <<  " Slot min = " << slot_min << " Slot_max = " 
    //       << slot_max <<  "pClient " << pClient_tmp << endl;
    
    if( pClient_tmp->ReadVME_SC_ALL(&sc_all[0], 0, slot_min, slot_max) ){
      
      for(int bd = 0; bd < 16; bd++){
	
	int time_cnt = 17*bd + 16;

	fadc_time = sc_all[time_cnt];

	time  =  ((Float_t) (fadc_time - fadc_time_prev[crate][bd]))*2048/1.e9;

	//	time =  ((Float_t) sc_all[time_cnt])*2048/1.e9;    /* time in sec between scalers readout (one count of scaler timer(last channel from scaler readout) is 2048ns */ 
	//	cout << " Board =  " <<  bd  <<  " FADC time prev = " << fadc_time_prev[crate][bd] << " FADC time = " << fadc_time << endl;
	//	cout << " Board =  " <<  bd  <<   " Timer =  " << time <<" sec" << endl << endl;
	
	if(time > 0) {
	  
	  for(int ch = 0; ch < MAXCH; ch++) {
	    int ch_ind    =  17*bd + ch;
	    int rate_ind  =  16*bd + ch; 
	    
	    if( (sc_all[ch_ind] - fadc_sc_prev[crate][rate_ind]) <= 0){
	      rate_tmp[rate_ind] = 0;
	    } else
	      rate_tmp[rate_ind]  =   (sc_all[ch_ind] - fadc_sc_prev[crate][rate_ind]) /time;    /*rate in Hz */ 	    
	    //	    cout <<  " CH  " <<  ch_ind <<  "   "  << sc_all[ch_ind] << "   " << rate[ch] << " Hz/s ";    	
	    fadc_sc_prev[crate][rate_ind] = sc_all[ch_ind];
	  }	  	  
	}  else {
	  int my_slot;
	  if(bd < 8) my_slot = bd + 3;
	  else my_slot  = bd + 5;
	  //	  cout <<  "-->> ERROR: Slot: " <<  my_slot << "  Timer channel(16) returns zero: Don't update Scalers rate "  << endl;
	}  // time

	fadc_time_prev[crate][bd] = fadc_time;

      }    // loop over boards
    }  else {
      
      cout << " : Error reading scalers from server:  " <<
	(pClient_tmp->Socket->GetInetAddress()).GetHostName()<<" : "<< (pClient_tmp->Socket->GetInetAddress()).GetHostAddress()<< endl;
      //** need to reconnect here?
      if(!pClient_tmp->Reconnect())  
	cout << "-->> ERROR : Cannot reconnect to server:  " <<
	  (pClient_tmp->Socket->GetInetAddress()).GetHostName()<<" : "<< (pClient_tmp->Socket->GetInetAddress()).GetHostAddress()<< endl;
      else{
	cout << "**>>  Connection to server restored:  " <<
	  (pClient_tmp->Socket->GetInetAddress()).GetHostName()<<" : "<< (pClient_tmp->Socket->GetInetAddress()).GetHostAddress()<< endl;
      }
    }
    
    return 0;
  }


  int  read_ctp_sc(VMERemote *pClient_tmp, float ctp_rate[7], unsigned long long &ctp_time_prev){

    unsigned  int ctp_sc[17];
    unsigned long long ctp_time;



    int debug_ctp = 0;

    memset(ctp_sc,0,sizeof(ctp_sc));

    if( pClient_tmp->ReadVME_SC(&ctp_sc[0], 10, 3) ) {
      
      cout << " Timestamp:  " <<  std::hex << ctp_sc[0] <<  "   " <<  ctp_sc[1]  << std::dec << endl;
      cout <<  "Left Arm Counter:   "  <<  ctp_sc[2] << endl;
      cout <<  "Right Arm Counter:  "  <<  ctp_sc[3] << endl;
      cout <<  "Coinc Counter:      "  <<  ctp_sc[4] << endl;
      
      int hit_right =   ctp_sc[5];
      int hit_left  =   ctp_sc[6];
      
      cout <<  "Hit channel   (R) :  "  <<  hit_right  <<  "    (L) :   " <<  hit_left << endl;
      
      ctp_time =   (((uint64_t) ctp_sc[0] <<32 ) | ctp_sc[1] );
      
      Float_t ctp_time_stamp  =  ((Float_t) (ctp_time - ctp_time_prev))*4./1.e9;
      
      if(debug_ctp){
	cout << std::hex << " OLD TIME =  " <<   ctp_time_prev  <<  "   NEW TIME =  " << ctp_time << std::dec << endl;
	cout <<  " TIME DIFFERENCE = " << ctp_time_stamp  << endl;
      }
      
      if( ctp_time !=  ctp_time_prev ){
	ctp_rate[2] = ctp_sc[2] / ctp_time_stamp;
	ctp_rate[3] = ctp_sc[3] / ctp_time_stamp;
	ctp_rate[4] = ctp_sc[4] / ctp_time_stamp;
	ctp_rate[5] = ctp_sc[5];
	ctp_rate[6] = ctp_sc[6];
      } else {
	ctp_rate[2] = 0;
	ctp_rate[3] = 0;
	ctp_rate[4] = 0;
	ctp_rate[5] = 0;
	ctp_rate[6] = 0;
      }

      cout << " ------------------- " << endl;
      cout << "     RATE FOR HIGH-GRAN COUNTERS   =   "  <<   ctp_rate[4]  << endl;
      cout << " ------------------- " << endl;
      
      
      ctp_time_prev = ctp_time;
      
    }

    return 0;

  }



  /*******/
  virtual Bool_t HandleTimer(TTimer *t)
  {    
        
    //    static unsigned long long ctp_time_prev_ps;
    //    static unsigned long long ctp_time_prev_psc;

    static int fadc_sc_prev[16][256];
    static int fadc_time_prev_all[16][16];


    memset(fadc_rate,  0, sizeof(fadc_rate));
    
    
    read_fadc_sc(pClient,   19, 20, fadc_rate,  fadc_time_prev_all, fadc_sc_prev, 0);
    
    UpdatePlot();
      
    
    cout << " Timer " << endl;
    return kTRUE;
  };
  

  void UpdatePlot(){
    
    hfadc->Reset();
    
    for(int ch = 224; ch < 256; ch++){  
      hfadc->Fill( (Float_t)  ch - 223, fadc_rate[ch]);	
    }
    
    fCanvas[0]->cd();	
    hfadc->Draw("histo");      
    fCanvas[0]->Update();
    
  }
  


private:

  TGVerticalFrame         *pFrameTop;
  TGHorizontalFrame       *pFrameBot;
  TGVerticalFrame         *pFrameLeft;
  TGVerticalFrame         *pFrameRight;

  TGHorizontalFrame       *pFrameLabel;
  TGHorizontalFrame       *pFrameLabel1;
  
  TGHorizontalFrame       *pFrameTimer;
  
  TGLabel                 *pLabelHost;
  TGLabel                 *pLabelTimer1;
  
  TGLabel                 *pLabelRate;
  TGLabel                 *pLabelRate1;
  
  TGNumberEntry           *pValueTimer;
  TGTextButton            *fTStartButton, *fTStopButton, *fTResetButton, *fExitButton;
  
  TProfile  *hfadc;
  
  TH1F  *hctp_ps_nleft,   *hctp_ps_nright;
  TH1F  *hctp_psc_nleft,  *hctp_psc_nright;
  TH1F  *hctp_en;

  TProfile  *hctp_ps,  *hctp_psc;



  TProfile  *hctp;
  TH1F   *hctp_nleft, *hctp_nright;

  TCanvas   *fCanvas[1];

  TRootEmbeddedCanvas *fEcanvas[1];

  TGCompositeFrame *fF1;

  TTimer *my_timer;

  TGTextBuffer *tbuf_host, *tbuf_rate, *tbuf_rate1;
  TGTextEntry  *tent_host, *tent_rate, *tent_rate1;

  Float_t  fadc_rate[256];     /*  fadc scalers for all boards in the crate, PS   */    
    
  Float_t  ctp_rate_ps[7];
  Float_t  ctp_rate_psc[7];

  VMERemote  *pClient;

  int     Port;      // Port
  string  Host;      // Host



};


/***************************************************/

/***************************************************/
int main(int argc, char* argv[])
{


	int cargc = 1;
	TApplication App("Diagnostic GUI", &cargc, argv);

	//	signal(SIGILL, SIG_DFL);
	//	signal(SIGSEGV, SIG_DFL);
	//	signal(SIGBUS, SIG_DFL);


        if (signal(SIGINT, sig_handler) == SIG_ERR)
          printf("\ncan't catch SIGINT\n");
        if (signal(SIGTERM, sig_handler) == SIG_ERR)
          printf("\ncan't catch SIGTERM\n");

	if(gROOT->IsBatch())
	{
		fprintf(stderr, "%s: cannot run in batch mode\n", argv[0]);
		return 1;
	}

	My_test *a = new  My_test(gClient->GetRoot());
	a->SetWindowName("ST FADC scalers");
	
	/* example to set the same threshold for all channels */
	//	if(a->pClient->WriteVME_SC(0, 150, 5, 16)) /* send default thresholds 150mv for all channels in slot 16*/
	//	  for(int i=0;i<16;i++) a->SetGUIThreshold(i,150);
	
	App.Run();
	
	
	return 0;
}