N-sim Emulation and simulation of Wireless Sensor Networks    Home    Project Page    Download    CVS    Installation    Configuration    Plug-ins  Hosted by

/home/brennan/n-sim/Vaike/linux/system-addons/drivers/raw_radiation.c Go to the documentation of this file. /*************************************************************************** * Copyright (C) 2007 by LANL/LANS pelowitz * * pelowitz.lanl.gov * * * * Code modifications: Balakumar J. Balasubramaniam (bbalasub@gmail.com) * * Ernst Ingo-Esch (ernst@lanl.gov) * * * * This program is not free software; you cannot redistribute it * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty of * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ //THIS VERSION Balakumar Balasubramaniam J // Last updated: 26 October, 2007 #ifdef HAVE_CONFIG_H #include <config.h> #endif #include <stdio.h> #include <stdlib.h> #include <stdio.h> #include <time.h> #include <sys/types.h> #include <sys/stat.h> //#include <signal.h> //#include <unistd.h> #include </usr/include/math.h> #include "usb.h" #include <assert.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> //#include "/usr/include/linux/sctp.h" #include <netdb.h> #include <unistd.h> #include <errno.h> #define PROGVERSION "1.0.0.1" #define BOOL int #define TRUE 1 #define FALSE 0 #define D0 0x01 #define D1 0x02 #define D2 0x04 #define D3 0x08 #define D4 0x10 #define D5 0x20 #define D6 0x40 #define D7 0x80 #define DFF 0xff #define LOG_FILEPATH_FLAG 0x00000001 #define SPECTRA_FILEPATH_FLAG 0x00000002 #define SPECTRA_SECONDS_FLAG 0x00000004 #define LOG_DOLOG_FLAG 0x00000008 #define PRE_ALARM_FLAG 0x00000010 #define POST_ALARM_FLAG 0x00000020 #define RING_SIZE_FLAG 0x00000040 #define DEAD_BAND_FLAG 0x00000080 #define BG_PERIOD_FLAG 0x00000100 #define SIGMA_ALARM_FLAG 0x00000200 #define PEAKTRACK_BIN_FLAG 0x00000400 #define PEAKTRACK_ROI_FLAG 0x00000800 #define PEAKTRACK_SMOOTH_FLAG 0x00001000 #define ALARM_FILEPATH_FLAG 0x00002000 #define SPECTRAOUT_SIZE_FLAG 0x00004000 #define BG_MINIMUM_FLAG 0x00008000 #define FORCE_NOALARM_FLAG 0x00010000 #define PEAKTRACK_FORCE_FLAG 0x00020000 #define ALL_FLAGS 0x0003ffff #define IPPROTO_SCTP 132 /* the device's vendor and product id */ //#define MY_VID 1234 //#define MY_PID 5678 #define MY_VID 0x0BD7 #define MY_PID 0xA021 #define REQUESTTYPEIN 0xc8 #define REQUESTTYPEOUT 0x48 /* the device's endpoints */ #define EP_IN_STATUSA 0x81 #define EP_IN_SPECTRAA 0x82 #define EP_IN_STATUSB 0x83 #define EP_IN_SPECTRAB 0x84 #define EP_IN_CONFIGUR 0x85 #define EP_OUT_CONFIGUR 0x01 #define EP_OUT 0x01 #define CLEARBUFF_A 0x80 #define CLEARBUFF_B 0x81 #define ENABLEMCA 0x82 #define DISABLEMCA 0x83 #define BUF_SIZE 65 #define CONFIG_SIZE 64 #define STATUS_SIZE 64 #define SPECT_SIZE (8192*3+1) #define SPECT_FSIZE (8192) #define NOSPECTRA_TYPE 0 #define UNASSIGNED_TYPE 1 #define PREALARM_TYPE 2 #define ALARM_TYPE 3 #define POSTALARM_TYPE 4 #define GUARD_TYPE 5 #define BG_TYPE 6 //will probably have to comment this out //unsigned int sleep(unsigned int seconds); // The remote receiver information goes here (bjb addition) char *server="128.165.54.61"; int port=2000; #define FRAGMENTSIZE 1024 #define PKTDELAY 10000 int fd; struct hostent *he; struct sockaddr_in their_addr; #define min(x,y) (x<y ? x:y) int tcpconnectopen=0; //data to configure the instrument struct { char *szParameter; char cIndex; char cMask; char cSigned; } config[] = { "reset_lockout=", 0, D7, 0, "flat_top_width=", 0, D6|D5|D4|D3, 0, "decimation_factor=", 0, D2|D1|D0, 0, "slow_channel_threshold=", 1, DFF, 0, "fast_channel_threshold=", 2, DFF, 0, "output_dac_offset=", 3, D7|D6|D5|D4|D3|D2|D1, 1, "dac_enabled=", 3, D0, 0, "normal_operation1=", 4, D7|D6, 0, "mca_enabled=", 4, D5, 0, "mcamcs_channel_mode=", 4, D4|D3|D2, 0, "dac_output=", 4, D1|D0, 0, "pileup_reject_interval=", 5, DFF, 0, "peaking_time=", 6, D7|D6|D5|D4, 0, "detector_reset_lockout_period=", 6, D3|D2, 0, "auto_baseline_reset_during_detector_reset=", 6, D1, 0, "dont_disable_mca_during_detector_reset=", 6, D0, 0, "rtd_slow_threshold=", 7, DFF, 0, "normal_operation2=", 8, D7, 0, "analog_gain=", 8, D6|D5, 0, "rtd_on=", 8, D4, 0, "rtd_time_threshold=", 8, D3|D2|D1|D0, 0, "50_digital_attenuation=", 9, D7, 0, "blr_enabled=", 9, D6, 0, "blr_down_correction=", 9, D5|D4, 0, "blr_up_correction=", 9, D3|D2, 0, "blr_correction_threshold=", 9, D1|D0, 0, "gate=", 10, D7|D6, 0, "mca_buffer_select=", 10, D5|D4, 0, "digital_scope_trigger=", 10, D3, 0, "aux_out=", 10, D2|D1|D0, 0, "preset_time_lsb=", 11, DFF, 0, "preset_time_byte2=", 12, DFF, 0, "preset_time_msb=", 13, DFF, 0, "fine_grain_normalizer_lsb=", 23, DFF, 0, "digital_scope_trigger_position=", 24, D7|D6, 0, "fine_grain_normalizer_msb=", 24, D5|D4|D3|D2|D1|D0, 0, "preset_counts_lsb=", 25, DFF, 0, "preset_counts_byte2=", 26, DFF, 0, "preset_counts_byte3=", 27, DFF, 0, "preset_counts_msb=", 28, DFF, 0, "mca_or_mcs_mode=", 29, D7, 0, "mcs_enabled=", 29, D5, 0, "mcs_time_base=", 29, D3|D2|D1|D0, 0, "sca1_lower_threshold_lsb=", 32, DFF, 0, "sca1_lower_threshold_msb=", 33, DFF, 0, "sca1_upper_threshold_lsb=", 34, DFF, 0, "sca1_enabled=", 35, D7, 0, "sca1_upper_threshold_msb=", 35, D6|D5|D4|D3|D2|D1|D0, 0, "sca2_lower_threshold_lsb=", 36, DFF, 0, "sca2_lower_threshold_msb=", 37, DFF, 0, "sca2_upper_threshold_lsb=", 38, DFF, 0, "sca2_enabled=", 39, D7, 0, "sca2_upper_threshold_msb=", 39, D6|D5|D4|D3|D2|D1|D0, 0, "sca3_lower_threshold_lsb=", 40, DFF, 0, "sca3_lower_threshold_msb=", 41, DFF, 0, "sca3_upper_threshold_lsb=", 42, DFF, 0, "sca3_enabled=", 43, D7, 0, "sca3_upper_threshold_msb=", 43, D6|D5|D4|D3|D2|D1|D0, 0, "sca4_lower_threshold_lsb=", 44, DFF, 0, "sca4_lower_threshold_msb=", 45, DFF, 0, "sca4_upper_threshold_lsb=", 46, DFF, 0, "sca4_enabled=", 47, D7, 0, "sca4_upper_threshold_msb=", 47, D6|D5|D4|D3|D2|D1|D0, 0, "sca5_lower_threshold_lsb=", 48, DFF, 0, "sca5_lower_threshold_msb=", 49, DFF, 0, "sca5_upper_threshold_lsb=", 50, DFF, 0, "sca5_enabled=", 51, D7, 0, "sca5_upper_threshold_msb=", 51, D6|D5|D4|D3|D2|D1|D0, 0, "sca6_lower_threshold_lsb=", 52, DFF, 0, "sca6_lower_threshold_msb=", 53, DFF, 0, "sca6_upper_threshold_lsb=", 54, DFF, 0, "sca6_enabled=", 55, D7, 0, "sca6_upper_threshold_msb=", 55, D6|D5|D4|D3|D2|D1|D0, 0, "sca7_lower_threshold_lsb=", 56, DFF, 0, "sca7_lower_threshold_msb=", 57, DFF, 0, "sca7_upper_threshold_lsb=", 58, DFF, 0, "sca7_enabled=", 59, D7, 0, "sca7_upper_threshold_msb=", 59, D6|D5|D4|D3|D2|D1|D0, 0, "sca8_lower_threshold_lsb=", 60, DFF, 0, "sca8_lower_threshold_msb=", 61, DFF, 0, "sca8_upper_threshold_lsb=", 62, DFF, 0, "sca8_enabled=", 63, D7, 0, "sca8_upper_threshold_msb=", 63, D6|D5|D4|D3|D2|D1|D0, 0, NULL,0,0,0 }; //configuration and status buffer //unsigned char tmp[BUF_SIZE]; unsigned char cur_config[BUF_SIZE]; //date of last change to configfile char szConfigChange[18] = {"0000_00_00_000000"}; //path to the executable -- used to find the .config file char szExecutablePath[256]; //holds the .config file and path char szConfigPathFile[256]; //holds the log file and path char szLogPathFile[256]; //holds the spectra path and file char szSpectraPathFile[256]; //holds the alarm path and file char szAlarmPathFile[256]; //holds the bg written when in alarm char szAlarmBGPathFile[256]; //collection duration in sec int iCollectSeconds; //flag for log 0=no log, 1 = min log, 2 = max log int iDoLog; //how often to save (seconds) back ground int bg_period = 3600; time_t bg_previous = 0; //alarm and spectra ring buffer int pre_alarm=1; int post_alarm=1; int ring_size=32; int ring_size_prev=0; int dead_band=2; int bg_minimum=20; int ring_insertion_point = 0; int ring_count = 0; double sigma_alarm = 5.0; int force_noalarm = 600; //peak tracking and rebin int spectraout_size=2500; int peaktrack_bin=750; int peaktrack_roi=50; int peaktrack_smooth=6; double fpeaktrack_offset = 0.0; double fpeaktrack_force = 1.0; float fA_TParam; float fA_Param; float fB_TParam; float fB_Param; float fC_TParam; float fC_Param; //alarm and background BOOL bInAlarm = FALSE; BOOL bHaveBG = FALSE; struct RING_ELEMENT{ time_t time; //start time of the spectra int iSum; double iSqSum; // bjb add int iType; int iSize; double fDuration; unsigned char status[BUF_SIZE]; //status from inst double fspectra[SPECT_FSIZE];//real version of spectra }ring_element,*pring_element; struct RING_ELEMENT alarm_spectra; struct RING_ELEMENT bg_spectra; struct RING_ELEMENT alarmbg_spectra; struct RING_ELEMENT tmp_spectra; struct RING_ELEMENT rebin_spectra; struct RING_ELEMENT *ring_buffer = NULL; usb_dev_handle *open_dev(void); void print_to_log(char*); char getconfig(char* pcBuf, int iOffset, char cMask, char cSigned); double Transmogrify(double fInPut, double fPeakTrackOffset, BOOL bUseTemp); double PeakTrack(double*dOutSpectrum, int iSize, int iExpectedBinPeak, int iRegionSize, int iSmoothWindow); void ReBIN(double*dInSpectrum, int iInSize, double*dOutSpectrum, int iOutSize, double dPeakTrackOffset, BOOL bUseTemp); void zero_spectra(struct RING_ELEMENT* pring_element) { pring_element->iSum = 0; pring_element->iSqSum=0; //bjb add pring_element->fDuration = 0.0; memset(&pring_element->fspectra,0,sizeof(pring_element->fspectra)); } void add_spectra(struct RING_ELEMENT* pring_elementdest, struct RING_ELEMENT* pring_elementsrc) { int i; pring_elementdest->iSum += pring_elementsrc->iSum; pring_elementdest->iSqSum += pring_elementsrc->iSqSum; //bjb add pring_elementdest->fDuration += pring_elementsrc->fDuration; for (i = 0; i < SPECT_FSIZE; i++) pring_elementdest->fspectra[i] += pring_elementsrc->fspectra[i]; } void print_spectra(struct RING_ELEMENT* pring_element,char* szPath,double fPeakTrackOffset) { int i,iLength; char szFilename[512]; struct tm*timeinfo; FILE *outfile; timeinfo = localtime(&pring_element->time); //build the spectra name with time stamp sprintf(szFilename,"%s_%04d_%02d_%02d_%02d%02d%02d.txt", szPath, timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); //make sure we have a good file name //step around the potential "C:" if running on windoz //some linux systems have problems with space in the file name //if that is the case here then add the check for space for (i = 2; i < (signed)strlen(szFilename); i++) { if ((szFilename[i] == ':') || (szFilename[i] == '\n') || (szFilename[i] == '?') || (szFilename[i] == '*')) szFilename[i] = '_'; } outfile = fopen(szFilename,"w"); print_to_log(szFilename); if (outfile) { fprintf(outfile,"Type: "); switch (pring_element->iType) { case NOSPECTRA_TYPE: fprintf(outfile,"No Spectra"); break; case UNASSIGNED_TYPE: fprintf(outfile,"Unassigned"); break; case PREALARM_TYPE: fprintf(outfile,"Pre-Alarm"); break; case ALARM_TYPE: fprintf(outfile,"Alarm"); break; case POSTALARM_TYPE: fprintf(outfile,"Post-Alarm"); break; case GUARD_TYPE: fprintf(outfile,"Guard"); break; case BG_TYPE: fprintf(outfile,"Background"); break; default: fprintf(outfile,"UNKNOWN"); } fprintf(outfile,"\n"); if (pring_element->iType != NOSPECTRA_TYPE) { fprintf(outfile,"Time: %04d\\%02d\\%02d %02d:%02d:%02d\n", timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); fprintf(outfile,"Duration (mSec): %f\n",pring_element->fDuration); fprintf(outfile,"Integral Sum: %d\n",pring_element->iSum); fprintf(outfile,"Peak Track: %f\n",fPeakTrackOffset); fprintf(outfile,"CONFIGURATION"); for (i = 0; i < CONFIG_SIZE; i++) { if (i%16==0)fprintf(outfile,"\n %04d ",i); fprintf(outfile,"%02x ",cur_config[i]); } fprintf(outfile,"\nSTATUS"); for (i = 0; i < STATUS_SIZE; i++) { if (i%16==0)fprintf(outfile,"\n %04d ",i); fprintf(outfile,"%02x ",pring_element->status[i]); } iLength = getconfig(cur_config, 4, D2|D3|D4, 0); fprintf(outfile,"\nSPECTRA (size:%d)\n", pring_element->iSize); for (i = 0; i < pring_element->iSize; i++) fprintf(outfile,"%04d %lf\n",i,pring_element->fspectra[i]); } fclose(outfile); } else { print_to_log("ERROR: Failed on write spectra file."); } } // this is where the packets are sent across the network // bjb addition send_spectra int send_spectra(struct RING_ELEMENT* pring_element,char* szPath,double fPeakTrackOffset) { char *pkt; int pktsize; char *tempstr; struct tm*timeinfo; int i, error; int remaining, total, tcnt; timeinfo = localtime(&pring_element->time); tempstr=malloc(1024); // tempstr holds the string that will be strcat-ted to pkt if (tempstr == NULL) { print_to_log("ERROR: memory allocation in send_spectra"); return -1; } // we need the size of the packet later on. so keep count of the number of characters pktsize=0; // allocate some large memory. this could be optimized depending upon the maximum size of the packet that will be sent pkt=malloc(2*SPECT_SIZE+CONFIG_SIZE+STATUS_SIZE); if (pkt == NULL) { print_to_log("ERROR: memory allocation in send_spectra"); return -1; } // initialize strings to NULL tempstr[0]='\0'; pkt[0]='\0'; // first create the pkt to be sent through the socket pktsize+=sprintf(tempstr,"PIPESTART "); strcat(pkt,tempstr); pktsize+=sprintf(tempstr,"Type: "); strcat(pkt,tempstr); switch (pring_element->iType) { case NOSPECTRA_TYPE: pktsize+=sprintf(tempstr,"No Spectra"); strcat(pkt,tempstr); break; case UNASSIGNED_TYPE: pktsize+=sprintf(tempstr,"Unassigned"); strcat(pkt,tempstr); break; case PREALARM_TYPE: pktsize+=sprintf(tempstr,"Pre-Alarm"); strcat(pkt,tempstr); break; case ALARM_TYPE: pktsize+=sprintf(tempstr,"Alarm"); strcat(pkt,tempstr); break; case POSTALARM_TYPE: pktsize+=sprintf(tempstr,"Post-Alarm"); strcat(pkt,tempstr); break; case GUARD_TYPE: pktsize+=sprintf(tempstr,"Guard"); strcat(pkt,tempstr); break; case BG_TYPE: pktsize+=sprintf(tempstr,"Background"); strcat(pkt,tempstr); break; default: pktsize+=sprintf(tempstr,"UNKNOWN"); strcat(pkt,tempstr); } pktsize+=sprintf(tempstr," "); strcat(pkt,tempstr); if (pring_element->iType != NOSPECTRA_TYPE) { pktsize+=sprintf(tempstr,"Time: %04d\\%02d\\%02d %02d:%02d:%02d ", timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); strcat(pkt,tempstr); pktsize+=sprintf(tempstr,"Duration (mSec): %f ", pring_element->fDuration); strcat(pkt,tempstr); pktsize+=sprintf(tempstr,"Integral Sum: %d ", pring_element->iSum); strcat(pkt,tempstr); pktsize+=sprintf(tempstr,"Peak Track: %f ", fPeakTrackOffset); strcat(pkt,tempstr); pktsize+=sprintf(tempstr,"CONFIGURATION "); strcat(pkt,tempstr); for (i=0;i<CONFIG_SIZE; i++) { if (i%16==0) { pktsize+=sprintf(tempstr," %04d ",i); strcat(pkt,tempstr); } pktsize+=sprintf(tempstr," %02x ",cur_config[i]); strcat(pkt,tempstr); } pktsize+=sprintf(tempstr,"STATUS "); strcat(pkt,tempstr); for (i=0;i<STATUS_SIZE; i++) { if (i%16==0) { pktsize+=sprintf(tempstr," %04d ",i); strcat(pkt,tempstr); } pktsize+=sprintf(tempstr," %02x ",pring_element->status[i]); strcat(pkt,tempstr); } pktsize+=sprintf(tempstr,"SPECTRA (size:%d) ", pring_element->iSize); strcat(pkt,tempstr); for (i=0;i<pring_element->iSize; i++) { pktsize+=sprintf(tempstr," %04d %lf ",i, pring_element->fspectra[i]); strcat(pkt,tempstr); } } pktsize+=sprintf(tempstr,"PIPEEND"); strcat(pkt,tempstr); // now send the pkt through the socket if (tcpconnectopen==0) { if ((fd = socket(PF_INET,SOCK_STREAM,0))<0) { perror("Socket"); print_to_log("ERROR: socket error during open\n"); return fd; } if ((he = gethostbyname(server))==NULL) { herror("gethostbyname"); print_to_log("ERROR: gethostbyname error\n"); return -1; } their_addr.sin_family = AF_INET; their_addr.sin_port = htons(port); their_addr.sin_addr = *((struct in_addr *)he->h_addr); memset(their_addr.sin_zero,'\0',sizeof(their_addr.sin_zero)); if (connect(fd,(struct sock_addr*)(& their_addr),sizeof(struct sockaddr))<0) { perror("connect error"); print_to_log("connect error\n"); } else tcpconnectopen=1; } printf("sending packet (size = %d)\n", pktsize); // send stuff here (break up packets to match MTU) // remaining=pktsize; // total=0; // tcnt=0; // while (total<pktsize) // { //if ((error = sendto(fd,pkt+total,min(FRAGMENTSIZE,remaining),0,(struct sock_addr*)(& their_addr),sizeof(struct sockaddr))) <0) if ((error = send(fd,pkt,pktsize,MSG_NOSIGNAL)) <0) { if (errno==EPIPE) tcpconnectopen=0; perror("sendto"); print_to_log("ERROR: sendto error\n"); } // tcnt++; // total+=error; // remaining-=error; // printf("%d)sendto returned %d\n",tcnt,error); // usleep(PKTDELAY); // need delay to mitigate packet collision // } free(pkt); free(tempstr); return 0; } //write string to the log file if iDoLog > 0 void print_to_log(char* szText) { char szfilename[256]; time_t rawtime; struct tm* timeinfo; FILE *outfile; if (iDoLog > 0) { time(&rawtime); timeinfo = localtime(&rawtime); sprintf(szfilename,"%s_%04d_%02d_%02d.log", szLogPathFile, timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday); outfile = fopen(szfilename,"a"); if (outfile) { fprintf(outfile,"%04d\\%02d\\%02d %02d:%02d:%02d %s\n", timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, szText); fclose(outfile); } if (iDoLog >= 4) printf("%04d\\%02d\\%02d %02d:%02d:%02d %s\n", timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, szText); } } double Transmogrify(double fInPut, double fPeakTrackOffset, BOOL bUseTemp) { double dATemp,dBTemp,dCTemp; if (fPeakTrackOffset > 0.0) { dATemp = 0.0; dBTemp = fPeakTrackOffset; dCTemp = 0.0; } else { dATemp = (bUseTemp)?fA_TParam:fA_Param; dBTemp = (bUseTemp)?fB_TParam:fB_Param; dCTemp = (bUseTemp)?fC_TParam:fC_Param; } return (dATemp * fInPut * fInPut + dBTemp * fInPut + dCTemp); } //assume iExpectedBinPeak iRegionSize/2 double PeakTrack(double*dOutSpectrum, int iSize, int iExpectedBinPeak, int iRegionSize, int iSmoothWindow) { double dShift = -1.0; int iMaxPointL = 0; int iMaxPointR = 0; int iMaxPoint = 0; double dMaxValueL = 0.0; double dMaxValueR = 0.0; int iPoint; if ((iExpectedBinPeak + iRegionSize/2) < iSize) { double* pdSmooth = (double*)malloc(sizeof(double)*iRegionSize); //double dSmooth[iRegionSize]; double dSmoothTemp; int i,j,k; int iHalfRegionSize = iRegionSize/2; //smooth the window around the expected peak if (iSmoothWindow) { for (i = iExpectedBinPeak-iHalfRegionSize,j=0; i < iExpectedBinPeak+iHalfRegionSize; i++,j++) { dSmoothTemp = 0.0; for (k = i - iSmoothWindow/2; k < i + iSmoothWindow/2; k++) dSmoothTemp += dOutSpectrum[k]; pdSmooth[j] = dSmoothTemp/iSmoothWindow; } } else { memcpy(pdSmooth,&dOutSpectrum[iExpectedBinPeak-iRegionSize/2],sizeof(double)*iRegionSize); } //find highest peak from left for (iPoint = 0; iPoint < iRegionSize; iPoint++) { if (dMaxValueL < pdSmooth[iPoint]) { iMaxPointL = iPoint; dMaxValueL = pdSmooth[iPoint]; } //TRACE("L = %d %f\r\n",iPoint,pdSmooth[iPoint]); } for (/*int*/ iPoint = iRegionSize-1; iPoint >= 0; iPoint--) { if (dMaxValueR < pdSmooth[iPoint]) { iMaxPointR = iPoint; dMaxValueR = pdSmooth[iPoint]; } //TRACE("R = %d %f\r\n",iPoint,pdSmooth[iPoint]); } if (iMaxPointL != iMaxPointR) iMaxPoint = (iMaxPointL + iMaxPointR)/2; else iMaxPoint = iMaxPointL; if (iMaxPoint>=0) //expected / observed dShift = (double)iExpectedBinPeak/(double)(iExpectedBinPeak + (iMaxPoint - (iRegionSize/2))); free (pdSmooth); } return dShift; } void ReBIN(double*dInSpectrum, int iInSize, double*dOutSpectrum, int iOutSize, double dPeakTrackOffset, BOOL bUseTemp) { int i; for (i = 0; i < iOutSize; i++) dOutSpectrum[i] = 0.0; double fStart, fEnd; double fFirst, fLast; int iStart, iEnd; int iTwixt; double fTotal; int iSourceIndex; //step across the source spectrum figuring the start KEV and end KEV for each bin //and distribute the source spectra into the destination spectra accordingly for (iSourceIndex = 0; iSourceIndex < iInSize; iSourceIndex++) { fStart = Transmogrify((double)iSourceIndex, dPeakTrackOffset, bUseTemp); fEnd = Transmogrify((double)(iSourceIndex+1), dPeakTrackOffset, bUseTemp); fTotal = fEnd - fStart; fFirst = fStart - (int)fStart; fLast = fEnd - (int)fEnd; iTwixt = (int)((int)fEnd - fStart); iStart = (int)fStart; iEnd = (int)fEnd; if ((iStart < iOutSize) && (iStart >= 0)) { if (iStart == iEnd) { dOutSpectrum[iStart] += dInSpectrum[iSourceIndex]; } else { //do we have any "fractional" bin to start with if ((fFirst > 0.0) && (fStart < iOutSize)) { double dTemp = (double)((1.0-fFirst) * dInSpectrum[iSourceIndex])/fTotal; dOutSpectrum[iStart] += dTemp; } //do all of the "whole" bins if (iTwixt > 0) for (i = 0; i < iTwixt; i++) { double fTemp = dInSpectrum[iSourceIndex]/fTotal; if ((iStart+i) < iOutSize) { if ((fFirst <= 0.0) && (iStart+i >= 0)) { dOutSpectrum[iStart+i] += fTemp; } else { int iTemp = iStart+i+1; if ((iTemp < iOutSize) && (iTemp >= 0)) { dOutSpectrum[iStart+i+1] += fTemp; } } } } //do the end "fractional" bin if we have any if ((fLast > 0.0) && (iEnd < iOutSize)) { double fTemp = fLast * dInSpectrum[iSourceIndex]/fTotal; dOutSpectrum[iEnd] += fTemp; } } } } } //try to open the usb device usb_dev_handle *open_dev(void) { struct usb_bus *bus; struct usb_device *dev; for(bus = usb_get_busses(); bus; bus = bus->next) { for(dev = bus->devices; dev; dev = dev->next) { if(dev->descriptor.idVendor == MY_VID && dev->descriptor.idProduct == MY_PID) { return usb_open(dev); } } } return NULL; } //get the cMask bits from the iOffset byte in pcBuf char getconfig(char* pcBuf, int iOffset, char cMask, char cSigned) { int iCount = 0; char cResult; unsigned char cTempMask = cMask; while ((cTempMask & 0x01)==0x00) { iCount++; cTempMask >>= 1; } if (cSigned) cResult = (pcBuf[iOffset] >> iCount); else cResult = (pcBuf[iOffset] >> iCount) & cTempMask; return cResult; } //set the cMask bits in the iOffset byte in the pcBuf to the //right justified bits in cValue void setconfig(char* pcBuf, int iOffset, unsigned char cMask, char cValue) { int iCount = 0; char cTempMask = cMask; while ((cTempMask & 0x01)==0x00) { iCount++; cTempMask >>= 1; } // printf("in setconfig pcBuff:%08x iOffset:%d cMask:%02x cValue:%d iCount:%d\n", // pcBuf,iOffset,cMask,cValue,iCount); pcBuf[iOffset] = (pcBuf[iOffset] & ~cMask) | ((cValue << iCount) & cMask); } //print out to the log file the configuration information in tmp void log_configuration(char* tmp) { int n; char s[256]; n = 0; while (config[n].szParameter) { sprintf(s,"%s%d",config[n].szParameter, getconfig(tmp,config[n].cIndex, config[n].cMask, config[n].cSigned)); print_to_log(s); n++; } } void reconfig1(void) { //get all the "REQUIRED" elements from the config file FILE* infile; //if we reconfigure then we probably want a new bg spectra bg_previous = 0; bInAlarm = FALSE; bHaveBG = FALSE; //open the config file infile = fopen(szConfigPathFile,"r"); //get the "REQUIRED" configuration from it if (infile) { char linebuffer[512]; char *szAt; unsigned int iFlags = 0x00000000; fgets(linebuffer,sizeof(linebuffer),infile); while (strlen(linebuffer) && (iFlags != ALL_FLAGS)) { if (strstr(linebuffer,"REQUIRED_log_filepath=")) { szAt = strchr(linebuffer,'=') + 1; strcpy(szLogPathFile,szAt); szLogPathFile[strlen(szLogPathFile)-1] = 0; iFlags |= LOG_FILEPATH_FLAG; } else if (strstr(linebuffer,"REQUIRED_spectra_filepath=")) { szAt = strchr(linebuffer,'=') + 1; strcpy(szSpectraPathFile,szAt); szSpectraPathFile[strlen(szSpectraPathFile)-1] = 0; iFlags |= SPECTRA_FILEPATH_FLAG; } else if (strstr(linebuffer,"REQUIRED_alarm_filepath=")) { szAt = strchr(linebuffer,'=') + 1; strcpy(szAlarmPathFile,szAt); szAlarmPathFile[strlen(szAlarmPathFile)-1] = 0; strcpy(szAlarmBGPathFile,szAlarmPathFile); strcat(szAlarmBGPathFile,"_BG"); iFlags |= ALARM_FILEPATH_FLAG; } else if (strstr(linebuffer,"REQUIRED_spectra_seconds=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&iCollectSeconds); iFlags |= SPECTRA_SECONDS_FLAG; } else if (strstr(linebuffer,"REQUIRED_log_dolog=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&iDoLog); iFlags |= LOG_DOLOG_FLAG; } else if (strstr(linebuffer,"REQUIRED_pre_alarm=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&pre_alarm); iFlags |= PRE_ALARM_FLAG; } else if (strstr(linebuffer,"REQUIRED_post_alarm=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&post_alarm); iFlags |= POST_ALARM_FLAG; } else if (strstr(linebuffer,"REQUIRED_ring_size=")) { ring_size_prev = ring_size; szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&ring_size); iFlags |= RING_SIZE_FLAG; } else if (strstr(linebuffer,"REQUIRED_dead_band=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&dead_band); iFlags |= DEAD_BAND_FLAG; } else if (strstr(linebuffer,"REQUIRED_bg_period=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&bg_period); iFlags |= BG_PERIOD_FLAG; } else if (strstr(linebuffer,"REQUIRED_sigma_alarm=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%lf",&sigma_alarm); iFlags |= SIGMA_ALARM_FLAG; } else if (strstr(linebuffer,"REQUIRED_peaktrack_bin=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&peaktrack_bin); iFlags |= PEAKTRACK_BIN_FLAG; } else if (strstr(linebuffer,"REQUIRED_peaktrack_roi=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&peaktrack_roi); iFlags |= PEAKTRACK_ROI_FLAG; } else if (strstr(linebuffer,"REQUIRED_peaktrack_smooth=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&peaktrack_smooth); iFlags |= PEAKTRACK_SMOOTH_FLAG; } else if (strstr(linebuffer,"REQUIRED_spectraout_size=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&spectraout_size); iFlags |= SPECTRAOUT_SIZE_FLAG; } else if (strstr(linebuffer,"REQUIRED_bg_minimum=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&bg_minimum); iFlags |= BG_MINIMUM_FLAG; } else if (strstr(linebuffer,"REQUIRED_force_noalarm=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%d",&force_noalarm); iFlags |= FORCE_NOALARM_FLAG; } else if (strstr(linebuffer,"REQUIRED_peaktrack_force=")) { szAt = strchr(linebuffer,'=') + 1; sscanf(szAt,"%lf",&fpeaktrack_force); iFlags |= PEAKTRACK_FORCE_FLAG; } fgets(linebuffer,sizeof(linebuffer),infile); } fclose(infile); } else { //couldn't open the config file so write a new one print_to_log("WARNING: Cannot find config file. Creating default file!"); strcpy(szLogPathFile,"Log"); strcpy(szSpectraPathFile,"Spectra"); strcpy(szAlarmPathFile,"Alarm"); strcpy(szAlarmBGPathFile,"Alarm_BG"); iCollectSeconds=1; iDoLog=1; pre_alarm=1; post_alarm=1; ring_size=64; dead_band=2; bg_period=3600; sigma_alarm=5.0; peaktrack_bin=1460; peaktrack_smooth=6; fpeaktrack_force=1.0; spectraout_size=2500; bg_minimum=60; infile = fopen(szConfigPathFile,"w"); if (infile) { fprintf(infile, "REQUIRED_log_dolog=1\n" "REQUIRED_log_filepath=Log\n" "REQUIRED_spectra_filepath=Spectra\n" "REQUIRED_alarm_filepath=Alarm\n" "REQUIRED_spectra_seconds=1\n" "REQUIRED_pre_alarm=1\n" "REQUIRED_post_alarm=1\n" "REQUIRED_ring_size=64\n" "REQUIRED_dead_band=2\n" "REQUIRED_bg_period=3600\n" "REQUIRED_sigma_alarm=5.0\n" "REQUIRED_peaktrack_bin=1460\n" "REQUIRED_peaktrack_roi=100\n" "REQUIRED_peaktrack_smooth=6\n" "REQUIRED_peaktrack_force=1.0\n" "REQUIRED_spectraout_size=2500\n" "REQUIRED_bg_minimum=60\n" "REQUIRED_force_noalarm=600\n" "reset_lockout=0\n" "flat_top_width=6\n" "decimation_factor=1\n" "slow_channel_threshold=0\n" "fast_channel_threshold=19\n" "output_dac_offset=13\n" "dac_enabled=1\n" "normal_operation1=0\n" "mca_enabled=1\n" "mcamcs_channel_mode=5\n" "dac_output=1\n" "pileup_reject_interval=0\n" "peaking_time=8\n" "detector_reset_lockout_period=2\n" "auto_baseline_reset_during_detector_reset=0\n" "dont_disable_mca_during_detector_reset=0\n" "rtd_slow_threshold=0\n" "normal_operation2=0\n" "analog_gain=1\n" "rtd_on=0\n" "rtd_time_threshold=6\n" "50_digital_attenuation=1\n" "blr_enabled=0\n" "blr_down_correction=3\n" "blr_up_correction=3\n" "blr_correction_threshold=3\n" "gate=0\n" "mca_buffer_select=0\n" "digital_scope_trigger=0\n" "aux_out=0\n" "preset_time_lsb=0\n" "preset_time_byte2=0\n" "preset_time_msb=0\n" "fine_grain_normalizer_lsb=0\n" "digital_scope_trigger_position=2\n" "fine_grain_normalizer_msb=4\n" "preset_counts_lsb=0\n" "preset_counts_byte2=0\n" "preset_counts_byte3=0\n" "preset_counts_msb=0\n" "mca_or_mcs_mode=0\n" "mcs_enabled=1\n" "mcs_time_base=0\n" "sca1_lower_threshold_lsb=0\n" "sca1_lower_threshold_msb=0\n" "sca1_upper_threshold_lsb=0\n" "sca1_enabled=0\n" "sca1_upper_threshold_msb=0\n" "sca2_lower_threshold_lsb=0\n" "sca2_lower_threshold_msb=0\n" "sca2_upper_threshold_lsb=0\n" "sca2_enabled=0\n" "sca2_upper_threshold_msb=0\n" "sca3_lower_threshold_lsb=0\n" "sca3_lower_threshold_msb=0\n" "sca3_upper_threshold_lsb=0\n" "sca3_enabled=0\n" "sca3_upper_threshold_msb=0\n" "sca4_lower_threshold_lsb=0\n" "sca4_lower_threshold_msb=0\n" "sca4_upper_threshold_lsb=0\n" "sca4_enabled=0\n" "sca4_upper_threshold_msb=0\n" "sca5_lower_threshold_lsb=0\n" "sca5_lower_threshold_msb=0\n" "sca5_upper_threshold_lsb=0\n" "sca5_enabled=0\n" "sca5_upper_threshold_msb=0\n" "sca6_lower_threshold_lsb=0\n" "sca6_lower_threshold_msb=0\n" "sca6_upper_threshold_lsb=0\n" "sca6_enabled=0\n" "sca6_upper_threshold_msb=0\n" "sca7_lower_threshold_lsb=0\n" "sca7_lower_threshold_msb=0\n" "sca7_upper_threshold_lsb=0\n" "sca7_enabled=0\n" "sca7_upper_threshold_msb=0\n" "sca8_lower_threshold_lsb=0\n" "sca8_lower_threshold_msb=0\n" "sca8_upper_threshold_lsb=0\n" "sca8_enabled=0\n" "sca8_upper_threshold_msb=0\n"); fclose(infile); } else print_to_log("WARNING: Cannot create default file!"); } } int reconfig2(usb_dev_handle *dev) { struct stat buf; struct tm* timeinfo; char s[512]; char szTemp[512]; int i,j,iResult; FILE *infile; //get the two descriptor strings from the instrument if (usb_get_string_simple(dev,1,szTemp,sizeof(szTemp)) > 0) { sprintf(s,"Descriptor 1:%s",szTemp); print_to_log(s); } if (usb_get_string_simple(dev,2,szTemp,sizeof(szTemp)) > 0) { sprintf(s,"Descriptor 2:%s",szTemp); print_to_log(s); } //get the current instrument configuration if ((iResult = usb_bulk_read(dev, EP_IN_CONFIGUR, cur_config, sizeof(cur_config), 5000)) != (sizeof(cur_config)-1)) { sprintf(s,"ERROR: bulk read configuration (%d) failed",iResult); print_to_log(s); return -1; } else { //log the previous configuration strcpy(s,"OLD CONFIGURATION"); szTemp[0] = 0; for (i = 0; i < CONFIG_SIZE; i++) { if ((i & 0x0000000f) == 0) { sprintf(szTemp,"\n %04d ",i); strcat(s,szTemp); } sprintf(szTemp,"%02x ",cur_config[i]); strcat(s,szTemp); } print_to_log(s); //print the verbose veraion only if iDoLog says so if (iDoLog > 1) log_configuration(cur_config); //get the remaining configuration information //build the 64 byte configuration based on the //old configuration. Note: only changed values //need to be included in the config file infile = fopen(szConfigPathFile,"r"); if (infile) { char linebuffer[256]; char *szAt; char cValue; //read a line from the config file while (fgets(linebuffer,sizeof(linebuffer),infile)) { int n; BOOL bFound; //see if any of our config strings are included //note that this assumes the config strings are //unique and that they start the line n = 0; bFound = FALSE; if ((strlen(linebuffer)>2) && (strstr(linebuffer,"REQUIRED_")==NULL)) { while (config[n].szParameter && !bFound) { if (strstr(linebuffer,config[n].szParameter)) { int dValue; //go to the character after the = szAt = strchr(linebuffer,'=')+1; sscanf(szAt,"%d",&dValue); //set the value in the config array cValue = (char)dValue; setconfig(cur_config,config[n].cIndex,config[n].cMask,cValue); bFound = TRUE; } n++; } if (!bFound) { for (i = 0; i < strlen(linebuffer); i++) if (linebuffer[i] == '\n') linebuffer[i] = 0; sprintf(s,"Configuration parameter \"%s\" not found.",linebuffer); print_to_log(s); } } } fclose(infile); } //log the new configuration strcpy(s,"NEW CONFIGURATION"); szTemp[0] = 0; for (i = 0; i < CONFIG_SIZE; i++) { if ((i & 0x0000000f) == 0) { sprintf(szTemp,"\n %04d ",i); strcat(s,szTemp); } sprintf(szTemp,"%02x ",cur_config[i]); strcat(s,szTemp); } print_to_log(s); //only do the verbose if iDoLog says so if (iDoLog > 2) log_configuration(cur_config); //send new configuration to instrument iResult=usb_bulk_write(dev, EP_OUT, cur_config, sizeof(cur_config)-1, 5000); if (iResult <= 0) { //log any errors sprintf(s,"ERROR: bulk write returned: %d",iResult); print_to_log(s); return -1; } //read back the new configuration if ((iResult = usb_bulk_read(dev, EP_IN_CONFIGUR, cur_config, sizeof(cur_config), 5000)) != (sizeof(cur_config)-1)) { sprintf(s,"ERROR: bulk read configuration (%d) failed",iResult); print_to_log(s); return -1; } //log the new configuration strcpy(s,"NEW CONFIGURATION READBACK"); szTemp[0] = 0; for (i = 0; i < CONFIG_SIZE; i++) { if ((i & 0x0000000f) == 0) { sprintf(szTemp,"\n %04d ",i); strcat(s,szTemp); } sprintf(szTemp,"%02x ",cur_config[i]); strcat(s,szTemp); } print_to_log(s); } //free up any existing storage in the ring buffer if (ring_buffer) { free(ring_buffer); ring_buffer = NULL; } //get memory for the new ring buffer ring_buffer = malloc(sizeof(ring_element)*ring_size); memset(ring_buffer,0,sizeof(ring_element)*ring_size); //start at a known point in the ring ring_insertion_point = 0; ring_count = 0; //get the config file's last modified time //so we can reconfig on the fly if the config file //gets modified stat(szConfigPathFile,&buf); timeinfo = localtime(&buf.st_mtime); sprintf(s,"%04d_%02d_%02d_%02d%02d%02d\n", timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); strcpy(szConfigChange,s); return 0; } void End(void) { print_to_log("Exiting"); } /* void Quit(int i) { printf("Quitting\n"); } */ int main(int argc, char**argv) { struct stat buf; int iDuration; int iCollectUSec; int iPostAlarmCount; usb_dev_handle *dev; /* the device handle */ int ret; // bjb char buffr[65535]; //bjb //configuration and status buffer //unsigned char tmp[BUF_SIZE]; //spectra buffer unsigned char spectra[SPECT_SIZE]; //various vars int i,j,q,iResult,iSeq; //easy translation from byte,byte,byte to int union { char c[4]; int i; } translate; //spectra file FILE* outfile; //configuration file // FILE* infile; //file name of spectra file char filename[256]; //struct to hold time from os time_t rawtime; //struct to hold values of date, time struct tm* timeinfo; //string buffer to facilitate talking to log char s[512]; char szTemp[64]; float mux, sigx; // mean and sigma of the count rate from the background atexit(End); // signal(9, Quit); //get the current path, we'll use it if //we can't find a path in the config file //and to find the config file if (argc > 0) strcpy(szExecutablePath,argv[0]); //default to 60 second spectra iCollectSeconds = 60; //default to doing a simple log file iDoLog = 1; //correct for windows .exe if (szExecutablePath[strlen(szExecutablePath)-4] == '.') szExecutablePath[strlen(szExecutablePath)-4] = 0; //build the configuration file path strcpy(szConfigPathFile,szExecutablePath); strcat(szConfigPathFile,".config"); strcpy(szLogPathFile,szExecutablePath); reconfig1(); print_to_log("Starting version: "PROGVERSION); usb_init(); /* initialize the library */ usb_find_busses(); /* find all busses */ usb_find_devices(); /* find all connected devices */ //get a handle to the device if((dev = open_dev()) == NULL) { print_to_log("ERROR: USB device not found!"); exit(-1); } // begin bjb code ret=usb_get_driver_np(dev,0,buffr,sizeof(buffr)); if (ret==0) { print_to_log("ERROR: interface 0 already claimed by another driver... attempting to detach it\n"); ret=usb_detach_kernel_driver_np(dev,0); print_to_log("ERROR: usb_detach_kernel_driver_np failed\n"); } // check if USB device is already claimed by a driver and attempt detach if it is // end bjb code //think this isn't necessary on this type of instrument //but should do it anyway //bjb if(usb_set_configuration(dev, 1) < 0) //bjb { //bjb print_to_log("ERROR: USB setting config 1 failed"); //bjb usb_close(dev); //bjb exit(-1); //bjb } //get control of the interface--don't let anyone else //talk to the instrument while we are if(usb_claim_interface(dev, 0) < 0) { print_to_log("ERROR: USB claiming interface 0 failed"); usb_close(dev); exit(-1); } // bjb code begin ret=usb_set_altinterface(dev,0); assert(ret>=0); // end bjb code if (reconfig2(dev) < 0) exit(-1); //read a spectra -- having some problems with garbage in the buffer //don't use this spectra // iResult = usb_bulk_read(dev, EP_IN_SPECTRAA, spectra, // sizeof(spectra), 5000); //clear buffer A //this is the actual start of the first acquisition iResult = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_OTHER, 0x80, 0, 0, spectra, 0, 5000); sleep(1); iResult = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_OTHER, 0x80, 0, 0, spectra, 0, 5000); if (iResult < 0) { sprintf(s,"ERROR: Cannot clear buffer. usb_control_msg returned %d",iResult); print_to_log(s); exit(-1); } //get time at start of spectra time(&rawtime); timeinfo = localtime(&rawtime); //get time at start of the spectra ring_buffer[ring_insertion_point].time = rawtime; bInAlarm = FALSE; bHaveBG = FALSE; //repeat forever for(iSeq = 1; iSeq <= 2; /*iSeq++*/) //while(1) { //check time of configuration file struct stat buf; stat(szConfigPathFile,&buf); timeinfo = localtime(&buf.st_mtime); sprintf(s,"%04d_%02d_%02d_%02d%02d%02d\n", timeinfo->tm_year+1900, timeinfo->tm_mon+1, timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); //did it change from startup if (strcmp(s,szConfigChange)!=0) { //reconfig if it did change reconfig1(); print_to_log("INFO: config file changed -- reconfiguring"); if (reconfig2(dev) < 0) exit(-1); } iDuration = 0; iCollectUSec = iCollectSeconds*500000; //Sleep(iCollectMSec-25); usleep(iCollectUSec);//wait half while (iDuration < (iCollectSeconds*1000)) { //Sleep(5); iCollectUSec = (iCollectSeconds*1000-iDuration)>>1; if (iCollectUSec > 5) usleep(iCollectUSec*1000); if ((iResult = usb_bulk_read(dev, EP_IN_STATUSA, ring_buffer[ring_insertion_point].status, BUF_SIZE, 5000)) != (BUF_SIZE-1)) { sprintf(s,"ERROR: bulk read STATUS A (%d) failed",iResult); print_to_log(s); return -1; } else { translate.c[0] = ring_buffer[ring_insertion_point].status[10]; translate.c[1] = ring_buffer[ring_insertion_point].status[11]; translate.c[2] = ring_buffer[ring_insertion_point].status[12]; translate.c[3] = 0; iDuration = translate.i * 100 + ring_buffer[ring_insertion_point].status[9];//in milliseconds } } //read the configuration from the instrument //although we currently have the config in cur_config this ensures that //the actual configuration is present (and it only takes 1msec) if ((iResult = usb_bulk_read(dev, EP_IN_CONFIGUR, cur_config, sizeof(cur_config), 5000)) != (sizeof(cur_config)-1)) { //log any error sprintf(s,"ERROR: bulk read configuration (%d) failed",iResult); print_to_log(s); exit(-1); } //read the status from the instrument if ((iResult = usb_bulk_read(dev, EP_IN_STATUSA, ring_buffer[ring_insertion_point].status, BUF_SIZE, 5000)) != (BUF_SIZE-1)) { //put errors in the log file sprintf(s,"ERROR: bulk read STATUS A (%d) failed",iResult); print_to_log(s); exit(-1); } else { //put the duration in the spectra translate.c[0] = ring_buffer[ring_insertion_point].status[10]; translate.c[1] = ring_buffer[ring_insertion_point].status[11]; translate.c[2] = ring_buffer[ring_insertion_point].status[12]; translate.c[3] = 0; ring_buffer[ring_insertion_point].fDuration = translate.i * 100 + ring_buffer[ring_insertion_point].status[9];//in milliseconds //read the spectra data iResult = usb_bulk_read(dev, EP_IN_SPECTRAA, spectra, sizeof(spectra), 5000); //put the spectra in the spectra file if ((iResult >= 0))// && outfile) { //zero the buffer and start the next acquisition //clear inst buffer A int iResult2; iResult2 = usb_control_msg(dev, USB_TYPE_VENDOR | USB_RECIP_OTHER, 0x80, 0, 0, spectra, 0, 5000); if (iResult2 < 0) {//error report on failure sprintf(s,"ERROR: usb_control_msg returned %d",iResult); print_to_log(s); exit(-1); } //s/get time at start of the next spectra time(&ring_buffer[(ring_insertion_point+1 % ring_size)].time); ring_buffer[ring_insertion_point].iSum = 0; ring_buffer[ring_insertion_point].iType = UNASSIGNED_TYPE; for (i = 0,j=0; i < iResult; i++) { switch (i%3) { case 0: translate.c[0] = spectra[i]; break; case 1: translate.c[1] = spectra[i]; break; case 2: translate.c[2] = spectra[i]; ring_buffer[ring_insertion_point].iSum += translate.i; ring_buffer[ring_insertion_point].iSqSum += (double)(translate.i)*(double)(translate.i); //bjb add ring_buffer[ring_insertion_point].fspectra[j++] = (double)translate.i; //ring_buffer[ring_insertion_point].fspectra[j++] = (double)ring_insertion_point; break; } } ring_buffer[ring_insertion_point].iSize = j; //do any alarm processing here //consider reading the most recent background back in along with the offset and sqrt sum at startup so that // after initial bg we always have a bg and bg sqrt. //if not in alarm and have bg and (sum sqrt/time / sum bg sqrt/time) > sigma_alarm //set "in alarm" flag //clear then add all pre alarm spectras to alarm spectra -- that we have received(may not have enough) //log event if (!bInAlarm)//start an alarm state only if not currently in an alarm { if (bHaveBG)//don't do an alarm unless we have sufficient bg { //is there an actual alarm situation //may need to change the division to use a "normalized isum" //printf("%f::%f::%f\n", // sqrt(ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration), // sqrt(bg_spectra.iSum/bg_spectra.fDuration), // sigma_alarm); //shorty commented out printf("%f::%f::%f\n", sqrt(ring_buffer[ring_insertion_point].iSum)/ring_buffer[ring_insertion_point].fDuration, sqrt(bg_spectra.iSum)/bg_spectra.fDuration, sigma_alarm); // shorty addition printf("iSqSum = %f\n",bg_spectra.iSqSum); mux=bg_spectra.iSum/bg_spectra.fDuration; // bjb addition sigx=sqrt(bg_spectra.iSum)/bg_spectra.fDuration; // bjb addition if (ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration > mux+sigma_alarm*sigx) // bjb addition //if ((sqrt(ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration) / // sqrt(bg_spectra.iSum/bg_spectra.fDuration)) > sigma_alarm) // bjb comment out //bjb addition//if ((bg_spectra.iSum/bg_spectra.fDuration+sigma_alarm*sqrt(bg_spectra.iSum)/bg_spectra.fDuration) < //bjb addition//ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration) //bjb addition { //set all the flags and accumulate the pre alarms bInAlarm = TRUE; iPostAlarmCount = 0; ring_buffer[ring_insertion_point].iType = ALARM_TYPE; zero_spectra(&alarm_spectra); alarm_spectra.iType = ALARM_TYPE; alarm_spectra.time = ring_buffer[ring_insertion_point].time; alarm_spectra.iSize = ring_buffer[ring_insertion_point].iSize; memcpy(alarm_spectra.status,ring_buffer[ring_insertion_point].status,BUF_SIZE); int iExtractPoint; print_to_log("Start of alarm."); for (i = 1; i <= pre_alarm; i++) { print_to_log("Pre-alarm spectra added to alarm spectra."); iExtractPoint = ring_insertion_point-i; if (iExtractPoint < 0) iExtractPoint += ring_size; ring_buffer[iExtractPoint].iType = PREALARM_TYPE; add_spectra(&alarm_spectra,&ring_buffer[iExtractPoint]); } } } //create a bg spectra //if not in alarm and time for new background and have enough spectra to do bg //generate new background spectra based on current - pre-alarm - deadband + n of older spectra //set have bg //do peak search and save offset for alarm spectra //do re-bin to put into kEv //save bg if (!bInAlarm) { //do we have enough background potential spectra? int iTestPoint = ring_insertion_point; BOOL bNewBackground = TRUE; iTestPoint -= pre_alarm; iTestPoint -= dead_band; if (iTestPoint < 0) iTestPoint += ring_size; //check if the minimum number of spectra are available for (i=0; i<bg_minimum; i++) { int iTemp = iTestPoint - i; if (iTemp < 0) iTemp += ring_size; if ((ring_buffer[iTemp].iType != BG_TYPE) && (ring_buffer[iTemp].iType != UNASSIGNED_TYPE)) { bNewBackground = FALSE; break; //break out of the for loop we don't have enough } } if (bNewBackground) { int iSpectraCount = 0; time_t now; zero_spectra(&tmp_spectra); tmp_spectra.time = ring_buffer[iTestPoint].time; tmp_spectra.iSize = ring_buffer[iTestPoint].iSize; tmp_spectra.iType = BG_TYPE; bg_spectra.time = ring_buffer[iTestPoint].time; bg_spectra.iSize = spectraout_size; for (i = 0; i < BUF_SIZE; i++) bg_spectra.status[i] = ring_buffer[iTestPoint].status[i]; while (((ring_buffer[iTestPoint].iType == BG_TYPE) || (ring_buffer[iTestPoint].iType == UNASSIGNED_TYPE)) && (iSpectraCount < ring_size) && (iTestPoint != ring_insertion_point)) { ring_buffer[iTestPoint].iType = BG_TYPE; add_spectra(&tmp_spectra,&ring_buffer[iTestPoint]); iTestPoint--; if (iTestPoint < 0) iTestPoint += ring_size; iSpectraCount++; } if (!bHaveBG) print_to_log("Have Background"); bHaveBG = TRUE; //re-bin for the number of bins // shorty comment out//ReBIN(tmp_spectra.fspectra, //shorty comment out// tmp_spectra.iSize,rebin_spectra.fspectra,spectraout_size, //shorty comment out// (double)spectraout_size/(double)tmp_spectra.iSize,FALSE); ReBIN(tmp_spectra.fspectra,tmp_spectra.iSize,rebin_spectra.fspectra,spectraout_size, (double)spectraout_size/(double)tmp_spectra.iSize,FALSE); // shorty addition //peak track if (peaktrack_bin > 0) { fpeaktrack_offset = PeakTrack(rebin_spectra.fspectra, spectraout_size, peaktrack_bin, peaktrack_roi, peaktrack_smooth); } else fpeaktrack_offset = fpeaktrack_force; //re-bin for the peak track //shorty comment out//ReBIN(rebin_spectra.fspectra, //shorty comment out// spectraout_size, bg_spectra.fspectra, spectraout_size, fpeaktrack_offset,FALSE); ReBIN(rebin_spectra.fspectra, spectraout_size,bg_spectra.fspectra,spectraout_size, fpeaktrack_offset,FALSE); // shorty addition bg_spectra.iType = BG_TYPE; bg_spectra.iSize = spectraout_size; bg_spectra.fDuration = tmp_spectra.fDuration; bg_spectra.iSum = tmp_spectra.iSum; //if n time since last bg write then write bg time(&now); if ((now - bg_previous) > bg_period) { sprintf(s,"Current Peak Track Offset %f",fpeaktrack_offset); print_to_log(s); bg_previous = now; send_spectra(&bg_spectra,szSpectraPathFile,fpeaktrack_offset); print_spectra(&bg_spectra,szSpectraPathFile,fpeaktrack_offset); } } } } //if in alarm and post alarm count <= post alarm desired //add current to alarm spectra //decrement post alarms //if post alarm count == post alarm desired //re-bin to bg spectra offset using computed and saved peak offset //print out the spectra //log event if (bInAlarm) //we are currently in an alarm situation { //add the current spectra if needed if (iPostAlarmCount <= post_alarm) { add_spectra(&alarm_spectra,&ring_buffer[ring_insertion_point]); ring_buffer[ring_insertion_point].iType = (iPostAlarmCount==0)?ALARM_TYPE:POSTALARM_TYPE; print_to_log("Current spectra added to alarm spectra."); } //see if we have enough to stop adding spectra if (iPostAlarmCount == post_alarm) { time_t temptime; //re-bin to the output size ReBIN(alarm_spectra.fspectra, alarm_spectra.iSize, tmp_spectra.fspectra, spectraout_size, (double)spectraout_size/(double)alarm_spectra.iSize, FALSE); // //re-bin to the peaktrack_offset if (peaktrack_bin <= 0) fpeaktrack_offset = fpeaktrack_force; // shorty comment out ReBIN(alarm_spectra.fspectra, // shorty comment out alarm_spectra.iSize, tmp_spectra.fspectra, spectraout_size, fpeaktrack_offset,FALSE); ReBIN(tmp_spectra.fspectra, tmp_spectra.iSize, rebin_spectra.fspectra, spectraout_size, fpeaktrack_offset, FALSE); // shorty addition //clear out the full memory memset(alarm_spectra.fspectra,0,sizeof(alarm_spectra.fspectra)); //copy the rebin data back into the alarm spectra // shorty comment out memcpy(alarm_spectra.fspectra,tmp_spectra.fspectra,spectraout_size*sizeof(double)); memcpy(alarm_spectra.fspectra,rebin_spectra.fspectra,spectraout_size*sizeof(double)); // shorty addition alarm_spectra.iSize=spectraout_size; //print out the alarm spectra send_spectra(&alarm_spectra,szAlarmPathFile,fpeaktrack_offset); print_spectra(&alarm_spectra,szAlarmPathFile,fpeaktrack_offset); //print out the background spectra temptime = bg_spectra.time; bg_spectra.time = alarm_spectra.time; send_spectra(&bg_spectra,szAlarmBGPathFile,fpeaktrack_offset); print_spectra(&bg_spectra,szAlarmBGPathFile,fpeaktrack_offset); bg_spectra.time = temptime; if (peaktrack_bin > 0) { sprintf(s,"Peak Track Offset Used: %f",fpeaktrack_offset); print_to_log(s); } //print_to_log("Alarm and Background spectra printed."); } //if past post alarms and bg is down then drop out of alarm status else if (iPostAlarmCount > post_alarm) { mux=bg_spectra.iSum/bg_spectra.fDuration; sigx=sqrt(bg_spectra.iSum)/bg_spectra.fDuration; // bjb addition if (iPostAlarmCount > force_noalarm) { bInAlarm = FALSE; iPostAlarmCount = 0; bHaveBG = FALSE; print_to_log("Forced out of alarm status. Building new BG."); } else if (ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration <= mux+sigma_alarm*sigx) // bjb addition // bjb addition// else if ((bg_spectra.iSum/bg_spectra.fDuration+sigma_alarm*sqrt(bg_spectra.iSum)/bg_spectra.fDuration) > ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration) // else if (sqrt((ring_buffer[ring_insertion_point].iSum/ring_buffer[ring_insertion_point].fDuration) / // sqrt(bg_spectra.iSum / bg_spectra.fDuration) < sigma_alarm)) { bInAlarm = FALSE; iPostAlarmCount = 0; print_to_log("Normal out of alarm status. Keeping old BG."); } } //make sure we've gone beyond this if -- only do it once iPostAlarmCount++; } //point to the next in the ring buffer ring_insertion_point = (ring_insertion_point + 1) % ring_size; //keep track of how many we have in the buffer //'cause we don't want to try to use spectra that aren't there if (ring_count < ring_size) ring_count++; } else { //put errors in the log file sprintf(s,"ERROR: read SPECTRA (%d) failed",iResult); print_to_log(s); exit(-1); } } //close the spectra file if (outfile) fclose(outfile); }//repeat forever //actually the os will do these for us usb_release_interface(dev, 0); usb_close(dev); return 0; }

© 2007, Los Alamos National Security, LLC.