Blame |
Last modification |
View Log
| RSS feed
#include "easiroc.h"
static const int SiTCP_PORT
= 24;
unsigned int slowdata
[sizeByte_SC
];
unsigned int ReadSCdata
[sizeByte_RSC
];
unsigned int Probedata
[sizeByte_PSC
];
unsigned int Pindata
[sizeByte_PIN
];
//------------------------------------------------------------------------------------------------------
int easiroc_Init
(const char* SiTCP_MASTER_IP
, unsigned int daq_mode
)
{
// Start WinSock
printf("easiroc_Init --> Start.\n");
WORD wVersionRequested
;
WSADATA wsaData
;
if (WSAStartup
(MAKEWORD
(2, 2), &wsaData
) != 0) {
printf("WSAStartup failed with error!\n");
}
//Initialize -------------------------------------------------------------
SOCKET sock
= INVALID_SOCKET
;
struct sockaddr_in SiTCP_ADDR
;
const char* IP
;
unsigned int port
;
sock
= socket
(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
if(sock
== INVALID_SOCKET
) {
printf("easiroc_Init::sock = %d\n", sock
);
return -1;
}
IP
= SiTCP_MASTER_IP
;
port
= SiTCP_PORT
;
SiTCP_ADDR.
sin_family = AF_INET
;
SiTCP_ADDR.
sin_port = htons
(port
);
SiTCP_ADDR.
sin_addr.
s_addr = inet_addr
(IP
);
struct timeval tv
;
tv.
tv_sec = 3;
tv.
tv_usec = 0;
setsockopt
(sock
, SOL_SOCKET
, SO_RCVTIMEO
, (char*)&tv
, sizeof(tv
));
int flag
= 1;
setsockopt
(sock
, IPPROTO_TCP
, TCP_NODELAY
, (char*)&flag
, sizeof(flag
));
//Connection -------------------------------------------------------------
int con
= connect
(sock
, (struct sockaddr
*)&SiTCP_ADDR
, sizeof(SiTCP_ADDR
));
printf("easiroc_Init::connect = %d\n", con
);
if(0 > con
){
printf("SiTCP Master :: Connection fail\n");
closesocket
(sock
);
return -1;
}
printf("SiTCP Master :: Connection Done\n\n");
// Auto Initialize -------------------------------------------------------
PrepareFPGA
();
DebugFPGA
(sock
);
printf("\nASIS Initialize : Done\n\n");
// Sleep(10000);
WriteData
(sock
, 37888);
PrepareSC
(1);
TransmitSC
(sock
);
printf("\nSlow Control chip1 : Done\n\n");
PrepareReadSC
(1);
TransmitReadSC
(sock
);
printf("\nRead Slow Control chip1 : Done\n\n");
WriteData
(sock
, 21504);
PrepareSC
(2);
TransmitSC
(sock
);
printf("\nSlow Control chip2 : Done\n\n");
PrepareReadSC
(2);
TransmitReadSC
(sock
);
printf("\nRead Slow Control chip2: Done\n\n");
WriteData
(sock
, 5120);
{
unsigned int signal
= 31;
signal
= signal
<< 16;
unsigned int data
= daq_mode
;
data
= data
<< 8;
signal
+= data
;
if(-1 == WriteData
(sock
, signal
)){
return -1;
}
printf("\n#D : DAQ mode is %d \n", daq_mode
);
}
return 0;
}
//------------------------------------------------------------------------------------------------------
void easiroc_Close
()
{
WSACleanup
();
printf("easiroc_Close -> Done.\n");
}
//------------------------------------------------------------------------------------------------------
int WriteData
(SOCKET sock
, unsigned int data
)
{
int esrcdbg
= 0;
Sleep
(SOCK_DELAY
);
data
+= 128 << 24;;
if(esrcdbg
) printf("0x%X\n", data
);
send
(sock
, (char*)&data
, sizeof(int), 0);
Sleep
(SOCK_DELAY
);
unsigned int buf
= 0;
unsigned int length
= 4;
int ret
= recv
(sock
, (char*)&buf
, length
, 0);
if ( ret
> 0 ) {
if(esrcdbg
) printf("Bytes received: %d\n", ret
);
else printf(".");
} else if ( ret
== 0 ) {
printf("Connection closed\n");
return -1;
} else {
printf("recv failed: %d\n", WSAGetLastError
());
return -1;
}
return 0;
}
//------------------------------------------------------------------------------------------------------
void PrepareFPGA
()
{
Pindata
[0] = 20;
Pindata
[1] = 65776;
}
//------------------------------------------------------------------------------------------------------
void PrepareSC
(int chipNo
)
{
if(chipNo
== 1) {
slowdata
[0] = 192;
slowdata
[1] = 1720319;
slowdata
[2] = 4253040640;
slowdata
[3] = 413;
slowdata
[4] = 0;
slowdata
[5] = 3739423232;
slowdata
[6] = 4294967295;
slowdata
[7] = 4294967295;
slowdata
[8] = 4294967295;
slowdata
[9] = 4294967295;
slowdata
[10] = 4294967295;
slowdata
[11] = 4294967295;
slowdata
[12] = 4294967295;
slowdata
[13] = 4294967295;
slowdata
[14] = 4294967295;
} else {
slowdata
[0] = 192;
slowdata
[1] = 4292874239;
slowdata
[2] = 4257218559;
slowdata
[3] = 478;
slowdata
[4] = 0;
slowdata
[5] = 3740340736;
slowdata
[6] = 1175693740;
slowdata
[7] = 2815957775;
slowdata
[8] = 766945147;
slowdata
[9] = 1504433946;
slowdata
[10] = 2729016485;
slowdata
[11] = 3412554245;
slowdata
[12] = 2725848728;
slowdata
[13] = 2267165112;
slowdata
[14] = 4291041547;
}
}
//------------------------------------------------------------------------------------------------------
void PrepareReadSC
(int chipNo
)
{
if(chipNo
== 1) {
ReadSCdata
[0] = 0;
} else {
ReadSCdata
[0] = 1;
}
}
//------------------------------------------------------------------------------------------------------
int DebugFPGA
(SOCKET socket
)
{
unsigned int buffer
= 0;
buffer
+= 0 << 16;
buffer
+= (Pindata
[0] & 255) << 8;
if(-1 == WriteData
(socket
, buffer
)){
return -1;
}
for(int i
= 1 ; i
<5; ++i
){
buffer
= 0;
if(i
== 4){
buffer
+= 5 << 16;
}else{
buffer
+= i
<< 16;
}
buffer
+= ((Pindata
[1] >> (i
-1)*8) & 255) << 8;
if(-1 == WriteData
(socket
, buffer
)){
return -1;
}
Sleep
(1);
}
return 0;
}
//------------------------------------------------------------------------------------------------------
int TransmitSC
(SOCKET socket
){
unsigned int data
= 0;
//Set SC mode -----------------------------------------------------------
data
= 0;
data
+= 1 << 16;
data
+= 240 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
//SC start -------------------------------------------------------------
data
= 0;
data
+= 10 << 16;
data
+= (slowdata
[0] & 255) << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
for(int i
= 1; i
<15; ++i
){
for(int shift
= 0; shift
<4; ++shift
){
data
= 0;
data
+= 10 << 16;
data
+= ((slowdata
[i
] >> 8*shift
) & 255) << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
//std::cout<<"test"<<std::endl;
Sleep
(1);
}
}
// Sleep(50000);
//StartCycle -----------------------------------------------------------
data
= 0;
data
+= 1 << 16;
data
+= 242 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
data
= 0;
data
+= 1 << 16;
data
+= 240 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
// Sleep(50000);
//Load SC --------------------------------------------------------------
data
= 0;
data
+= 1 << 16;
data
+= 241 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
data
= 0;
data
+= 1 << 16;
data
+= 240 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
return 0;
}
//------------------------------------------------------------------------------------------------------
int TransmitReadSC
(SOCKET socket
)
{
//SCA read ---------------------------------------------------------------
unsigned int data
= 0;
for(int i
= 0; i
<4; ++i
){
data
= 0;
data
+= 12 << 16;
data
+= ((ReadSCdata
[0] >> i
*8) & 255) << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
Sleep
(1);
}
//StartCycle ------------------------------------------------------------
data
= 0;
data
+= 1 << 16;
data
+= 242 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
data
= 0;
data
+= 1 << 16;
data
+= 240 << 8;
if(-1 == WriteData
(socket
, data
)){
return -1;
}
return 0;
}
//------------------------------------------------------------------------------------------------------
/*
#include"src/easiroc.h"
#include"src/SC.hh"
#include<fstream>
#include<ios>
static const int SiTCP_PORT = 24;
extern unsigned int slowdata[sizeByte_SC];
extern unsigned int ReadSCdata[sizeByte_RSC];
extern unsigned int Probedata[sizeByte_PSC];
extern unsigned int Pindata[sizeByte_PIN];
int ForceStop = 0;
int EndADC = 0;
void ForceStop_FromCtrl_C(int signal);
int receive(int sock, char* data_buf, unsigned int *ReadLength);
int WriteData(int socket, unsigned int data);
int ReadData(int socket, unsigned int signal, unsigned int data);
void ADCStop(int socket);
int DebugFPGA(int socket);
int TransmitSC(int socket);
int TransmitReadSC(int socket);
int TransmitProbe(int socket);
int ContinuousADC(int socket);
int ContinuousADC_ver2(int socket);
void ADCOneCycle(int socket, std::ofstream& file);
void ADCOneCycle_wHeader(int socket, std::ofstream& file);
int ADCOneCycle_wHeader_ver2(int socket, std::ofstream& file);
void MHTDC_debug(int socket);
int Debugging(int socket);
int chipselect();
int main(int argc, char* argv[]){
if(1 == argc){
std::cout << "Usage\n";
std::cout << "./easiroc [IP Address of SOY] [DAQ mode]" << std::e\
ndl;
std::cout << " DAQ mode : 1 MHTDC\n";
std::cout << " : 2 ADC\n";
std::cout << " : 3 ADC & MHTDC" << std::endl;
exit(-1);
}
unsigned int daq_mode = (unsigned int)atoi(argv[2]);
const char* SiTCP_MASTER_IP = argv[1];
int sock = 0;
struct sockaddr_in SiTCP_ADDR;
const char* IP;
unsigned int port;
//Initialize -------------------------------------------------------------
ForceStop = 0;
(void) signal(SIGINT, ForceStop_FromCtrl_C);
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
IP = SiTCP_MASTER_IP;
port = SiTCP_PORT;
SiTCP_ADDR.sin_family = AF_INET;
SiTCP_ADDR.sin_port = htons(port);
SiTCP_ADDR.sin_addr.s_addr = inet_addr(IP);
struct timeval tv;
tv.tv_sec = 3;
tv.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(tv));
int flag = 1;
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag));
//Connection -------------------------------------------------------------
if(0 > connect(sock, (struct sockaddr*)&SiTCP_ADDR, sizeof(SiTCP_ADDR))){
std::cerr << "SiTCP Master :: Connection fail" << std::endl;
close(sock);
return -1;
}
std::cout << "SiTCP Master :: Connection Done" << std::endl;
std::cout << std::endl;
// Auto Initialize -------------------------------------------------------
PrepareFPGA();
DebugFPGA(sock);
std::cout << "ASIS Initialize : Done" << std::endl;
std::cout << std::endl;
usleep(10000);
WriteData(3, 37888);
PrepareSC(1);
TransmitSC(sock);
std::cout << "Slow Control chip1 : Done" << std::endl;
std::cout << std::endl;
PrepareReadSC(1);
TransmitReadSC(sock);
std::cout << "Read Slow Control chip1 : Done" << std::endl;
std::cout << std::endl;
WriteData(3, 21504);
PrepareSC(2);
TransmitSC(sock);
std::cout << "Slow Control chip2 : Done" << std::endl;
std::cout << std::endl;
PrepareReadSC(2);
TransmitReadSC(sock);
std::cout << "Read Slow Control chip2: Done" << std::endl;
std::cout << std::endl;
WriteData(3, 5120);
{
unsigned int signal = 31;
signal = signal << 16;
unsigned int data = daq_mode;
data = data << 8;
signal += data;
if(-1 == WriteData(sock, signal)){
exit(-1);
}
std::cout << "#D : DAQ mode is " << daq_mode << std::endl;
}
// User area -----------------------------------------------------------
bool DispMenu = true;
int CurrentCh = 0;
while(DispMenu){
for(int i = 0; i<3; ++i){
std::cout << std::endl;
}
std::cout << "I'm : " << SiTCP_MASTER_IP << std::endl;
std::cout << "Please select" << std::endl;
std::cout << " 1. Transmit SC" << std::endl;
std::cout << " 2. Transmit Read SC" << std::endl;
std::cout << " 3. ASIC Initialize" << std::endl;
std::cout << " 4. Transmit Probe " << std::endl;
std::cout << " 5. Connection Close" << std::endl;
std::cout << " 6. Start DAQ" << std::endl;
std::cout << " 7. Debug" << std::endl;
std::cout << "input # ====> " << std::flush;
char buf[10];
fgets(buf, sizeof(buf),stdin);
char num;
sscanf(buf,"%c",&num);
switch(num){
case '1':
WriteData(3, 37888);
PrepareSC(1);
TransmitSC(sock);
WriteData(3, 21504);
PrepareSC(2);
TransmitSC(sock);
WriteData(3, 5120);
break;
case '2':
WriteData(3, 37888);
PrepareReadSC(1);
TransmitReadSC(sock);
WriteData(3, 21504);
PrepareReadSC(2);
TransmitReadSC(sock);
WriteData(3, 5120);
break;
case '3':
PrepareFPGA();
DebugFPGA(sock);
break;
case '4':
std::cout << "Input channel number ====> " << std::endl;
std::cin >> CurrentCh;
fgets(&buf[0],sizeof(buf),stdin); //Enter buffer clear
if(CurrentCh < 32){
WriteData(3, 37888);
}
else if(CurrentCh > 31){
WriteData(3, 21504);
CurrentCh = CurrentCh - 32;
}
std::cout<<CurrentCh<<std::endl;
PreparePSC(CurrentCh);
TransmitProbe(sock);
//WriteData(3, 5120);
break;
case '5':
DispMenu = false;
break;
case '6':
ContinuousADC_ver2(sock);
break;
case '7':
Debugging(sock);
break;
case '8':
MHTDC_debug(sock);
break;
case '9':
chipselect();
break;
default:
break;
};
}
//End Connection ---------------------------------------------------------
close(sock);
std::cout << "All :: Connection Close" << std::endl;
return 0;
}
void ForceStop_FromCtrl_C(int signal){
std::cout << "Stop request from user" << std::endl;
ForceStop = 1;
EndADC = 1;
}
int receive(int sock, char* data_buf, unsigned int *ReadLength){
unsigned int revd_size = 0;
int tmp_returnVal = 0;
while(revd_size < *ReadLength){
tmp_returnVal = recv(sock, data_buf +revd_size, *ReadLength -revd_size, 0);
if(tmp_returnVal < 0){
int errbuf = errno;
perror("TCP receive");
if(errbuf == EAGAIN){
if(EndADC == 1){
std::cout << "No data" << std::endl;
break;
}
continue;
}else if(errbuf == EINTR){
continue;
}else{
exit(-1);
}
}
revd_size += tmp_returnVal;
}
// std::cout << "ret is " << std::dec << revd_size << std::endl;
return revd_size;
}
int WriteData(int sock, unsigned int data){
data += 128 << 24;
// for(int i = 31; i>-1; --i){
// unsigned int hoge = (data >> i) & 1;
// if(hoge){
// fprintf(stdout, "!");
// }else{
// fprintf(stdout, ".");
// }
// if(i%8 == 0){
// fprintf(stdout, "\n");
// }
// }
// fprintf(stdout, "\n");
// std::cout << std::hex << data << std::endl;
send(sock, (char*)&data, sizeof(int), 0);
unsigned int buf = 0;
unsigned int length = 4;
receive(sock, (char*)&buf, &length);
if(data - buf){
std::cerr << "### Data Transmit Error ###" << std::endl;
std::cerr << "Transmited data is " << std::hex << data << std::endl;
std::cout << "Returned data is " << std::hex << buf << std::endl;
return -1;
}
return 0;
}
int ReadData(int sock, unsigned int signal, unsigned int *data){
signal += 64 << 24;
send(sock, (char*)&signal, sizeof(int), 0);
unsigned int length = 4;
receive(sock, (char*)data, &length);
// for(int i = 31; i>-1; --i){
// unsigned int hoge = (*data >> i) & 1;
// if(hoge){
// fprintf(stdout, "!");
// }else{
// fprintf(stdout, ".");
// }
// if(i%8 == 0){
// fprintf(stdout, "\n");
// }
// }
// fprintf(stdout, "\n");
return 0;
}
int DebugFPGA(int socket){
unsigned int buffer = 0;
buffer += 0 << 16;
buffer += (Pindata[0] & 255) << 8;
if(-1 == WriteData(socket, buffer)){
exit(-1);
}
for(int i = 1 ; i<5; ++i){
buffer = 0;
if(i == 4){
buffer += 5 << 16;
}else{
buffer += i << 16;
}
buffer += ((Pindata[1] >> (i-1)*8) & 255) << 8;
if(-1 == WriteData(socket, buffer)){
exit(-1);
}
usleep(1);
}
return 0;
}
int TransmitSC(int socket){
unsigned int data = 0;
//Set SC mode -----------------------------------------------------------
data = 0;
data += 1 << 16;
data += 240 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
//SC start -------------------------------------------------------------
data = 0;
data += 10 << 16;
data += (slowdata[0] & 255) << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
for(int i = 1; i<15; ++i){
for(int shift = 0; shift<4; ++shift){
data = 0;
data += 10 << 16;
data += ((slowdata[i] >> 8*shift) & 255) << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
//std::cout<<"test"<<std::endl;
usleep(1);
}
}
// usleep(50000);
//StartCycle -----------------------------------------------------------
data = 0;
data += 1 << 16;
data += 242 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
data = 0;
data += 1 << 16;
data += 240 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
// usleep(50000);
//Load SC --------------------------------------------------------------
data = 0;
data += 1 << 16;
data += 241 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
data = 0;
data += 1 << 16;
data += 240 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
return 0;
}
int TransmitReadSC(int socket){
//SCA read ---------------------------------------------------------------
unsigned int data = 0;
for(int i = 0; i<4; ++i){
data = 0;
data += 12 << 16;
data += ((ReadSCdata[0] >> i*8) & 255) << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
usleep(1);
}
//StartCycle ------------------------------------------------------------
data = 0;
data += 1 << 16;
data += 242 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
data = 0;
data += 1 << 16;
data += 240 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
return 0;
}
int TransmitProbe(int socket){
unsigned int data = 0;
//Set Probe mode --------------------------------------------------------
data += 1 << 16;
data += 208 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
//Probe start ----------------------------------------------------------
for(int i = 0; i<sizeByte_PSC; ++i){
for(int shift = 0; shift<4; ++shift){
data = 0;
data += 10 << 16;
data += ((Probedata[i] >> 8*shift) & 255) << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
usleep(1);
}
}
usleep(50000);
//StartCycle ------------------------------------------------------------
data = 0;
data += 1 << 16;
data += 210 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
data = 0;
data += 1 << 16;
data += 208 << 8;
if(-1 == WriteData(socket, data)){
exit(-1);
}
return 0;
}
int ContinuousADC(int socket){
std::string file_num;
std::cout << "Input output data file name : " << std::flush;
std::cin >> file_num;
std::string basename = "after_break_ext_";
std::string file_name = basename + file_num + ".dat";
std::ofstream file(file_name.c_str(),std::ios::binary);
int MaxCycleNum = 0;
std::cout << "Input total # of events" << std::endl;
// std::cout << "If you type 'N', preset # of events will be N*1000" << std::endl;
std::cout << "======>" << std::flush;
std::cin >> MaxCycleNum;
MaxCycleNum = MaxCycleNum/1000;
std::cout << "Preset value : " << MaxCycleNum*1000 << std::endl;
for(int i = 0; i<MaxCycleNum; ++i){
// ADCOneCycle(socket, file);
ADCOneCycle_wHeader(socket, file);
std::cout << "Event # " << 1000*(i+1) << std::endl;
}
std::cout << "End ADC" << std::endl;
file.close();
return 0;
}
int ContinuousADC_ver2(int socket){
std::string file_name;
std::cout << "Input output data file name : " << std::flush;
std::cin >> file_name;
std::ofstream file(file_name.c_str(),std::ios::binary);
int MaxCycleNum = 0;
std::cout << "Input total # of events" << std::endl;
std::cout << "======>" << std::flush;
std::cin >> MaxCycleNum;
std::cout << "Preset value : " << std::dec << MaxCycleNum << std::endl;
unsigned int signal = 0;
int EventNum = 0;
signal += 32 << 24;
signal += 100 << 16;
send(socket, (char*)&signal, sizeof(int), 0);
while(EventNum < MaxCycleNum){
ADCOneCycle_wHeader_ver2(socket, file);
++EventNum;
if(0 == EventNum%1000){
std::cout << "Event # " << std::dec << EventNum << std::endl;
}
if(false
|| EventNum == MaxCycleNum
|| ForceStop == 1
){
ADCStop(socket);
EndADC = 1;
int abort = 0;
while(0 == ADCOneCycle_wHeader_ver2(socket, file)){
usleep(10000);
if(abort == 50){
ADCStop(socket);
abort = 0;
}
std::cout << "dummy data" << std::endl;
++abort;
}
EndADC = 0;
ForceStop = 0;
break;
}
}
std::cout << "End ADC" << std::endl;
file.close();
return 0;
}
void ADCOneCycle(int socket, std::ofstream& file){
static const int TotalEvent = 1000;
unsigned int signal = 0;
signal += 16 << 24;
signal += 100 << 16;
send(socket, (char*)&signal, sizeof(int), 0);
unsigned int ADCData[16*TotalEvent];
for(int i = 0; i<16*TotalEvent; ++i){
ADCData[i] = 0;
}
static unsigned int ADCLength = sizeof(ADCData);
receive(socket, (char*)ADCData, &ADCLength);
for(int Event = 0; Event<TotalEvent; ++Event ){
int event = 0xffff;
file.write((char*)&event, sizeof(short));
// fprintf(stdout, "Event # %d\n",Event);
for(int i = 0; i<16; ++i){
unsigned int buffer = ADCData[i+16*Event] & 4095;
// fprintf(stdout, "%d\n",buffer & 15);
file.write((char*)&buffer, sizeof(short));
buffer = (ADCData[i+16*Event] >> 16) & 4095;
// fprintf(stdout, "%d\n",buffer & 15);
file.write((char*)&buffer, sizeof(short));
}
// std::cout << std::endl;
// std::cout << std::endl;
}
signal = 0;
signal += 100 << 16;
if(-1 == WriteData(socket, signal)){
exit(-1);
}
}
void ADCOneCycle_wHeader(int socket, std::ofstream& file){
static const int TotalEvent = 1000;
unsigned int signal = 0;
unsigned int DataBuffer[100*TotalEvent];
memset(DataBuffer, 0, sizeof(DataBuffer));
unsigned int *ptr_DataBuf = DataBuffer;
unsigned int TotalRecvByte = 0;
unsigned int TotalRecvEvent = 0;
static unsigned int sizeHeader = 2*sizeof(int);
signal += 16 << 24;
signal += 100 << 16;
send(socket, (char*)&signal, sizeof(int), 0);
for(int i = 0; i<TotalEvent; ++i){
unsigned int Header[2] = {1, 1};
receive(socket, (char*)Header, &sizeHeader);
// Header[0] = 0xFFFFEA0C;
// Header[1] = 0x00000100;
if(Header[0] != 0xFFFFEA0C){
std::cerr << "Fatal ADC ERROR : HEADER" << std::endl;
std::cerr << "Header1 : " << std::hex << Header[0] << " Header2 : " << std::hex << Header[1] << std::endl;
exit(-1);
}else{
// std::cerr << "Header1 : " << std::hex << Header[0] << " Header2 : " << std::hex << Header[1] << std::endl;
// std::cout << "Num " << i << std::endl;
// std::cerr << "Header1 : " << std::hex << Header[0] << " Header2 : " << std::hex << Header[1] << std::endl;
unsigned int sizeData = Header[1] & 0xffff;
unsigned int OneData[sizeData/sizeof(int)];
// for(unsigned int i = 0; i<sizeData/sizeof(int); ++i){
// OneData[i] = (900 +2*i) << 16;
// OneData[i] += 900 +2*i +1;
// }
receive(socket, (char*)OneData, &sizeData);
// std::cout << OneData[0] << std::endl;
memcpy(ptr_DataBuf, Header, sizeHeader);
ptr_DataBuf += 2;
memcpy(ptr_DataBuf, OneData, sizeData);
ptr_DataBuf += sizeData/sizeof(int);
TotalRecvByte += sizeHeader + sizeData;
++TotalRecvEvent;
}
}
for(unsigned int i = 0; i<TotalRecvByte/sizeof(int); ++i){
// unsigned int buffer = (DataBuffer[i] >> 16) & 0xffff;
// // fprintf(stdout, "%d\n",buffer & 15);
// file.write((char*)&buffer, sizeof(short));
// buffer = DataBuffer[i] & 0xffff;
// // fprintf(stdout, "%d\n",buffer & 15);
// file.write((char*)&buffer, sizeof(short));
unsigned int buffer = DataBuffer[i];
file.write((char*)&buffer, sizeof(int));
}
signal = 0;
signal += 100 << 16;
if(-1 == WriteData(socket, signal)){
exit(-1);
}
return;
}
int ADCOneCycle_wHeader_ver2(int socket, std::ofstream& file){
static const int NofHeader = 3;
unsigned int DataBuffer[1000];
memset(DataBuffer, 0, sizeof(DataBuffer));
unsigned int *ptr_DataBuf = DataBuffer;
unsigned int TotalRecvByte = 0;
unsigned int TotalRecvEvent = 0;
static unsigned int sizeHeader = NofHeader*sizeof(int);
unsigned int Header[NofHeader] = {1, 1, 1};
int ret = 0;
ret = receive(socket, (char*)Header, &sizeHeader);
if(ret <= 0 && EndADC == 1){
return -1;
}
// std::cout << "Header1 : " << std::hex << Header[0] << " Header2 : " << std::hex << Header[1] << std::endl;
// Header[0] = 0xFFFFEA0C;
// Header[1] = 0x00000100;
if(Header[0] != 0xFFFFEA0C){
std::cerr << "Fatal ADC ERROR : HEADER" << std::endl;
std::cerr << "Header1 : " << std::hex << Header[0]
<< " Header2 : " << std::hex << Header[1]
<< " Header3 : " << std::hex << Header[2] << std::endl;
exit(-1);
}else{
unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
unsigned int NofWord = (Header[1] & 0xffff);
unsigned int OneData[NofWord];
receive(socket, (char*)OneData, &sizeData);
// for(int i = 0; i<NofWord; ++i){
// std::cout << std::hex << OneData[i] << std::endl;
// }
memcpy(ptr_DataBuf, Header, sizeHeader);
ptr_DataBuf += NofHeader;
memcpy(ptr_DataBuf, OneData, sizeData);
ptr_DataBuf += sizeData/sizeof(int);
TotalRecvByte += sizeHeader + sizeData;
++TotalRecvEvent;
}
if(EndADC != 1){
for(unsigned int i = 0; i<TotalRecvByte/sizeof(int); ++i){
unsigned int buffer = DataBuffer[i];
file.write((char*)&buffer, sizeof(int));
}
}
return 0;
}
// Debug ---------------------------------------------------------------------
int Debugging(int socket){
enum debug{read, write, quit, sizedebug};
bool flag_[sizedebug];
for(int i = 0; i<sizedebug; ++i){
flag_[i] = false;
}
std::cout << "Read/Write" << std::endl;
std::cout << "1. Read" << std::endl;
std::cout << "2. Write" << std::endl;
std::cout << "3. Return" << std::endl;
std::cout << "input # =====> " << std::flush;
char buf[10];
fgets(buf, sizeof(buf), stdin);
char num;
sscanf(buf, "%c", &num);
switch(num){
case '1':
flag_[read] = true;
break;
case '2':
flag_[write] = true;
break;
default:
break;
};
if(flag_[read]){
std::cout << "Debug Read" << std::endl;
std::cout << "Input subaddress : " << std::flush;
std::string strbuf;
std::cin >> strbuf;
std::istringstream valbuf(strbuf);
unsigned int saddr = 0;
valbuf >> saddr;
saddr = saddr << 16;
unsigned int data = 0;
if(0 == ReadData(socket, saddr, &data)){
std::cout << std::hex << data << std::endl;
std::cout << "bit31 << >> bit0" << std::endl;
for(int i = 1; i<33; ++i){
if(data >> (32 -i) & 1){
std::cout << "!" << std::flush;
}else{
std::cout << "." << std::flush;
}
if(0 == i%8){
std::cout << " " << std::endl;
}
}
std::cout << std::endl;
}else{
std::cerr << "Read error" << std::endl;
exit(-1);
}
}
if(flag_[write]){
std::cout << "Debug Write" << std::endl;
std::cout << "Input subaddress : " << std::flush;
std::string strbuf;
std::cin >> strbuf;
std::istringstream valbuf(strbuf);
unsigned int signal = 0;
valbuf >> signal;
signal = signal << 16;
std::cout << "Input signal : " << std::flush;
std::string strbuf2;
std::cin >> strbuf2;
std::istringstream databuf(strbuf2);
unsigned int data = 0;
databuf >> data;
data = data << 8;
signal += data;
std::cout << std::hex << signal << std::flush;
std::cout << std::dec << std::endl;
std::cout << signal << std::endl;
if(-1 == WriteData(socket, signal)){
exit(-1);
}
}
return 0;
}
void ADCStop(int socket){
unsigned int signal = 0;
std::cout << "ADC exit process" << std::endl;
signal += 16 << 24;
signal += 100 << 16;
send(socket, (char*)&signal, sizeof(int), 0);
sleep(1);
signal = 0;
signal += 100 << 16;
send(socket, (char*)&signal, sizeof(int), 0);
usleep(10000);
return;
}
void MHTDC_debug(int sock){
std::ofstream m_file("mhtdc.dat",std::ios::binary);
unsigned int saddr = 50;
unsigned int data = 0;
saddr = saddr << 16;
unsigned int signal = 4;
signal = signal << 8;
saddr += signal;
WriteData(sock, saddr);
saddr = 50;
saddr = saddr << 16;
WriteData(sock, saddr);
usleep(100000);
while(ForceStop == 0){
// for(int k = 0; k<3; ++k){
saddr = 41;
data = 0;
saddr = saddr << 16;
usleep(100000);
if(0 == ReadData(sock, saddr, &data)){
int size = (data >> 8) & 0xff;
// std::cout << "size : " << size << std::endl;
std::cout << std::hex << "status : " << data << std::endl;
int valid = data & 0x1;
if(valid == 1){
unsigned int f_size = 0xffff;
f_size = (f_size << 16) + size;
m_file.write((char*)&f_size, sizeof(unsigned int));
for(int i = 0; i<size; ++i){
// usleep(100);
saddr = 42;
saddr = saddr << 16;
unsigned int head =0;
if(0 == ReadData(sock, saddr, &data)){
std::cout << std::hex << "header" << i << " : " << data << std::endl;
head = data & 0xffff;
}else{
std::cerr << "Read error" << std::endl;
exit(-1);
}
// Leading
saddr = 40;
saddr = saddr << 16;
if(0 == ReadData(sock, saddr, &data)){
unsigned int time = (data & 0xffff);
unsigned int one_data = (head << 16) + time;
m_file.write((char*)&one_data, sizeof(unsigned int));
std::cout << std::dec << "time L" << i << " : " << time << " ns" << std::endl;
}else{
std::cerr << "Read error" << std::endl;
exit(-1);
}
// Trailing
saddr = 43;
saddr = saddr << 16;
if(0 == ReadData(sock, saddr, &data)){
unsigned int time = (data & 0xffff);
time = (1 << 15) + time;
unsigned int one_data = (head << 16) + time;
m_file.write((char*)&one_data, sizeof(unsigned int));
std::cout << std::dec << "time T" << i << " : " << (time & 0xfff) << " ns" << std::endl;
}else{
std::cerr << "Read error" << std::endl;
exit(-1);
}
}
saddr = 50;
saddr = saddr << 16;
signal = 4;
signal = signal << 8;
saddr += signal;
WriteData(sock, saddr);
saddr = 50;
saddr = saddr << 16;
WriteData(sock, saddr);
}
}else{
std::cerr << "Read error" << std::endl;
exit(-1);
}
}
return;
}
int chipselect(){
WriteData(3, 37888);
// if(-1 == WriteData(3, 5120)){
// exit(-1);
// }
return 0;
}
*/