Subversion Repositories f9daq

Compare Revisions

Ignore whitespace Rev 291 → Rev 299

/cvi/apps/l2d2_easyroc/easiroc.c
5,9 → 5,10
 
unsigned int slowdata[sizeByte_SC];
unsigned int ReadSCdata[sizeByte_RSC];
unsigned int Probedata[sizeByte_PSC];
unsigned int Pindata[sizeByte_PIN];
 
unsigned int iniData[sizeByte_PIN + 2*sizeByte_SC + 2*sizeByte_RSC];
 
unsigned int Probedata[sizeByte_PSC];
 
int ForceStop = 0;
54,7 → 55,7
IP = SiTCP_MASTER_IP;
port = SiTCP_PORT;
SiTCP_ADDR.sin_family = AF_INET;
SiTCP_ADDR.sin_port = htons(port);
SiTCP_ADDR.sin_port = htons((unsigned short)port);
SiTCP_ADDR.sin_addr.s_addr = inet_addr(IP);
struct timeval tv;
151,46 → 152,74
return 0;
}
//------------------------------------------------------------------------------------------------------
int easiroc_LoadIni(const char *iniFile)
{
FILE *fp=fopen(iniFile, "rt");
if(!fp) {
printf("easiroc::LoadIni() cannot open file %s !!!\n", iniFile);
return 0;
}
char lbuff[256];
int counter = 0;
while(1) {
int c = fgetc(fp);
if(feof(fp)) break;
if( '#' == (char)c ) {
fgets(lbuff,256,fp);
//printf("Found Comment line: %s", lbuff);
} else {
ungetc(c, fp);
fscanf(fp, "%u\n", &iniData[counter] );
//printf("Found value [%d] %u\n", counter, iniData[counter]);
counter++;
}
}
fclose(fp);
return 1;
}
//------------------------------------------------------------------------------------------------------
void PrepareFPGA()
{
Pindata[0] = 20;
Pindata[1] = 65776;
Pindata[0] = iniData[0];
Pindata[1] = iniData[1];
}
//------------------------------------------------------------------------------------------------------
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;
slowdata[ 0] = iniData[sizeByte_PIN + 0];
slowdata[ 1] = iniData[sizeByte_PIN + 1];
slowdata[ 2] = iniData[sizeByte_PIN + 2];
slowdata[ 3] = iniData[sizeByte_PIN + 3];
slowdata[ 4] = iniData[sizeByte_PIN + 4];
slowdata[ 5] = iniData[sizeByte_PIN + 5];
slowdata[ 6] = iniData[sizeByte_PIN + 6];
slowdata[ 7] = iniData[sizeByte_PIN + 7];
slowdata[ 8] = iniData[sizeByte_PIN + 8];
slowdata[ 9] = iniData[sizeByte_PIN + 9];
slowdata[10] = iniData[sizeByte_PIN + 0];
slowdata[11] = iniData[sizeByte_PIN + 11];
slowdata[12] = iniData[sizeByte_PIN + 12];
slowdata[13] = iniData[sizeByte_PIN + 13];
slowdata[14] = iniData[sizeByte_PIN + 14];
} 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;
slowdata[ 0] = iniData[sizeByte_PIN + 1*sizeByte_SC + 0];
slowdata[ 1] = iniData[sizeByte_PIN + 1*sizeByte_SC + 1];
slowdata[ 2] = iniData[sizeByte_PIN + 1*sizeByte_SC + 2];
slowdata[ 3] = iniData[sizeByte_PIN + 1*sizeByte_SC + 3];
slowdata[ 4] = iniData[sizeByte_PIN + 1*sizeByte_SC + 4];
slowdata[ 5] = iniData[sizeByte_PIN + 1*sizeByte_SC + 5];
slowdata[ 6] = iniData[sizeByte_PIN + 1*sizeByte_SC + 6];
slowdata[ 7] = iniData[sizeByte_PIN + 1*sizeByte_SC + 7];
slowdata[ 8] = iniData[sizeByte_PIN + 1*sizeByte_SC + 8];
slowdata[ 9] = iniData[sizeByte_PIN + 1*sizeByte_SC + 9];
slowdata[10] = iniData[sizeByte_PIN + 1*sizeByte_SC + 10];
slowdata[11] = iniData[sizeByte_PIN + 1*sizeByte_SC + 11];
slowdata[12] = iniData[sizeByte_PIN + 1*sizeByte_SC + 12];
slowdata[13] = iniData[sizeByte_PIN + 1*sizeByte_SC + 13];
slowdata[14] = iniData[sizeByte_PIN + 1*sizeByte_SC + 14];
}
}
//------------------------------------------------------------------------------------------------------
197,14 → 226,40
void PrepareReadSC(int chipNo)
{
if(chipNo == 1) {
ReadSCdata[0] = 0;
ReadSCdata[0] = iniData[sizeByte_PIN + 2*sizeByte_SC + 0];
} else {
ReadSCdata[0] = 1;
ReadSCdata[0] = iniData[sizeByte_PIN + 2*sizeByte_SC + 1];
}
}
//------------------------------------------------------------------------------------------------------
void easiroc_PrintData()
{
printf(">>> Pindata\n");
for(int i=0; i<sizeByte_PIN; i++) printf("%u\n", Pindata[i]);
printf(">>> slowdata (1)\n");
for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
printf(">>> slowdata (2)\n");
for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
printf(">>> ReadSCdata (1)\n");
for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
printf(">>> ReadSCdata (2)\n");
for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
}
//------------------------------------------------------------------------------------------------------
int DebugFPGA(SOCKET socket)
{
printf(">>> DebugFPGA Pindata:\n");
for(int i=0; i<sizeByte_PIN; i++) printf("%u\n", Pindata[i]);
unsigned int buffer = 0;
buffer += 0 << 16;
buffer += (Pindata[0] & 255) << 8;
232,6 → 287,9
//------------------------------------------------------------------------------------------------------
int TransmitSC(SOCKET socket)
{
printf(">>> TransmitSC slowdata:\n");
for(int i=0; i<sizeByte_SC; i++) printf("%u\n", slowdata[i]);
unsigned int data = 0;
//Set SC mode -----------------------------------------------------------
data = 0;
301,7 → 359,11
//------------------------------------------------------------------------------------------------------
int TransmitReadSC(SOCKET socket)
{
//SCA read ---------------------------------------------------------------
printf(">>> TransmitReadSC ReadSCdata:\n");
for(int i=0; i<sizeByte_RSC; i++) printf("%u\n", ReadSCdata[i]);
 
//SCA read ---------------------------------------------------------------
unsigned int data = 0;
 
for(int i = 0; i<4; ++i){
347,35 → 409,35
}
 
switch(CurrentProbeType){
case '1':
case 1:
CurrentProbe = pa_hg;
break;
 
case '2':
case 2:
CurrentProbe = pa_lg;
break;
 
case '3':
case 3:
CurrentProbe = ssh_hg;
break;
 
case '4':
case 4:
CurrentProbe = ssh_lg;
break;
 
case '5':
case 5:
CurrentProbe = fs;
break;
 
case '6':
case 6:
 
break;
 
case '7':
case 7:
 
break;
 
case '8':
case 8:
flag_rst = 1;
CurrentCh = 0;
ProbeBuffer = 0;
385,6 → 447,8
default:
break;
};
//printf("CurrentProbeType = %d | CurrentProbe = %d\n", CurrentProbeType, CurrentProbe);
 
if(flag_rst) {
return 0;
397,10 → 461,12
unsigned int buffer_16 = ProbeBuffer*ProbeBuffer;
unsigned int buffer_0 = (ProbeBuffer >> 16)*(ProbeBuffer >> 16);
if(CurrentProbe == ssh_hg || CurrentProbe == pa_hg) {
//printf("CurrentProbe == ssh_hg || CurrentProbe == pa_hg\n");
buffer_16 = buffer_16 << 1;
buffer_0 = buffer_0 << 1;
}
if(CurrentProbe == fs) {
//printf("CurrentProbe == fs\n");
Probedata[fs_all] = ProbeBuffer;
} else if(CurrentProbe == ssh_hg || CurrentProbe == ssh_lg) {
if(CurrentCh > 15) {
562,7 → 628,7
return 0;
}
//------------------------------------------------------------------------------------------------------
int ADCOneCycle_wHeader_ver2(SOCKET socket, FILE* file)
int ADCOneCycle_wHeader_ver2(SOCKET socket, FILE* file, int stopping)
{
static const int NofHeader = 3;
 
578,10 → 644,8
int ret = 0;
ret = recv(sock, (char*)Header, sizeHeader, 0);
if(ret <= 0 && EndADC == 1) {
if(EndADC != 0) printf("Fatal ADC ERROR : recv\n");
return -1;
}
//if(ret <= 0) printf("Fatal ADC ERROR : recv\n");
if(ret <= 0 && EndADC == 1) return -1;
// sleep necessary! ERRORS happen if trigger rate lower than ~ sleep frequency!
usleep(200);
598,9 → 662,10
unsigned int OneData[NofWord];
recv(socket, (char*)OneData, sizeData, 0);
 
// for(int i = 0; i<NofWord; ++i){ std::cout << std::hex << OneData[i] << std::endl; }
 
if(!stopping) {
for(int i = 0; i<NofWord; ++i) printf("[%d] 0x%x ", i, OneData[i]);
printf("\n");
}
memcpy(ptr_DataBuf, Header, sizeHeader);
ptr_DataBuf += NofHeader;
 
611,7 → 676,7
++TotalRecvEvent;
}
 
if(EndADC != 1){
if(EndADC != 1 && file!=NULL){
for(unsigned int i = 0; i<TotalRecvByte/sizeof(int); ++i) {
unsigned int buffer = DataBuffer[i];
fwrite((char*)&buffer, sizeof(int), 1, file);
659,7 → 724,7
while(EventNum < MaxCycleNum){
//Sleep(10);
ADCOneCycle_wHeader_ver2(socket, file);
ADCOneCycle_wHeader_ver2(socket, file, 0);
++EventNum;
if(0 == EventNum%1000){
printf("Event # %d\n", EventNum);
670,7 → 735,7
 
EndADC = 1;
int abort = 0;
while(0 == ADCOneCycle_wHeader_ver2(socket, file)) {
while(0 == ADCOneCycle_wHeader_ver2(socket, file, 1)) {
Sleep(1);
if(abort == 50) {
ADCStop(socket);
699,7 → 764,84
if(ContinuousADC_ver2(sock, file_name, MaxCycleNum) != 0) return -1;
return 0;
}
}
//------------------------------------------------------------------------------------------------------
int easiroc_singleADCstart() {
unsigned int signal = 0;
 
signal += 32 << 24;
signal += 100 << 16;
send(sock, (char*)&signal, sizeof(int), 0);
Sleep(100);
printf("\nStart ADC\n");
return 0;
}
//------------------------------------------------------------------------------------------------------
int easiroc_singleADCevent(unsigned int *retData) {
static const int NofHeader = 3;
 
unsigned int DataBuffer[1000];
memset(DataBuffer, 0, sizeof(DataBuffer));
 
unsigned int sizeHeader = NofHeader*sizeof(int);
 
unsigned int Header[] = {1, 1, 1};
int ret = 0;
ret = recv(sock, (char*)Header, sizeHeader, 0);
//if(ret <= 0) printf("Fatal ADC ERROR : recv\n");
if(ret <= 0 && EndADC == 1) return -1;
//usleep(200);
//Sleep(1);
 
//printf("Header1 (0xFFFFEA0C) : 0x%x | Header2 (0x00000100) : 0x%x\n", Header[0], Header[1]);
if(Header[0] != 0xFFFFEA0C) {
printf("Fatal ADC ERROR : HEADER\n");
printf("Header1 : 0x%x | Header2 : 0x%x | Header3 : 0x%x\n", Header[0], Header[1], Header[2]);
return -2;
} else {
unsigned int sizeData = (sizeof(int)*Header[1] & 0xffff);
unsigned int NofWord = (Header[1] & 0xffff);
unsigned int OneData[NofWord];
recv(sock, (char*)OneData, sizeData, 0);
 
//for(int i = 0; i<NofWord; ++i) printf("[%d] 0x%x ", i, OneData[i]);
//printf("\n");
if(NofWord < EASIROC_MAX_READ_N_WORDS) memcpy(retData, OneData, sizeData);
return NofWord;
}
}
//------------------------------------------------------------------------------------------------------
int easiroc_singleADCstop() {
ADCStop(sock);
 
EndADC = 1;
int abort = 0;
while(0 == ADCOneCycle_wHeader_ver2(sock, NULL, 1)) {
Sleep(1);
if(abort == 50) {
ADCStop(sock);
abort = 0;
}
//printf("dummy data\n");
printf(".");
++abort;
}
 
EndADC = 0;
ForceStop = 0;
printf("\nEnd ADC\n");
return 0;
}
//------------------------------------------------------------------------------------------------------