int checkForRequests() {
int count,retVal;
static int wd=0;
char *tempString=0;
// unsigned int eventNumber;
char fileName[FILENAME_MAX];
char linkName[FILENAME_MAX];
PlaybackRequest_t pReq;
int numLinks=0;
if(wd==0) {
//First time need to prep the watcher directory
wd=setupLinkWatchDir(PLAYBACK_LINK_DIR);
if(wd<=0) {
fprintf(stderr,"Unable to watch %s\n",PLAYBACK_LINK_DIR);
syslog(LOG_ERR,"Unable to watch %s\n",PLAYBACK_LINK_DIR);
exit(0);
}
numLinks=getNumLinks(wd);
}
//Check for new inotify events
retVal=checkLinkDirs(1,0); //Should probably check
if(retVal || numLinks)
numLinks=getNumLinks(wd); //Current events waiting
if(numLinks>0) {
fprintf(stderr,"Playbackd has received %d requests\n",numLinks);
for(count=0;count<numLinks;count++) {
tempString=getFirstLink(wd);
sprintf(linkName,"%s/%s",PLAYBACK_LINK_DIR,tempString);
sprintf(fileName,"%s/%s",PLAYBACK_DIR,tempString);
FILE *fp=fopen(fileName,"rb");
if(!fp) {
removeFile(linkName);
removeFile(fileName);
continue;
}
retVal=fread(&pReq,sizeof(PlaybackRequest_t),1,fp);
if(retVal<0) {
removeFile(linkName);
removeFile(fileName);
continue;
}
// fprintf(stderr,"Here\n");
sendEvent(&pReq);
removeFile(linkName);
removeFile(fileName);
}
}
return 0;
}
int main(int argc, char *argv[])
{
//Temporary variables
int retVal=0,pri=0,ind=0;
/* Config file thingies */
// int status=0;
// char* eString ;
sprintf(currentOpenportDir,"%s",OPENPORT_OUTPUT_DIR);
char *progName=basename(argv[0]);
//
retVal=sortOutPidFile(progName);
if(retVal<0)
return -1;
/* Set signal handlers */
signal(SIGUSR1, sigUsr1Handler);
signal(SIGUSR2, sigUsr2Handler);
signal(SIGTERM, handleBadSigs);
signal(SIGINT, handleBadSigs);
signal(SIGSEGV, handleBadSigs);
signal(SIGRTMIN, refreshLinksHandler);
/* Setup log */
setlogmask(LOG_UPTO(LOG_INFO));
openlog (progName, LOG_PID, ANITA_LOG_FACILITY) ;
syslog(LOG_INFO,"Starting Openportd\n");
/* Load Config */
kvpReset () ;
// status = configLoad (GLOBAL_CONF_FILE,"global") ;
// eString = configErrorString (status) ;
//Fill event dir names
for(pri=0;pri<NUM_PRIORITIES;pri++) {
retVal=snprintf(eventTelemDirs[pri],sizeof(eventTelemDirs[pri]),"%s/%s%d",BASE_EVENT_TELEM_DIR,EVENT_PRI_PREFIX,pri);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
retVal=snprintf(eventTelemLinkDirs[pri],sizeof(eventTelemLinkDirs[pri]),"%s/link",eventTelemDirs[pri]);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
makeDirectories(eventTelemLinkDirs[pri]);
}
makeDirectories(OPENPORT_OUTPUT_DIR);
makeDirectories(OPENPORT_STAGE_DIR);
makeDirectories(OPENPORTD_CMD_ECHO_TELEM_LINK_DIR);
for(ind=0;ind<NUM_HK_TELEM_DIRS;ind++) {
makeDirectories(telemLinkDirs[ind]);
}
retVal=readConfig();
char currentHeader[FILENAME_MAX];
static int numLinks[NUM_PRIORITIES]={0};
static int numHkLinks[NUM_HK_TELEM_DIRS]={0};
int totalEventLinks=0;
int totalHkLinks=0;
int totalEventsSent=0;
time_t currentTime=0;
time_t lastRefresh=0;
int hkInd=0;
char *tempString=0;
int numSent=0;
//Setup inotify watches
for(pri=0;pri<NUM_PRIORITIES;pri++) {
//Setup inotify watches
if(wdEvents[pri]==0) {
wdEvents[pri]=setupLinkWatchDir(eventTelemLinkDirs[pri]);
if(wdEvents[pri]<=0) {
fprintf(stderr,"Unable to watch %s\n",eventTelemLinkDirs[pri]);
syslog(LOG_ERR,"Unable to watch %s\n",eventTelemLinkDirs[pri]);
handleBadSigs(0);
}
numLinks[pri]=getNumLinks(wdEvents[pri]);
}
}
for(hkInd=0;hkInd<NUM_HK_TELEM_DIRS;hkInd++) {
if(wdHks[hkInd]==0) {
wdHks[hkInd]=setupLinkWatchDir(telemLinkDirs[hkInd]);
if(wdHks[hkInd]<=0) {
fprintf(stderr,"Unable to watch %s\n",telemLinkDirs[hkInd]);
syslog(LOG_ERR,"Unable to watch %s\n",telemLinkDirs[hkInd]);
// handleBadSigs(0);
}
numHkLinks[hkInd]=getNumLinks(wdHks[hkInd]);
}
}
time(&lastRefresh);
int hkCount=0;
printf("Before while loop\n");
startCopyScript();
do {
if(printToScreen) printf("Initalizing Openportd\n");
currentState=PROG_STATE_RUN;
while(currentState==PROG_STATE_RUN) {
printf("Inside while loop\n");
if(!sendData) {
sleep(1);
continue;
}
//The idea is that we only write an output file if there is space for it
int numWaitingToTransfer=countFilesInDir(currentOpenportDir);
if(numWaitingToTransfer>2) {
fprintf(stderr,"There are %d files waiting to transer, will sleep now\n",numWaitingToTransfer);
sleep(1);
continue;
}
if(totalEventsSent%10==0) {
printf("Data sent\nEvents:\t");
for(pri=0;pri<NUM_PRIORITIES;pri++)
printf("%d ",numEventsSent[pri]);
printf("\nHk:\t");
for(hkInd=0;hkInd<NUM_HK_TELEM_DIRS;hkInd++)
printf("%d ",numHksSent[hkInd]);
printf("\n");
}
//Check to see if we need to refresh the links
time(¤tTime);
if(currentTime>lastRefresh+REFRESH_LINKS_EVERY || needToRefreshLinks) {
refreshLinkDirs();
lastRefresh=currentTime;
needToRefreshLinks=0;
}
//Update the link lists
//or some time has passed
if(totalEventLinks==0)
retVal=checkLinkDirs(1,0);
else
retVal=checkLinkDirs(0,1);
totalEventLinks=0;
for(pri=0;pri<NUM_PRIORITIES;pri++) {
numLinks[pri]=getNumLinks(wdEvents[pri]);
totalEventLinks+=numLinks[pri];
}
totalHkLinks=0;
for(hkInd=0;hkInd<NUM_HK_TELEM_DIRS;hkInd++) {
numHkLinks[hkInd]=getNumLinks(wdHks[hkInd]);
totalHkLinks+=numHkLinks[hkInd];
}
if(!retVal && totalHkLinks==0 && totalEventLinks==0) {
//No data
needToRefreshLinks=1;
usleep(1000);
continue;
}
printf("%d %d %d\n",totalEventLinks,totalHkLinks,retVal);
if(totalEventLinks) {
//Which priority are we sending
currentPri=priorityOrder[orderIndex];
int doneEvent=0;
while(!doneEvent && totalEventLinks>0) {
while(numLinks[currentPri]==0) {
orderIndex++;
if(orderIndex>=numOrders) orderIndex=0;
currentPri=priorityOrder[orderIndex];
}
printf("Trying priority %d -- numLinks %d\n",currentPri,numLinks[currentPri]);
if(numLinks[currentPri]) {
//Got an event
tempString=getLastLink(wdEvents[currentPri]);
retVal=snprintf(currentHeader,sizeof(currentHeader),"%s/%s",eventTelemLinkDirs[currentPri],tempString);
if(retVal<0) {
syslog(LOG_ERR,"Error using snprintf -- %s",strerror(errno));
}
// syslog(LOG_INFO,"Trying %s\n",currentHeader);
doneEvent=readAndSendEventRamdisk(currentHeader); //Also deletes
if(doneEvent) {
numEventsSent[currentPri]++;
totalEventsSent++;
}
numLinks[currentPri]--;
totalEventLinks--;
}
}
if(currentTime>lastRefresh+REFRESH_LINKS_EVERY ||
needToRefreshLinks) {
refreshLinkDirs();
lastRefresh=currentTime;
needToRefreshLinks=0;
totalHkLinks=0;
for(hkInd=0;hkInd<NUM_HK_TELEM_DIRS;hkInd++) {
numHkLinks[hkInd]=getNumLinks(wdHks[hkInd]);
totalHkLinks+=numHkLinks[hkInd];
}
}
//Now try to send some stuff I like
numSent=0;
if(numHkLinks[OPENPORT_TELEM_HEADER])
readHkAndOpenport(wdHks[OPENPORT_TELEM_HEADER],
headersPerEvent,HEADER_TELEM_DIR,
HEADER_TELEM_LINK_DIR,sizeof(AnitaEventHeader_t),&numSent);
numHksSent[OPENPORT_TELEM_HEADER]+=numSent;
numSent=0;
if(numHkLinks[OPENPORT_TELEM_CMD_ECHO])
readHkAndOpenport(wdHks[OPENPORT_TELEM_CMD_ECHO],echoesPerEvent,
OPENPORTD_CMD_ECHO_TELEM_DIR,
OPENPORTD_CMD_ECHO_TELEM_LINK_DIR,
sizeof(CommandEcho_t),&numSent);
numHksSent[OPENPORT_TELEM_CMD_ECHO]+=numSent;
numSent=0;
if(numHkLinks[OPENPORT_TELEM_HK])
readHkAndOpenport(wdHks[OPENPORT_TELEM_HK],hkPerEvent,HK_TELEM_DIR,
HK_TELEM_LINK_DIR,sizeof(HkDataStruct_t),&numSent);
numSent=0;
if(numHkLinks[OPENPORT_TELEM_ADU5A_PAT])
readHkAndOpenport(wdHks[OPENPORT_TELEM_ADU5A_PAT],1,
ADU5A_PAT_TELEM_DIR,
ADU5A_PAT_TELEM_LINK_DIR,
sizeof(GpsAdu5PatStruct_t),&numSent);
numHksSent[OPENPORT_TELEM_ADU5A_PAT]+=numSent;
numSent=0;
if(numHkLinks[OPENPORT_TELEM_MONITOR])
readHkAndOpenport(wdHks[OPENPORT_TELEM_MONITOR],monitorPerEvent,
MONITOR_TELEM_DIR,MONITOR_TELEM_LINK_DIR,
sizeof(MonitorStruct_t),&numSent);
numHksSent[OPENPORT_TELEM_MONITOR]+=numSent;
// else if(totalEventLinks==0) {
// usleep(1000);
// }
orderIndex++;
if(orderIndex>=numOrders) orderIndex=0;
}
//Now we try and send some data
//I'm going to try and modify this but for now
if(hkCount%eventBandwidth==0)
sendSomeHk(10000);
hkCount++;
}
} while (currentState == PROG_STATE_INIT);
stopCopyScript();
unlink(OPENPORTD_PID_FILE);
return 0;
}
void fillBufferWithHk()
{
// printf("fillBufferWithHk\n");
//Setup inotify watches
//Get the various number of links
//Send some data down
static int wdHks[NUM_HK_TELEM_DIRS]={0};
static int numHkLinks[NUM_HK_TELEM_DIRS]={0};
static int maxPacketSize[NUM_HK_TELEM_DIRS]=
{sizeof(CommandEcho_t),
sizeof(MonitorStruct_t),
sizeof(AnitaEventHeader_t),
sizeof(HkDataStruct_t),
sizeof(GpsAdu5SatStruct_t),
sizeof(GpsAdu5SatStruct_t),
sizeof(GpsG12SatStruct_t),
sizeof(GpsAdu5PatStruct_t),
sizeof(GpsAdu5PatStruct_t),
sizeof(GpsG12PosStruct_t),
sizeof(GpuPhiSectorPowerSpectrumStruct_t),
sizeof(GpsAdu5VtgStruct_t),
sizeof(GpsAdu5VtgStruct_t),
sizeof(GpsGgaStruct_t),
sizeof(GpsGgaStruct_t),
sizeof(GpsGgaStruct_t),
sizeof(FullSurfHkStruct_t),
sizeof(TurfRateStruct_t),
sizeof(AveragedSurfHkStruct_t),
sizeof(SummedTurfRateStruct_t),
sizeof(SSHkDataStruct_t),
sizeof(OtherMonitorStruct_t),
sizeof(FullLabChipPedStruct_t),
4000, //Who knows why,
sizeof(RtlSdrPowerSpectraStruct_t) ,
sizeof(TuffNotchStatus_t)
};
int hkInd=0;
//Setup inotify watches
if(wdHks[0]==0) {
for(hkInd=0;hkInd<NUM_HK_TELEM_DIRS;hkInd++) {
if(wdHks[hkInd]==0) {
wdHks[hkInd]=setupLinkWatchDir(telemLinkDirs[hkInd]);
if(wdHks[hkInd]<=0) {
fprintf(stderr,"Unable to watch %s\n",telemLinkDirs[hkInd]);
syslog(LOG_ERR,"Unable to watch %s\n",telemLinkDirs[hkInd]);
// handleBadSigs(0);
}
numHkLinks[hkInd]=getNumLinks(wdHks[hkInd]);
}
}
}
//Update the link lists -- well don't for now
// checkLinkDirs(0,1);
//Now try and send some hk data
for(hkInd=0;hkInd<NUM_HK_TELEM_DIRS;hkInd++) {
int numToLeave=1;
if(hkInd==0) numToLeave=0;
//Make sure we clear the buffer to leave room for requests
if(hkInd==LOS_TELEM_REQUEST && numBytesInBuffer>1000)
doWrite();
numHkLinks[hkInd]=getNumLinks(wdHks[hkInd]);
// printf("numHkLinks[%d] %d\n",hkInd,numHkLinks[hkInd]);
if(numHkLinks[hkInd]>0) {
//Have stuff to send
if((LOS_MAX_BYTES-numBytesInBuffer)>maxPacketSize[hkInd]) {
addToTelemetryBuffer(LOS_MAX_BYTES-numBytesInBuffer,wdHks[hkInd],
telemDirs[hkInd],telemLinkDirs[hkInd],
maxPacketSize[hkInd],numToLeave);
}
}
}
if(numBytesInBuffer>1000)
doWrite();
if(numBytesInBuffer<0) {
printf("What the heck does %d bytes mean\n",numBytesInBuffer);
}
}
int main(int argc, char *argv[])
{
int pri,retVal,firstTime=1,ind=0;
time_t lastRefresh=0;
time_t lastUpdate=0;
time_t currentTime=0;
char *tempString=0;
char *progName=basename(argv[0]);
// last_send.tv_sec = 0;
// last_send.tv_nsec = 0;
//Sort out PID File
retVal=sortOutPidFile(progName);
if(retVal!=0) {
return retVal;
}
//Directory listing tools
// char currentTouchname[FILENAME_MAX];
char currentHeader[FILENAME_MAX];
int numLinks[NUM_PRIORITIES]={0};
int totalEventLinks=0;
int wdEvents[NUM_PRIORITIES]={0};
// int sillyEvNum[NUM_PRIORITIES]={0};
/* Set signal handlers */
signal(SIGUSR1, sigUsr1Handler);
signal(SIGUSR2, sigUsr2Handler);
signal(SIGTERM, handleBadSigs);
signal(SIGINT,handleBadSigs);
signal(SIGSEGV,handleBadSigs);
/* Setup log */
setlogmask(LOG_UPTO(LOG_INFO));
openlog (progName, LOG_PID, ANITA_LOG_FACILITY) ;
// Load Config
retVal=readConfig();
if(!laptopDebug) {
retVal=initDevice();
if(retVal!=0) {
return 1;
}
}
else {
retVal=0;
printf("Running in debug mode not actually trying to talk to device\n");
makeDirectories(fakeOutputDir);
}
makeDirectories(PRIORITIZERD_EVENT_LINK_DIR);
for(ind=0;ind<NUM_HK_TELEM_DIRS;ind++) {
makeDirectories(telemLinkDirs[ind]);
}
//Fill event dir names
for(pri=0;pri<NUM_PRIORITIES;pri++) {
sprintf(eventTelemDirs[pri],"%s/%s%d",BASE_EVENT_TELEM_DIR,
EVENT_PRI_PREFIX,pri);
sprintf(eventTelemLinkDirs[pri],"%s/link",eventTelemDirs[pri]);
makeDirectories(eventTelemLinkDirs[pri]);
if(sendData) {
//And setup inotify watches
if(wdEvents[pri]==0) {
wdEvents[pri]=setupLinkWatchDir(eventTelemLinkDirs[pri]);
if(wdEvents[pri]<=0) {
fprintf(stderr,"Unable to watch %s\n",eventTelemLinkDirs[pri]);
syslog(LOG_ERR,"Unable to watch %s\n",eventTelemLinkDirs[pri]);
handleBadSigs(0);
}
numLinks[pri]=getNumLinks(wdEvents[pri]);
}
}
}
time(&lastRefresh);
pthread_t thread;
retVal = pthread_create(&thread, 0, watchdogThread,0);
if (retVal)
{
syslog(LOG_ERR, "LOSd: create watchdog thread returned %d\n", retVal);
}
do {
if(verbosity) printf("Initializing LOSd\n");
int lastSendData=sendData;
retVal=readConfig();
if(lastSendData!=sendData) {
break; //Lets restart LOSd
}
if(firstTime) {
sendWakeUpBuffer();
firstTime=0;
}
int hkCount=0;
currentState=PROG_STATE_RUN;
while(currentState==PROG_STATE_RUN) {
//This is just if LOSd has been turned off when we're out of range
if(!sendData) {
sleep(1);
continue;
}
//Check to see if we need to refresh the links
time(¤tTime);
if(currentTime>lastRefresh+REFRESH_LINKS_EVERY) {
refreshLinkDirs();
lastRefresh=currentTime;
}
//Work which priority we're doing
currentPri=priorityOrder[orderIndex];
//Will actually change this to almost work in the future
if(hkCount%5==0) fillBufferWithHk();
hkCount++;
//Check the link dirs
if(currentTime>lastUpdate+10 || totalEventLinks<1) {
if(totalEventLinks<1)
checkLinkDirs(1,0);
else
checkLinkDirs(0,1); //Maybe I don't need to do this every time
lastUpdate=currentTime;
}
totalEventLinks=0;
for(pri=0;pri<NUM_PRIORITIES;pri++) {
numLinks[pri]=getNumLinks(wdEvents[pri]);
totalEventLinks+=numLinks[pri];
}
if(printToScreen && verbosity>1) {
printf("Got %d links in %s\n",numLinks[currentPri],
eventTelemLinkDirs[currentPri]);
}
// sillyEvNum[currentPri]=0;
if(numLinks[currentPri]>0) {
//Got an event
tempString=getLastLink(wdEvents[currentPri]);
sprintf(currentHeader,"%s/%s",eventTelemLinkDirs[currentPri],
tempString);
if(printToScreen && verbosity)
printf("Starting %s\n",currentHeader);
readAndSendEventRamdisk(currentHeader); //Also deletes
numLinks[currentPri]--;
totalEventLinks--;
}
//Again I need to improve the bandwidth sharing between data and hk
fillBufferWithHk();
// if(totalEventLinks<1) usleep(100);
// printf("totalEventLinks %d\n",totalEventLinks);
orderIndex++;
if(orderIndex>=numOrders) orderIndex=0;
}
} while(currentState==PROG_STATE_INIT);
unlink(LOSD_PID_FILE);
syslog(LOG_INFO,"LOSd terminating");
// fprintf(stderr, "Bye bye\n");
return 0;
}
int main(int argc, char *argv[]){
{
int runInd=0;
for(runInd=0; runInd<NUM_RUNS; runInd++){
lastEvents[runInd] = firstEvents[runInd]+5000 < lastEvents[runInd] ? firstEvents[runInd]+5000 : lastEvents[runInd];
}
}
/* { */
/* int runInd=0; */
/* for(runInd=0; runInd<NUM_RUNS; runInd++){ */
/* lastEvents[runInd] = firstEvents[runInd]+10000; */
/* } */
/* } */
int retVal; //,count;
/* Directory reading things */
int wd=0;
/* char *tempString; */
int numEventLinks;
/* Log stuff */
char *progName=basename(argv[0]);
retVal=sortOutPidFile(progName);
if(retVal<0)
return retVal;
#ifdef WRITE_DEBUG_FILE
FILE *debugFile = fopen("/tmp/priDebugFile.txt","w");
if(!debugFile) {
fprintf(stderr,"Couldn't open debug file\n");
exit(0);
}
#endif
/* Set signal handlers */
signal(SIGUSR1, sigUsr1Handler);
signal(SIGUSR2, sigUsr2Handler);
signal(SIGTERM, handleBadSigs);
signal(SIGINT, handleBadSigs);
signal(SIGSEGV, handleBadSigs);
//Dont' wait for children
//RJN hack will have to fix this somehow
signal(SIGCLD, SIG_IGN);
/* Setup log */
setlogmask(LOG_UPTO(LOG_INFO));
openlog (progName, LOG_PID, ANITA_LOG_FACILITY) ;
makeDirectories(HEADER_TELEM_LINK_DIR);
makeDirectories(HEADER_TELEM_DIR);
makeDirectories(EVENTD_EVENT_LINK_DIR);
makeDirectories(PRIORITIZERD_EVENT_LINK_DIR);
makeDirectories(ACQD_EVENT_LINK_DIR);
makeDirectories(GPU_TELEM_DIR);
makeDirectories(GPU_TELEM_LINK_DIR);
retVal=0;
/* Main event getting loop. */
if(wd==0) {
//First time need to prep the watcher directory
wd=setupLinkWatchDir(EVENTD_EVENT_LINK_DIR);
if(wd<=0) {
fprintf(stderr,"Unable to watch %s\n",EVENTD_EVENT_LINK_DIR);
syslog(LOG_ERR,"Unable to watch %s\n",EVENTD_EVENT_LINK_DIR);
exit(0);
}
numEventLinks=getNumLinks(wd);
}
/*
This function mallocs at some global pointers
so needs to be outside any kind of loop.
*/
prepareGpuThings();
prepareTimingCalibThings();
/* Reset average */
int phi=0;
for(phi=0; phi<NUM_PHI_SECTORS; phi++){
memset(&payloadPowSpec[phi], 0, sizeof(GpuPhiSectorPowerSpectrumStruct_t));
}
prepWriterStructs();
do {
if(printToScreen) printf("Initalizing fakePrioritizerd\n");
retVal=readConfig();
if(retVal<0) {
syslog(LOG_ERR,"Problem reading Prioritizerd.config");
printf("Problem reading Prioritizerd.config\n");
exit(1);
}
currentState=PROG_STATE_RUN;
/* This one is the main while loop */
int runInd=0;
for(runInd=0; runInd<NUM_RUNS; runInd++) {
int run = runs[runInd];
if(run!=selectedRun) continue;
const char* baseDir = "/home/anita/anitaStorage/antarctica14/raw";
int eventFileNum=0;
int firstFile = 100*(firstEvents[runInd]/100) + 100;
int lastFile = 100*(lastEvents[runInd]/100) - 100;
for(eventFileNum=firstFile; eventFileNum<=lastFile; eventFileNum+=100){
// while(currentState==PROG_STATE_RUN) {
// usleep(1);
retVal=checkLinkDirs(1,0);
if(retVal || numEventLinks) numEventLinks=getNumLinks(wd);
if(numEventLinks>=panicQueueLength) {
syslog(LOG_INFO,"Prioritizerd is getting behind (%d events in inbox), will have some prioritity 7 events",numEventLinks);
}
/* if(!numEventLinks){ */
/* usleep(1000); */
/* continue; */
/* } */
/* Read data into program memory */
int eventDir1 = eventFileNum/1000000;
eventDir1 *= 1000000;
int eventDir2 = eventFileNum/10000;
eventDir2 *= 10000;
char dir[FILENAME_MAX];
sprintf(dir, "%s/run%d/event/ev%d/ev%d", baseDir, run, eventDir1, eventDir2);
char fileName1[FILENAME_MAX];
sprintf(fileName1, "%s/psev_%d.dat.gz", dir, eventFileNum);
char fileName2[FILENAME_MAX];
sprintf(fileName2, "%s/hd_%d.dat.gz", dir, eventFileNum);
printf("%s\n", fileName1);
readIn100Events(fileName1, pedSubBody, fileName2, theHeader);
/* readInTextFile(pedSubBody, theHeader); */
int eventsReadIn = 0;
while(eventsReadIn<100 && currentState==PROG_STATE_RUN){
/* numEventLinks=getNumLinks(wd); */
/* tempString=getFirstLink(wd); */
/* if(numEventLinks==0) break; */
/* if(tempString==NULL) continue; */
/* // printf("tempString = %s\n", tempString); */
/* // printf("%s\n",eventLinkList[eventsReadIn]->d_name); */
/* sscanf(tempString,"hd_%d.dat",&doingEvent); */
/* if(lastEventNumber>0 && doingEvent!=lastEventNumber+1) { */
/* syslog(LOG_INFO,"Non-sequential event numbers %d and %d\n", lastEventNumber, doingEvent); */
/* } */
/* lastEventNumber=doingEvent; */
/* sprintf(linkFilename, "%s/%s", EVENTD_EVENT_LINK_DIR, tempString); */
/* sprintf(hdFilename, "%s/hd_%d.dat", EVENTD_EVENT_DIR, doingEvent); */
/* //RJN 4th June 2008 */
/* //Switch to Acqd writing psev files */
/* sprintf(bodyFilename[eventsReadIn],"%s/psev_%d.dat", ACQD_EVENT_DIR, doingEvent); */
/* retVal=fillHeader(&theHeader[eventsReadIn],hdFilename); */
if(numEventLinks < panicQueueLength){
/* Then we add to GPU queue... */
/* retVal=fillPedSubbedBody(&pedSubBody,bodyFilename[eventsReadIn]); */
double* finalVolts[ACTIVE_SURFS*CHANNELS_PER_SURF];
/* printf("fakePrioritizer reads event %d with priority %d\n",theHeader[eventsReadIn].eventNumber, theHeader[eventsReadIn].priority&0xf); */
doTimingCalibration(eventsReadIn, &theHeader[eventsReadIn], pedSubBody[eventsReadIn], finalVolts);
addEventToGpuQueue(eventsReadIn, finalVolts, theHeader[eventsReadIn]);
int chanInd=0;
for(chanInd=0; chanInd<ACTIVE_SURFS*CHANNELS_PER_SURF; chanInd++){
free(finalVolts[chanInd]);
}
eventsReadIn++;
}
else{/* Panic! Write all header files to archived directory with priority 7! */
panicWriteAllLinks(wd, 7, panicQueueLength, priorityPPS1, priorityPPS2);
}
}
/* exit(-1); */
printf("eventsReadIn = %d, max is %d.\n", eventsReadIn, NUM_EVENTS);
/* Now use GPU to determine priority, send in arrays of length eventsReadIn... */
if(eventsReadIn>0){
mainGpuLoop(eventsReadIn, theHeader, payloadPowSpec, writePowSpecPeriodSeconds);
}
if(payloadPowSpec[0].unixTimeLastEvent - payloadPowSpec[0].unixTimeFirstEvent >= writePowSpecPeriodSeconds
|| currentState!=PROG_STATE_RUN){
int phi=0;
for(phi=0; phi<NUM_PHI_SECTORS; phi++){
printf("Trying to write and link for phi sector %d...\n", phi);
writeFileAndLink(&payloadPowSpec[phi], phi);
}
if(currentState==PROG_STATE_RUN){
/* Reset average */
for(phi=0; phi<NUM_PHI_SECTORS; phi++){
memset(&payloadPowSpec[phi], 0, sizeof(GpuPhiSectorPowerSpectrumStruct_t));
}
}
}
int count = 0;
for(count=0;count<eventsReadIn;count++) {
// handle queue forcing of PPS here
int pri=theHeader[count].priority&0xf;
if((theHeader[count].turfio.trigType&0x2) && (priorityPPS1>=0 && priorityPPS1<=9))
pri=priorityPPS1;
if((theHeader[count].turfio.trigType&0x4) && (priorityPPS2>=0 && priorityPPS2<=9))
pri=priorityPPS2;
if(pri<0 || pri>9) pri=9;
theHeader[count].priority=(16*theHeader[count].priority)+pri;
/* printf("eventNumber = %u, priority = %d\n", theHeader[count].eventNumber, theHeader[count].priority&0xf); */
//Now Fill Generic Header and calculate checksum
/* fillGenericHeader(&theHeader[count],theHeader[count].gHdr.code,sizeof(AnitaEventHeader_t)); */
/* //Rename body and write header for Archived */
/* sprintf(archiveBodyFilename,"%s/psev_%u.dat",PRIORITIZERD_EVENT_DIR, */
/* theHeader[count].eventNumber); */
/* if(rename(bodyFilename[count],archiveBodyFilename)==-1) */
/* { */
/* syslog(LOG_ERR,"Error moving file %s -- %s",archiveBodyFilename, */
/* strerror(errno)); */
/* } */
/* sprintf(archiveHdFilename,"%s/hd_%u.dat",PRIORITIZERD_EVENT_DIR, */
/* theHeader[count].eventNumber); */
/* writeStruct(&theHeader[count],archiveHdFilename,sizeof(AnitaEventHeader_t)); */
/* makeLink(archiveHdFilename,PRIORITIZERD_EVENT_LINK_DIR); */
/* //Write Header and make Link for telemetry */
/* sprintf(telemHdFilename,"%s/hd_%d.dat",HEADER_TELEM_DIR, */
/* theHeader[count].eventNumber); */
/* retVal=writeStruct(&theHeader[count],telemHdFilename,sizeof(AnitaEventHeader_t)); */
/* makeLink(telemHdFilename,HEADER_TELEM_LINK_DIR); */
/* /\* Delete input *\/ */
/* sprintf(linkFilename,"%s/hd_%d.dat",EVENTD_EVENT_LINK_DIR, */
/* theHeader[count].eventNumber); */
/* sprintf(hdFilename,"%s/hd_%d.dat",EVENTD_EVENT_DIR, */
/* theHeader[count].eventNumber); */
/* removeFile(linkFilename); */
/* removeFile(hdFilename); */
}
}
}
} while(currentState==PROG_STATE_INIT && 0);
unlink(PRIORITIZERD_PID_FILE);
closeHkFilesAndTidy(&gpuWriter);
tidyUpGpuThings();
tidyUpTimingCalibThings();
/* Close the file which contains the high level output information */
printf("fakePrioritizerd exiting. Reached end of main\n.");
return 0;
}
