/**************************************************************************** /* F i l e D a t a /* /* Module : SRAMManager /* C.I. No. : /* $Revision: 1.55 $ /* $Date: 2005/03/20 18:30:38 $ /* Belonging to : /* : /* $RCSfile: SM_SRAMPageManager_op.c,v $ /* Program Type : /* Sub-modules : /* /**************************************************************************** /* S W D e v e l o p m e n t E n v i r o n m e n t /* /* Host system : /* SW Compiler : /* $Author: sebastiani $ /* : /**************************************************************************** /* U p d a t i n g /* /* $Log: SM_SRAMPageManager_op.c,v $ /* Revision 1.55 2005/03/20 18:30:38 sebastiani /* *** empty log message *** /* /* Revision 1.54 2005/02/21 08:58:29 sebastiani /* all log comments completed /* /* Revision 1.53 2005/02/19 10:20:16 sebastiani /* accept all MCMC in all mode /* /* Revision 1.52 2005/01/26 18:46:56 sebastiani /* new bug fixes for WS /* /* Revision 1.51 2005/01/07 15:42:53 sebastiani /* add exp 64 mode delay patch /* /* Revision 1.50 2004/11/19 15:14:55 sebastiani /* PRH_EXTERN_{VAR,ARR,TABLE} removed and put them on the autogenerated parameter heeader file /* /* Revision 1.49 2004/11/05 16:43:08 sebastiani /* *** empty log message *** /* /* Revision 1.48 2004/09/17 15:01:00 faber /* LU_INFN_LOG flags fixing /* /* Revision 1.47 2004/09/09 14:53:58 sebastiani /* fix prepare page to send cmd /* /* Revision 1.46 2004/08/26 16:54:41 sebastiani /* version work fine /* /* Revision 1.45 2004/08/13 14:42:22 sebastiani /* Add Neutron detector! /* need add file ND_READ_ACQ.dat on site ... /* /* Revision 1.44 2004/08/09 08:30:29 sebastiani /* fix calo alarm procedure /* /* Revision 1.43 2004/08/02 12:17:26 sebastiani /* fix little /* /* Revision 1.42 2004/07/27 17:30:17 faber /* OBT can be now in second or milliseconds, depending of the situazion. /* OBT_s is used for FM compatibility, OBT_ms basically for MM infos /* /* Revision 1.41 2004/07/27 13:27:18 sebastiani /* SM_EXPERIMENT cancelled /* /* Revision 1.40 2004/07/21 14:09:22 sebastiani /* Fix PacketCounter /* /* Revision 1.39 2004/07/16 16:13:05 sebastiani /* important fix /* /* Revision 1.38 2004/07/15 13:46:01 sebastiani /* fix some bugs /* /* Revision 1.37 2004/06/15 08:25:01 sebastiani /* *** empty log message *** /* /* Revision 1.36 2004/06/04 14:24:40 sebastiani /* clear some files /* /* Revision 1.35 2004/06/01 16:41:24 sebastiani /* EventReceive ANY /* /* Revision 1.34 2004/05/26 17:48:30 sebastiani /* *** empty log message *** /* /* Revision 1.33 2004/05/25 14:07:18 faber /* *** empty log message *** /* /* Revision 1.32 2004/05/24 10:25:28 faber /* OS_EVENT_UNCOMPLETED_CMDIF introduced /* /* Revision 1.31 2004/05/20 12:51:58 sebastiani /* nee /* /* Revision 1.30 2004/05/20 09:04:23 sebastiani /* ok /* /* Revision 1.29 2004/05/19 08:45:05 sebastiani /* fix bug /* /* Revision 1.28 2004/05/10 12:59:17 faber /* __FILEID__ right value fixed: many .c files had the wrong value! /* /* Revision 1.27 2004/04/29 16:13:59 alfarano /* update cal /* /* Revision 1.25 2004/02/13 10:11:30 alfarano /* calorimeter initialization func and more /* /* Revision 1.24 2004/02/05 15:38:50 sebastiani /* PM_WAIT_TRIGEVENT managed as a parametrized macro /* /* Revision 1.23 2004/02/05 14:45:13 sebastiani /* unlock acq in PageWasSaved DAQ_SETUP case /* /* Revision 1.22 2004/02/02 08:34:40 sebastiani /* change Macro to write packet header /* /* Revision 1.21 2004/01/22 08:58:54 sebastiani /* WAIT time introduced between DAQ and CMD/IF DMA programming /* /* Revision 1.20 2004/01/13 15:07:38 tassa /* add send forced idaq cmd! /* /* Revision 1.19 2003/12/30 14:22:44 sebastiani /* change crc function: 8 => 16 /* /* Revision 1.18 2003/11/18 09:01:15 alfarano /* laben patch fixes some problems /* /* Revision 1.17 2003/11/13 16:15:06 sebastiani /* PM_opUnLockAcquisition added to SM_DAQSETUP in PageWasSaved, as suggested in the new laben versione released in these days /* /* Revision 1.16 2003/11/10 12:13:25 sebastiani /* PM_pi_SetPktType and SM_PktType global variable introdused /* /* Revision 1.15 2003/10/31 17:21:29 sebastiani /* bug fix on read and write function in TM_TMTCManager: added busy flag control on each read & write /* CRC functions updated in the SRAMPageManager /* /* Revision 1.14 2003/10/30 15:34:04 faber /* CRC debug fixed 2 /* /* Revision 1.13 2003/10/30 14:55:52 faber /* CRC function debuggin (some fixes) /* /* Revision 1.12 2003/10/30 10:09:36 sebastiani /* *** empty log message *** /* /* Revision 1.11 2003/10/29 17:41:48 sebastiani /* *** empty log message *** /* /* Revision 1.10 2003/10/27 19:03:10 sebastiani /* PM_WRITE_* macros introduced: new header format/management. /* length,pktsize,crc /* /* Revision 1.9 2003/10/21 16:09:12 alfarano /* LU_LOG_INFN replacement for all remaining original log functions /* /* Revision 1.8 2003/10/17 09:16:43 sebastiani /* SKETCHBOARD_FREE event introduced /* /* Revision 1.7 2003/09/17 16:38:53 faber /* PM_pi_ExpPageAvail() introduced /* /* Revision 1.6 2003/09/10 13:44:52 laben /* delete reference to FILE2 ( new File System Model). /* /* Revision 1.5 2003/09/10 10:30:43 faber /* -introduced: /* void PM_pi_DisableStore_In_DataTimeOut(), /* void PM_pi_EnableStore_In_DataTimeOut(), /* UINT32 PM_pi_GetDataLength(SM_PAGEID page); /* - fixed: Bug in PreparePage, EXP64 mode "one page only use". /* the fixing consist of the subsitution /* of the istruction /* SM_SelectedPage <<= 2; /* with /* SM_SelectedPage += 4; /* /* Revision 1.4 2003/08/26 07:44:56 faber /* events introduced /* /* Revision 1.3 2003/08/08 11:02:20 sebastiani /* introduced SM_DIRECT mode /* /* Revision 1.2 2003/08/07 08:46:55 wizard /* SIMULATOR bugfix ifdef/ifndef /* SM_PktSize update bug fix in SM_op_PageHasData in order to fix the laben bug of SM_pi_GetPacket /* introduced the notification to a task from the PageHasData /* /* Revision 1.1.1.1 2003/08/04 09:40:21 sebastiani /* Imported sources laben rel. 19.06.2003 integrated with pam2 /* /* Revision 1.21 2003/06/13 09:04:15 aurora /* removed a debug comment /* /* Revision 1.20 2003/06/09 10:20:34 aurora /* improved the management of data acquisition. /* Fixed the dalay when copy the data in to ERC32 memory /* /* Revision 1.19 2003/05/12 16:05:20 aurora /* fixed the last modify /* /* Revision 1.18 2003/05/12 15:48:24 aurora /* Increase the lostpkt counter on ETO interrupt /* /* Revision 1.17 2003/04/29 13:31:34 aurora /* management of page overrun every 64 Kbyte /* /* Revision 1.16 2003/03/24 11:06:11 aurora /* management for interrupt on page overrun at 128KByte in DAQSetup mode /* /* Revision 1.15 2003/01/30 10:17:54 aurora /* correct the routine for share HBUS /* /* Revision 1.14 2003/01/22 14:03:52 aurora /* improved management of HBUS /* /* Revision 1.13 2002/11/14 09:55:02 zulia /* correct the size of data send through CMD I/F /* improved the management of ET ISR /* /* Revision 1.12 2002/10/17 10:08:21 zulia /* fixed PIFReset /* /* Revision 1.11 2002/10/17 08:38:57 zulia /* - added counters for distinguish the cause of lost packets /* - added a flag (SM_EnableStoreET) for enable or disable the /* storage of a packet when rises a ET /* - fixed the clear of page_overrun interrupt /* /* Revision 1.10 2002/09/02 12:55:18 zulia /* reset of PIF on boot /* /* Revision 1.9 2002/07/31 14:34:09 zulia /* send data to CMD I/F after Event Trigger /* set header to 12 Bytes /* packet counter to 32 bits /* provided interface for copy buffer from micro to PIF sram /* /* Revision 1.8 2002/06/25 09:17:03 zulia /* Disable reset of packet counter after change state mode /* /* Revision 1.7 2002/06/19 08:25:31 zulia /* added provided interface PM_pi_GetAndIncrPckCnt that /* get and increase the packet counter /* /* Revision 1.6 2002/05/09 08:16:35 zulia /* * acceptance release /* /* /*****************************************************************************/ /*============================= Include File ================================*/ #include #define __FILEID__ _SM_SRAMPageManager_op__c #include #include #include LU_DECL_MASK(); #include #include #include #include #include #include #include #include /*============================== local define ===============================*/ /*======================== Object Internal variables ========================*/ /*****************************************************************************/ /* @Variable: SM_AcqMode */ /* @Purpose : */ /* PIF Acquisition mode */ /* @@ */ /*****************************************************************************/ static SM_ACQMODE SM_AcqMode; /*****************************************************************************/ /* @Variable: SM_EmptyPage */ /* @Purpose : */ /* Flag to mark a SRAM "page empty" after an EVENT T.O. */ /* @@ */ /*****************************************************************************/ static BOOL SM_EmptyPage; /*****************************************************************************/ /* @Variable: SM_TrashFlag */ /* @Purpose : */ /* Flag to mark the use of the SRAM trash page */ /* @@ */ /*****************************************************************************/ //static BOOL SM_TrashFlag; /*****************************************************************************/ /* @Variable: SM_SavingSkatchboard */ /* @Purpose : */ /* Flag to mark that the sketchboard page storage is in progress */ /* @@ */ /*****************************************************************************/ static BOOL SM_SavingSkatchboard; /*****************************************************************************/ /* @Variable: SM_SelectedPage */ /* @Purpose : */ /* Current SRAM page used to hold incoming experiment packets */ /* @@ */ /*****************************************************************************/ static UINT32 SM_SelectedPage; /*****************************************************************************/ /* @Variable: SM_PacketCounter */ /* @Purpose : */ /* Header packet counter */ /* @@ */ /*****************************************************************************/ static UINT32 SM_PacketCounter; /*****************************************************************************/ /* @Variable: SM_LostPackets */ /* @Purpose : */ /* Lost packet counter */ /* @@ */ /*****************************************************************************/ static UINT32 SM_LostPackets; /*****************************************************************************/ /* @Variable: SM_ETOLostPackets */ /* @Purpose : */ /* Lost packet counter due to ETO */ /* @@ */ /*****************************************************************************/ static UINT32 SM_ETOLostPackets; /*****************************************************************************/ /* @Variable: SM_MMSULostPackets */ /* @Purpose : */ /* Lost packet counter */ /* @@ */ /*****************************************************************************/ static UINT32 SM_MMSULostPackets; /*****************************************************************************/ /* @Variable: SM_ERC32LostPackets */ /* @Purpose : */ /* Counter for packets lost during the transfer in ERC32 memory */ /* @@ */ /*****************************************************************************/ static UINT32 SM_ERC32LostPackets; /*****************************************************************************/ /* @Variable: SM_LostTriggers */ /* @Purpose : */ /* Lost Event Trigger counter */ /* @@ */ /*****************************************************************************/ static UINT32 SM_LostTriggers; /*****************************************************************************/ /* @Variable: SM_ExpPageCounter */ /* @Purpose : */ /* Counter of the free SRAM pages for the experiment pkts caching */ /* @@ */ /*****************************************************************************/ static UINT32 SM_ExpPageCounter; /*****************************************************************************/ /* @Variable: SM_PktRamCpyFlag */ /* @Purpose : */ /* Experiment pkt RAM copy flag */ /* @@ */ /*****************************************************************************/ static BOOL SM_PktRamCpyFlag; /*****************************************************************************/ /* @Variable: SM_PktSize */ /* @Purpose : */ /* Size of the last recieved packet */ /* @@ */ /*****************************************************************************/ static UINT32 SM_PktSize; /*****************************************************************************/ /* @Variable: SM_PktStatus */ /* @Purpose : */ /* Status of the last recieved packet */ /* @@ */ /*****************************************************************************/ static SM_PKTSTAT SM_PktStatus; /*****************************************************************************/ /* @Variable: SM_PktLock */ /* @Purpose : */ /* Flag used to avoid concurrency in R/W on PktBuf during exp. acquisition */ /* @@ */ /*****************************************************************************/ static BOOL SM_PktLock; /*****************************************************************************/ /* @Variable: SM_PIFTrOk */ /* @Purpose : */ /* PIF Tranfer status flag */ /* @@ */ /*****************************************************************************/ static SD_TRANSFERSTAT SM_PIFTrOk; /*****************************************************************************/ /* @Variable: SM_CalDataLenght[16] */ /* @Purpose : */ /* Number of data to write after ET for initialise intruments */ /* These values are significatives only for SM_CALEXPx pages */ /* @@ */ /*****************************************************************************/ static UINT32 SM_CalDataLenght[16]; /*****************************************************************************/ /* @Variable: SM_CalPageSelected */ /* @Purpose : */ /* page used for initialise instruments */ /* @@ */ /*****************************************************************************/ static SM_PAGEID SM_CalPageSelected; /*****************************************************************************/ /* @Variable: SM_PacketStoreIsOngoing */ /* @Purpose : */ /* Flag to mark that the store of scientific packet is ongoing */ /* @@ */ /*****************************************************************************/ static BOOL SM_PacketStoreIsOngoing; static BOOL SM_ERC32IsOngoing; /*****************************************************************************/ /* @Variable: SM_HBUSIsLocked */ /* @Purpose : */ /* Flag to mark that HBUS is in use from an other function */ /* @@ */ /*****************************************************************************/ static BOOL SM_HBUSIsLocked; /*****************************************************************************/ /* @Variable: SM_NotifyTask (INFN) */ /* @Purpose : */ /* Task to notify the Event to */ /* @@ */ /*****************************************************************************/ static UINT32 SM_NotifyTask_PKT_READY; static UINT32 SM_NotifyTask_SKETCHBOARD_FREE; /*****************************************************************************/ /* @Variable: SM_EnableStore */ /* @Purpose : */ /* Enable/Disable the storing of the packed in the File Sistem (FILE1) */ /* @@ */ /*****************************************************************************/ static BOOL SM_EnableStore; /*****************************************************************************/ /* @Variable: SM_PktType */ /* @Purpose : */ /* Enable/Disable the storing of the packed in the File Sistem (FILE1) */ /* @@ */ /*****************************************************************************/ static BOOL SM_PktType; static TI_TIME SM_exp64_t1=0; /*****************************************************************************/ /*===== S R A M P a g e M a n a g e r P R O V I D E D I N T E R F A C E ==*/ /*****************************************************************************/ /* @Function: SM_opSRAMPageManagerInit */ /* @Purpose : */ /* This function initializes the SRAM Page Manager object (its variables). */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_EXITCODE OUT Return code */ /* RstPktCounter IN Flag used to enable the lost packets */ /* counter reset */ /* @@ */ /*****************************************************************************/ SM_EXITCODE PM_opSRAMPageManagerInit(BOOL RstPktCounter) { SM_EXITCODE status = SM_SUCCESS; unsigned int intLevel; unsigned int i; /* Init the lost packet counter only at startup */ if(RstPktCounter) { SD_piPIFReset(); SM_LostPackets = 0; SM_ETOLostPackets = 0; SM_MMSULostPackets = 0; SM_ERC32LostPackets = 0; SM_LostTriggers = 0; SM_PacketCounter = 0; /* Init the timeout timers */ SD_piSetEventTimeout(SM_ETO_TICS); SD_piSetDataTimeout(SM_DTO_TICS); /* Init the Header length registers */ SD_piSetDataHeaderLength(SM_PKTHEADER_LEN); SD_piSetCalibrationHeaderLength(SM_PKTHEADER_LEN); /* Init the length of data in all calibration pages */ for (i = 0; i < SM_MAXPAGE; SM_CalDataLenght[i++] = 0); /* select first page for initialise intruments */ SM_CalPageSelected = SM_CALEXP0; } /* Mask all interrupt related to PIF acquisition */ OS_piInterDisable(&intLevel); SD_piMaskInt(SD_EVT_TO | SD_DATA_TO | SD_PAGE_OVR); OS_piInterEnable(intLevel); ERC32_Mask_interrupt(ETIRQ); /* Set the acquisition mode to IDLE */ FT_piChangeAcqMode(SM_IDLE); SM_ExpPageCounter = DIRECTPAGES; // console_outbyte_polled( 0, 'J' ); // console_outbyte_polled( 0, '\n' ); SM_PktLock = FALSE; SM_PktRamCpyFlag = FALSE; SM_NotifyTask_PKT_READY = RM_INFN_TASK; SM_NotifyTask_SKETCHBOARD_FREE = RM_INFN_TASK; SM_PktType = 0; SM_PIFTrOk = SD_TRANSFERFAIL; // Skratchboard SM_SavingSkatchboard = FALSE; return (status); } /*****************************************************************************/ /* @MACRO: SM_WRITE_PACKET_HEADER */ /* @Purpose : */ /* Write in the PIF the header for an incaming event. Must be used only */ /* inside the PreparePage */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ static BYTE PM_WRITE_PKT_HEADER_Pkt_Header[SM_PKTHEADER_LEN]; static UINT32 PM_WRITE_PKT_HEADER_index; #define PM_WRITE_PKT_HEADER_BYTE(byte) do { \ PM_WRITE_PKT_HEADER_Pkt_Header[PM_WRITE_PKT_HEADER_index]=(BYTE)(byte); \ SD_piWriteSRAM(PM_WRITE_PKT_HEADER_Pkt_Header[PM_WRITE_PKT_HEADER_index]); \ PM_WRITE_PKT_HEADER_index++; \ } while(0) #define PM_INC_PKT_COUNTER() do { \ if(SM_EnableStore) \ SM_PacketCounter++; \ } while(0) #define PM_WRITE_PKT_HEADER(page,pkt_size,crc) do { \ /* Retrive OBT */ \ TI_TIME obt; \ TI_piGetTimeInfo_ms(&obt); \ /* Set the SRAM R/W register to the first byte of the Cal page */ \ PM_WRITE_PKT_HEADER_index=0; \ SD_piSetSRAMRWAddress((UINT32)(page) * SM_SRAMPAGESIZE); \ /* The HBUS is locked by PM_opPreparePage */ \ PM_WRITE_PKT_HEADER_BYTE(PM_HEADER_1); \ PM_WRITE_PKT_HEADER_BYTE(PM_HEADER_2); \ PM_WRITE_PKT_HEADER_BYTE(PM_HEADER_3); \ /* write packet type */ \ PM_WRITE_PKT_HEADER_BYTE(SM_PktType | ((SM_PktStatus == SM_PKT_BAD)<<7) ); \ PM_WRITE_PKT_HEADER_BYTE(SM_PktType | ((SM_PktStatus == SM_PKT_BAD)<<7) ); \ /* Write the packet counter */ \ PM_WRITE_PKT_HEADER_BYTE(((SM_PacketCounter>>16) & 0x000000FF)); \ PM_WRITE_PKT_HEADER_BYTE(((SM_PacketCounter>>8 ) & 0x000000FF)); \ PM_WRITE_PKT_HEADER_BYTE(( SM_PacketCounter & 0x000000FF)); \ /* Write the OBT */ \ PM_WRITE_PKT_HEADER_BYTE(((obt>>24) & 0x000000FF)); \ PM_WRITE_PKT_HEADER_BYTE(((obt>>16) & 0x000000FF)); \ PM_WRITE_PKT_HEADER_BYTE(((obt>>8 ) & 0x000000FF)); \ PM_WRITE_PKT_HEADER_BYTE(( obt & 0x000000FF)); \ /* Write the pkt lenght */ \ PM_WRITE_PKT_HEADER_BYTE((( (pkt_size)-SM_PKTHEADER_LEN)>>16) & 0x000000FF); \ PM_WRITE_PKT_HEADER_BYTE((( (pkt_size)-SM_PKTHEADER_LEN)>>8 ) & 0x000000FF); \ PM_WRITE_PKT_HEADER_BYTE( ( (pkt_size)-SM_PKTHEADER_LEN) & 0x000000FF); \ crc=CM_Compute_CRC16(0,&PM_WRITE_PKT_HEADER_Pkt_Header[0],PM_WRITE_PKT_HEADER_index); \ /*crc=CM_Compute_CRC8_8(0,&PM_WRITE_PKT_HEADER_Pkt_Header[0],PM_WRITE_PKT_HEADER_index); */\ PM_WRITE_PKT_HEADER_BYTE(crc & 0xff); \ PM_WRITE_PKT_HEADER_index=0; \ } while(0) /********************************************************g*********************/ /* @Function: SM_opPreparePage */ /* @Purpose : */ /* The function selects a new SRAM page to hold the new data coming from */ /* the DAQ I/F and write the page header. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ status_code PM_opPreparePage(BOOL daq_dmain) { #ifdef SIMULATOR return; #else unsigned int intLevel; status_code status=CM_RC_SUCCESSFUL; /* Mask any further Event Trigger */ ERC32_Mask_interrupt(ETIRQ); #if 0 { static TI_TIME SM_exp64_t0=0; TI_TIME delay=0; TI_piGetTimeInfo_ms(&SM_exp64_t0); if(SM_exp64_t0>SM_exp64_t1){ if((SM_exp64_t0-SM_exp64_t1) 0 || !daq_dmain) { if (SM_CalDataLenght[SM_CalPageSelected] > 0) { /* Set the selected SRAM page where take data for */ /* initialise instrument */ SD_piSetCMDBUSReadPage(SM_CalPageSelected); /* Set end of data of selected page */ SD_piSetCMDBUSReadParams( (UINT32)(SM_CalPageSelected * SM_SRAMPAGESIZE + SM_CalDataLenght[SM_CalPageSelected]-1)); /* Start the acquisition and timeouts */ if (daq_dmain) { SM_ExpPageCounter--; /* Set the fix SRAM page to hold the incoming pkt */ SD_piSetDAQWritePage(SM_CALPAGE); SD_piTrigCalibrationEvent(); } /* start transfer to CMD I/F*/ SD_piStartTransferToCMD(); //console_outbyte_polled( 0, 'X' ); //console_outbyte_polled( 0, '\n' ); } else{ status=CM_RC_CALPAGEEMPTY; } }else{ status=CM_RC_NOPAGEAVAILABLE; } } break; #if 0 /* /\* Actions performed after an ET in Experiment acq. mode *\/ */ /* case SM_EXPERIMENT: */ /* { */ /* /\* Check if a new SRAM cache page has to be selected: *\/ */ /* /\* - The last acquisition was good and need to be saved *\/ */ /* /\* - In the last acquisition the trash page was selected *\/ */ /* if((SM_PIFTrOk == TRUE && */ /* SM_EmptyPage == FALSE ) || */ /* SM_TrashFlag == TRUE) */ /* { */ /* /\* Check if there is any free SRAM page left *\/ */ /* if(SM_ExpPageCounter > 0) */ /* { */ /* SM_ExpPageCounter--; */ /* /\* Select the next SRAM page number in a circular buffer of *\/ */ /* /\* EXPPAGES pages *\/ */ /* SM_SelectedPage++; */ /* SM_SelectedPage &= 0x00000007; */ /* /\* Set the SRAM page to hold the incoming pkt *\/ */ /* SD_piSetDAQWritePage(SM_SelectedPage); */ /* /\* The selected page is not the trash one *\/ */ /* SM_TrashFlag = FALSE; */ /* } */ /* else */ /* { */ /* /\* No more free cache SRAM page left. The Trash one must be selected *\/ */ /* SD_piSetDAQWritePage(TRASHPAGE); */ /* SM_TrashFlag = TRUE; */ /* } */ /* } */ /* /\* If the last acquisition was not good then reselect the same SRAM page *\/ */ /* else */ /* SD_piSetDAQWritePage(SM_SelectedPage); */ /* if (SM_CalDataLenght[SM_CalPageSelected] > 0) */ /* { */ /* /\* Set the selected SRAM page where take data for *\/ */ /* /\* initialise instrument *\/ */ /* SD_piSetCMDBUSReadPage(SM_CalPageSelected); */ /* /\* Set end of data of selected page *\/ */ /* SD_piSetCMDBUSReadParams( */ /* (UINT32)(SM_CalPageSelected * SM_SRAMPAGESIZE + */ /* SM_CalDataLenght[SM_CalPageSelected]-1)); */ /* /\* Start the acquisition *\/ */ /* if (daq_dmain) */ /* { */ /* SD_piTrigDataEvent(); */ /* } */ /* /\* start transfer to CMD I/F *\/ */ /* SD_piStartTransferToCMD(); */ /* // PM_WRITE_PKT_HEADER_BEFORE(SM_SelectedPage); */ /* } */ /* } break; */ #endif /* Actions performed after an ET in Exp64 acq. mode */ case SM_EXP64: { if(SM_ExpPageCounter > 0) { SM_ExpPageCounter--; SM_SelectedPage += 4; SM_SelectedPage &= 0x00000007; /* Set the SRAM page to hold the incoming pkt */ SD_piSetDAQWritePage(SM_SelectedPage); if (SM_CalDataLenght[SM_CalPageSelected] > 0) { /* Set the selected SRAM page where take data for */ /* initialise instrument */ SD_piSetCMDBUSReadPage(SM_CalPageSelected); /* Set end of data of selected page */ SD_piSetCMDBUSReadParams( (UINT32)(SM_CalPageSelected * SM_SRAMPAGESIZE + SM_CalDataLenght[SM_CalPageSelected]-1)); /* Start the acquisition */ SD_piTrigData64Event(); /* start transfer to CMD I/F */ SD_piStartTransferToCMD(); // PM_WRITE_PKT_HEADER_BEFORE(SM_SelectedPage); } else{ status=CM_RC_CALPAGEEMPTY; } } else{ status=CM_RC_NOPAGEAVAILABLE; } #if 0 /* /\* Check if a new SRAM cache page has to be selected: *\/ */ /* /\* - The last acquisition was good and need to be saved *\/ */ /* /\* - In the last acquisition the trash page was selected *\/ */ /* if((SM_PIFTrOk == TRUE && */ /* SM_EmptyPage == FALSE ) || */ /* SM_TrashFlag == TRUE) { */ /* /\* Check if there is any free SRAM page left *\/ */ /* if(SM_ExpPageCounter > 0) { */ /* SM_ExpPageCounter--; */ /* /\* Select the page 0 and the page 3 in a circulat buffer of *\/ */ /* /\* page 0 and page 3 *\/ */ /* SM_SelectedPage += 4; */ /* SM_SelectedPage &= 0x00000007; */ /* /\* Set the SRAM page to hold the incoming pkt *\/ */ /* SD_piSetDAQWritePage(SM_SelectedPage); */ /* /\* The selected page is not the trash one *\/ */ /* SM_TrashFlag = FALSE; */ /* } */ /* else { */ /* /\* No more free cache SRAM page left. The Trash one must be selected *\/ */ /* SD_piSetDAQWritePage(TRASHPAGE); */ /* SM_TrashFlag = TRUE; */ /* } */ /* } */ /* /\* If the last acquisition was not good then reselect the same SRAM page *\/ */ /* else */ /* SD_piSetDAQWritePage(SM_SelectedPage); */ /* if (SM_CalDataLenght[SM_CalPageSelected] > 0) */ /* { */ /* /\* Set the selected SRAM page where take data for *\/ */ /* /\* initialise instrument *\/ */ /* SD_piSetCMDBUSReadPage(SM_CalPageSelected); */ /* /\* Set end of data of selected page *\/ */ /* SD_piSetCMDBUSReadParams( */ /* (UINT32)(SM_CalPageSelected * SM_SRAMPAGESIZE + */ /* SM_CalDataLenght[SM_CalPageSelected]-1)); */ /* /\* Start the acquisition *\/ */ /* SD_piTrigData64Event(); */ /* /\* start transfer to CMD I/F *\/ */ /* SD_piStartTransferToCMD(); */ /* // PM_WRITE_PKT_HEADER_BEFORE(SM_SelectedPage); */ /* } */ #endif // 0 }break; } OS_piInterEnable(intLevel); } else { /* HBUS is locked or an other storage is ongoing */ SM_LostTriggers++; status=CM_RC_BUSY; } /* Release the HBUS for an other transfer */ PM_opReleaseHBUS(); /* Clear ERC32 interrupt */ OS_piInterDisable(&intLevel); ERC32_Clear_interrupt(ETIRQ); ERC32_Unmask_interrupt(ETIRQ); OS_piInterEnable(intLevel); return status; #endif // SIMULATOR } void PM_opDisableStore_In_DataTimeOut() { SM_EnableStore = FALSE; } void PM_opEnableStore_In_DataTimeOut() { SM_EnableStore = TRUE; } BYTE PM_opSetPktType(BYTE pkttype) { BYTE old=SM_PktType; SM_PktType = pkttype; return old; } BYTE PM_opGetPktType() { return SM_PktType; } /*****************************************************************************/ /* @Function: PM_opPageHasData */ /* @Purpose : */ /* The function is used to tell the Page Manager that the last selected page*/ /* contains data written by the DAQ I/F. The Page Manager checks the data */ /* and send a "store" request to the MMSUManager. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ static UINT32 counterleft=~0x00; void PM_opPageHasData(void) { #ifdef SIMULATOR return; #else SD_DAQ_WRESULT pageInfo; unsigned int intLevel; static BYTE crc_pkt; unsigned int pkt_size; BOOL savepagecalled=FALSE; OS_piInterDisable(&intLevel); SD_piClearInt(SD_DATA_TO); OS_piInterEnable(intLevel); ERC32_Clear_interrupt(ERC32_INTERRUPT_EXTERNAL_2); counterleft=SD_piGetCMDCounterLeft(); switch(SM_AcqMode) { case SM_DIRECT: { /* Check if the packet buffer is not locked for read operation */ if(!SM_PktLock && !SD_piIsIntPending(SD_PAGE_OVR)) { /* Evaluate the packet size in bytes */ SM_PktSize = pageInfo = SD_piGetDAQWriteResult(); SM_PktSize++; if (FT_piSavePage(SM_CALPAGE, SM_PktSize, FS_ERC32) != FT_SUCCESS) { SM_ExpPageCounter=DIRECTPAGES; SM_ERC32LostPackets++; } else SM_ERC32IsOngoing=TRUE; /* Check if the packet is good */ if(SD_piIsDAQWriteOk() == SD_TRANSFEROK) SM_PktStatus = SM_PKT_GOOD; else { SM_LostPackets++; SM_PktStatus = SM_PKT_BAD; } // TBD:Post to INFN: DAQPkt READY !!! /* Enable again the Event Trigger Interrupt*/ if(counterleft){ /*@LOG PageHasData: counterleft != 0 - counterleft*/ LU_INFN_LOG(LU_DEBUG_TRACE,LU_MASK(__FILEID__),__FILEID__,__LINE__,counterleft); if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_UNCOMPLETED_CMDIF); }else if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_PKT_READY); } else { /* Clear the Page Overrun pending interrupt*/ if(SD_piIsIntPending(SD_PAGE_OVR)) { SD_piClearInt(SD_PAGE_OVR); SM_EmptyPage = TRUE; } SM_PktStatus = SM_PKT_BAD; SM_ExpPageCounter=DIRECTPAGES; // console_outbyte_polled( 0, '@' ); // console_outbyte_polled( 0, '\n' ); } } break; /* Actions performed after an DTO in DAQSetup acq. mode */ case SM_DAQSETUP: { /* Check if the packet buffer is not locked for read operation */ if(!SM_PktLock && !SD_piIsIntPending(SD_PAGE_OVR)) { /* Increase the packet counter */ /* Evaluate the packet size in bytes */ SM_PktSize = pageInfo = SD_piGetDAQWriteResult(); SM_PktSize++; /* Check if the packet is good */ if(SD_piIsDAQWriteOk() == SD_TRANSFEROK) SM_PktStatus = SM_PKT_GOOD; else { SM_LostPackets++; SM_PktStatus = SM_PKT_BAD; } PM_WRITE_PKT_HEADER(SM_CALPAGE,SM_PktSize,crc_pkt); PM_INC_PKT_COUNTER(); savepagecalled=FALSE; /* Put a save request for the selected SRAM page in the save queue*/ if(SM_PktRamCpyFlag) if (FT_piSavePage(SM_CALPAGE, pageInfo, FS_ERC32) != FT_SUCCESS) SM_ERC32LostPackets++; else{ SM_ERC32IsOngoing=TRUE; savepagecalled=TRUE; } if(SM_EnableStore) if (FT_piSavePage(SM_CALPAGE, pageInfo, FS_FILE1) != FT_SUCCESS) SM_MMSULostPackets++; else{ SM_PacketStoreIsOngoing=TRUE; savepagecalled=TRUE; } if(!savepagecalled){ SM_ExpPageCounter=DAQSETUPPAGES; // console_outbyte_polled( 0, '@' ); // console_outbyte_polled( 0, '\n' ); } // console_outbyte_polled( 0, 'y' ); // console_outbyte_polled( 0, '\n' ); if(counterleft){ /*@LOG PageHasData: counterleft != 0 - counterleft*/ LU_INFN_LOG(LU_DEBUG_TRACE,LU_MASK(__FILEID__),__FILEID__,__LINE__,counterleft); if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_UNCOMPLETED_CMDIF); }else if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_PKT_READY); } else { /* Clear the Page Overrun pending interrupt*/ if(SD_piIsIntPending(SD_PAGE_OVR)) { SD_piClearInt(SD_PAGE_OVR); SM_EmptyPage = TRUE; } SM_LostPackets++; /* this counter is increased only because is reported in RTF */ SM_LostTriggers++; /* The transfer is complete then enalble an other acquisition */ SM_ExpPageCounter=DAQSETUPPAGES; // console_outbyte_polled( 0, '@' ); // console_outbyte_polled( 0, '\n' ); } } break; case SM_EXP64: { // SM_exp64_t2=SM_exp64_t1; /* Actions performed after an DTO in experiment acq. mode */ SM_EmptyPage = FALSE; /* Check if the packet is good */ /* SM_PIFTrOk = SD_piIsDAQWriteOk(); if(SM_TrashFlag == FALSE && SM_PIFTrOk == SD_TRANSFEROK && !SD_piIsIntPending(SD_PAGE_OVR)) */ if(!SD_piIsIntPending(SD_PAGE_OVR)) { /* Get the paket end address in SRAM */ SM_PktSize = pageInfo = SD_piGetDAQWriteResult() ; SM_PktSize++; SM_PktSize -= (SM_SelectedPage * SM_SRAMPAGESIZE); /* Increase the packet counter */ #if 0 if(PRH_VAR_RM_IDAQONLYACQ_ADDON_SIZE) { SM_PktSize += CM_RAND(PRH_VAR_RM_IDAQONLYACQ_ADDON_SIZE); if(SM_PktSize > SM_SRAMPAGESIZE64) SM_PktSize=SM_SRAMPAGESIZE64; pageInfo = SM_PktSize + (SM_SelectedPage * SM_SRAMPAGESIZE) -1; } #endif /* Check if the packet is good */ if(SD_piIsDAQWriteOk() == SD_TRANSFEROK) SM_PktStatus = SM_PKT_GOOD; else { SM_LostPackets++; SM_PktStatus = SM_PKT_BAD; } PM_WRITE_PKT_HEADER(SM_SelectedPage,SM_PktSize,crc_pkt); PM_INC_PKT_COUNTER(); savepagecalled=FALSE; /* Check if it's time to copy the packet into RAM */ if(SM_PktRamCpyFlag) { if(FT_piSavePage(SM_SelectedPage, pageInfo, FS_ERC32) != FT_SUCCESS) SM_ERC32LostPackets++; else { SM_ERC32IsOngoing=TRUE; savepagecalled=TRUE; } } /* Put a save request for the selected SRAM page in the save queue*/ if(SM_EnableStore) if(FT_piSavePage(SM_SelectedPage, pageInfo, FS_FILE1) != FT_SUCCESS) { /* The save request was refused so the current page can be immediatly */ /* reused */ SM_EmptyPage = TRUE; /* A packet was lost */ SM_MMSULostPackets++; } else { savepagecalled=TRUE; SM_PacketStoreIsOngoing=TRUE; } if(!savepagecalled) if(++SM_ExpPageCounter > EXP64PAGES) { SM_ExpPageCounter = EXP64PAGES; } if(counterleft){ /*@LOG PageHasData: counterleft != 0 - counterleft*/ LU_INFN_LOG(LU_DEBUG_TRACE,LU_MASK(__FILEID__),__FILEID__,__LINE__,counterleft); if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_UNCOMPLETED_CMDIF); }else if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_PKT_READY); } else /* The packet is not good */ { /* Clear the Page Overrun pending interrupt*/ if(SD_piIsIntPending(SD_PAGE_OVR)) { SD_piClearInt(SD_PAGE_OVR); SM_EmptyPage = TRUE; } SM_LostPackets++; SM_LostTriggers++; if(++SM_ExpPageCounter > EXP64PAGES) { SM_ExpPageCounter = EXP64PAGES; } } } break; default:{ /*@LOG Unespected Data Timeout LOG_INFN HA_piLogHistoryEntry10(HA_E10_SW_SM,HA_E10_UNESPECTED_DTO,HA_E10_REP2_NULL); */ LU_INFN_LOG(LU_CRITICAL|LU_HA,LU_MASK(__FILEID__),__FILEID__,__LINE__,HA_E10_REP2_NULL); } } #endif // SIMULATOR } #ifdef DEBUG status_code PM_opPreparePage_dummy() { unsigned int intLevel; status_code status=CM_RC_SUCCESSFUL; OS_piInterDisable(&intLevel); SD_piSetDAQWritePage(SM_CALPAGE); if(SM_ExpPageCounter > 0) { SM_ExpPageCounter--; SM_SelectedPage =0; } else{ status=CM_RC_NOPAGEAVAILABLE; } OS_piInterEnable(intLevel); return status; } #endif // DEBUG /*****************************************************************************/ /* @Function: PM_opPageIsEmpty */ /* @Purpose : */ /* The function is used to tell the Page Manager that the last selected page*/ /* was not written by the DAQ I/F. */ /* selected */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ void PM_opPageIsEmpty(void) { unsigned int intLevel; /* The packet was lost*/ SM_ETOLostPackets++; SM_LostTriggers++; if(SM_NotifyTask_PKT_READY != NULL_TASK) OS_piEventSend(SM_NotifyTask_PKT_READY,OS_EVENT_ETO); switch(SM_AcqMode) { /* Actions performed after an ETO in DAQSetup acq. mode */ case SM_DIRECT: case SM_DAQSETUP: SM_ExpPageCounter=DIRECTPAGES; // console_outbyte_polled( 0, '@' ); // console_outbyte_polled( 0, '\n' ); break; case SM_EXP64: if(++SM_ExpPageCounter > EXP64PAGES) { SM_ExpPageCounter = EXP64PAGES; } break; } /* Clear the Event Timeout interrupt */ OS_piInterDisable(&intLevel); SD_piClearInt(SD_EVT_TO); OS_piInterEnable(intLevel); } /*****************************************************************************/ /* @Function: PM_opPageWasSaved */ /* @Purpose : */ /* The function tels the Page Manager that a SRAM page was saved in MMSU and*/ /* can be reused */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ void PM_opPageWasSaved(FS_FILEID FileId) { unsigned int intLevel; switch (FileId) { case FS_FILE1: { switch(SM_AcqMode) { case SM_EXP64: { OS_piInterDisable(&intLevel); SM_PacketStoreIsOngoing=FALSE; /* Increment the number free available SRAM page */ if(SM_ERC32IsOngoing==FALSE){ SM_ExpPageCounter++; if(SM_ExpPageCounter > EXP64PAGES) { SM_ExpPageCounter = EXP64PAGES; } } OS_piInterEnable(intLevel); } break; case SM_DAQSETUP: { OS_piInterDisable(&intLevel); SM_PacketStoreIsOngoing=FALSE; /* Increment the number free available SRAM page */ if(SM_ERC32IsOngoing==FALSE){ SM_ExpPageCounter=DAQSETUPPAGES; // console_outbyte_polled( 0, 'Y' ); // console_outbyte_polled( 0, '\n' ); } OS_piInterEnable(intLevel); } break; case SM_DIRECT: break; default: break; } } break; case FS_HK: { /* Unlock the schetchboard page as soon as it is saved*/ SM_SavingSkatchboard = FALSE; if(SM_NotifyTask_SKETCHBOARD_FREE != NULL_TASK) OS_piEventSend(SM_NotifyTask_SKETCHBOARD_FREE,OS_EVENT_SKETCHBOARD_FREE); } break; case FS_ERC32: { switch(SM_AcqMode) { case SM_DIRECT: case SM_DAQSETUP: OS_piInterDisable(&intLevel); SM_ERC32IsOngoing=FALSE; if(SM_PacketStoreIsOngoing==FALSE){ SM_ExpPageCounter=DIRECTPAGES; // console_outbyte_polled( 0, 'Z' ); // console_outbyte_polled( 0, '\n' ); } OS_piInterEnable(intLevel); break; case SM_EXP64: OS_piInterDisable(&intLevel); SM_ERC32IsOngoing=FALSE; if(SM_PacketStoreIsOngoing==FALSE){ SM_ExpPageCounter++; if(SM_ExpPageCounter > EXP64PAGES) { SM_ExpPageCounter = EXP64PAGES; } } OS_piInterEnable(intLevel); break; } } break; case FS_CMD: break; default: break; } } /*****************************************************************************/ /* @Function: PM_op_SetAcqMode */ /* @Purpose : */ /* The function selects the operational mode for the Page Manager: */ /* science data or calibration. The transition is possible only if in the */ /* curent mode there are no more SRAM page to store into MMSU */ /* Due to the fact that the SRAM is a shared resource between the */ /* acquisition and the mass memory store automas, this function highly */ /* coupled with the MMSUManager Enable/Disable store functions. */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_EXITCODE OUT Return code */ /* @@ */ /*****************************************************************************/ SM_EXITCODE PM_op_SetAcqMode(SM_ACQMODE mode) { SM_EXITCODE status = SM_SUCCESS; UINT32 idx; unsigned int intLevel; /* Mask any interrupt related to acquisition activity */ OS_piInterDisable(&intLevel); SD_piMaskInt(SD_EVT_TO | SD_DATA_TO | SD_PAGE_OVR); ERC32_Mask_interrupt(ETIRQ); OS_piInterEnable(intLevel); PM_opReleaseHBUS(); SM_ERC32IsOngoing=FALSE; SM_PacketStoreIsOngoing = FALSE; switch(mode) { /* Enter the Direct Mode mode */ case SM_DIRECT: { SD_piSetCalibrationHeaderLength(0); SM_AcqMode = SM_DIRECT; /* Init the last recieved packet status to a */ /* "to be acquired" condition */ SM_PktStatus = SM_PKT_ACQ; /* Enable the skatchboard usage */ SM_SavingSkatchboard = FALSE; /**/ SM_ExpPageCounter = DIRECTPAGES; if(SM_NotifyTask_SKETCHBOARD_FREE != NULL_TASK) OS_piEventSend(SM_NotifyTask_SKETCHBOARD_FREE,OS_EVENT_SKETCHBOARD_FREE); /* Clear and unmask all the acquisition related interrupts */ ERC32_Clear_interrupt(ETIRQ); OS_piInterDisable(&intLevel); SD_piClearInt(SD_EVT_TO | SD_DATA_TO | SD_PAGE_OVR); SD_piUnMaskInt(SD_EVT_TO | SD_DATA_TO); OS_piInterEnable(intLevel); ERC32_Unmask_interrupt(ETIRQ); } break; /* Enter the DAQSetup mode */ case SM_DAQSETUP: { SD_piSetCalibrationHeaderLength(SM_PKTHEADER_LEN); SM_AcqMode = SM_DAQSETUP; /* Init the last recieved packet status to a */ /* "to be acquired" condition */ SM_PktStatus = SM_PKT_ACQ; /* Enable the skatchboard usage */ SM_SavingSkatchboard = FALSE; SM_ExpPageCounter = DAQSETUPPAGES; // console_outbyte_polled( 0, '9' ); // console_outbyte_polled( 0, '\n' ); if(SM_NotifyTask_SKETCHBOARD_FREE != NULL_TASK) OS_piEventSend(SM_NotifyTask_SKETCHBOARD_FREE,OS_EVENT_SKETCHBOARD_FREE); /* Clear and unmask all the acquisition related interrupts */ ERC32_Clear_interrupt(ETIRQ); OS_piInterDisable(&intLevel); SD_piClearInt(SD_EVT_TO | SD_DATA_TO | SD_PAGE_OVR); SD_piUnMaskInt(SD_EVT_TO | SD_DATA_TO); OS_piInterEnable(intLevel); ERC32_Unmask_interrupt(ETIRQ); } break; #if 0 /* Enter the Experiment mode */ case SM_EXPERIMENT: { SD_piSetCalibrationHeaderLength(SM_PKTHEADER_LEN); SM_AcqMode = SM_EXPERIMENT; /* Force the Caching automa to select a brand new SRAM page */ SM_TrashFlag = TRUE; SM_SelectedPage = 0; SM_EmptyPage = TRUE; SM_ExpPageCounter = EXPPAGES; /* Init the last recieved packet status to a */ /* "to be acquired" condition */ SM_PktStatus = SM_PKT_ACQ; /* Reset the SRAM to RAM triggrer counter */ /* Enable the skatchboard usage */ SM_SavingSkatchboard = FALSE; if(SM_NotifyTask_SKETCHBOARD_FREE != NULL_TASK) OS_piEventSend(SM_NotifyTask_SKETCHBOARD_FREE,OS_EVENT_SKETCHBOARD_FREE); /* Clear and unmask all the acquisition related interrupts */ OS_piInterDisable(&intLevel); SD_piClearInt(SD_EVT_TO | SD_DATA_TO | SD_PAGE_OVR); SD_piUnMaskInt(SD_EVT_TO | SD_DATA_TO); OS_piInterEnable(intLevel); ERC32_Clear_interrupt(ETIRQ); ERC32_Unmask_interrupt(ETIRQ); } break; #endif /* Enter the Experiment mode */ case SM_EXP64: { SD_piSetCalibrationHeaderLength(SM_PKTHEADER_LEN); SM_AcqMode = SM_EXP64; /* Force the Caching automa to select a brand new SRAM page */ SM_SelectedPage = 0; SM_EmptyPage = TRUE; SM_ExpPageCounter = EXP64PAGES; /* Init the last recieved packet status to a */ /* "to be acquired" condition */ SM_PktStatus = SM_PKT_ACQ; /* Reset the SRAM to RAM triggrer counter */ /* Enable the skatchboard usage */ SM_SavingSkatchboard = FALSE; if(SM_NotifyTask_SKETCHBOARD_FREE != NULL_TASK) OS_piEventSend(SM_NotifyTask_SKETCHBOARD_FREE,OS_EVENT_SKETCHBOARD_FREE); /* Clear and unmask all the acquisition related interrupts */ OS_piInterDisable(&intLevel); SD_piClearInt(SD_EVT_TO | SD_DATA_TO | SD_PAGE_OVR); SD_piUnMaskInt(SD_EVT_TO | SD_DATA_TO); OS_piInterEnable(intLevel); ERC32_Clear_interrupt(ETIRQ); ERC32_Unmask_interrupt(ETIRQ); } break; /* Enter the Idle mode */ case SM_IDLE: { SM_AcqMode = SM_IDLE; } break; default:{ status = SM_WRONGACQMODE; } } return (status); } /*****************************************************************************/ /* @Function: PM_op_GetAcqMode */ /* @Purpose : */ /* The function return the current acquisition mode */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_ACQMODE OUT acquisition mode */ /* @@ */ /*****************************************************************************/ SM_ACQMODE PM_op_GetAcqMode(void) { /* Return the current acquisition mode */ return (SM_AcqMode); } /*****************************************************************************/ /* @Function: PM_op_GetLostPktCounter */ /* @Purpose : */ /* The function return the lost Event Trigger counter */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ void PM_op_GetLostPktCounter(UINT32* Counter) { unsigned int intLevel; /* Return the lost packets counter */ OS_piInterDisable(&intLevel); *Counter = SM_LostTriggers; OS_piInterEnable(intLevel); } /*****************************************************************************/ /* @Function: PM_op_GetPacket */ /* @Purpose : */ /* The function return a packet from PIF SRAM Memory */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_PKTSTAT OUT acquisition result */ /* PtrPkt OUT Pointer to the caller packet buffer */ /* Size OUT Size of the packet copied into buffer */ /* @@ */ /*****************************************************************************/ SM_PKTSTAT PM_op_GetPacket(UINT32* Size, void* PtrPkt) { SM_PKTSTAT pktStat; unsigned int intLevel; FS_FILE_DESCR fd; if (PM_opLockHBUS() == SM_SUCCESS) { /* Lock the buffer in read mode */ OS_piInterDisable(&intLevel); SM_PktLock = TRUE; OS_piInterEnable(intLevel); /* return the packet status */ pktStat = SM_PktStatus; FS_piGetFileInfo(FS_ERC32, &fd); /* If the paket is good then copy it to the provided destination */ if(SM_PktStatus == SM_PKT_GOOD) { memcpy(PtrPkt, (void*)fd.WriteAddr, SM_PktSize); *Size = SM_PktSize; } /* Unlock the buffer */ OS_piInterDisable(&intLevel); SM_PktLock = FALSE; OS_piInterEnable(intLevel); PM_opReleaseHBUS(); } else pktStat = SM_PKT_ACQ; return (pktStat); } /*****************************************************************************/ /* @Function: PM_op_StorePacket */ /* @Purpose : */ /* The function starts all the operations needed to store the given packet */ /* in the selected file. If the result is good it means that the store */ /* request was successfuly accepted. The store of the packet can still fail */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_STRSTAT OUT Store request result */ /* PtrPkt IN Pointer to the caller packet buffer */ /* Size IN Size of the packet to be copied into FileId */ /* in bytes */ /* FileID IN Destination file */ /* @@ */ /*****************************************************************************/ SM_STRSTAT PM_op_StorePacket(UINT32 Size, void* PtrPkt, FS_FILEID FileId) { SM_STRSTAT strStat = SM_STR_OK; SD_DAQ_WRESULT pageInfo; /* Check the FileID */ if(FileId == FS_REGFILES || FileId == FS_MAXID) { strStat = SM_STR_WRONGFILE; } /* Check the packet size */ if(Size == 0 || Size > SM_SKETCHSIZE) { strStat = SM_STR_WRIONGSIZE; } /* Check if the skatchboard is in use */ if(SM_SavingSkatchboard == TRUE) { strStat = SM_STR_BUSY; } if (strStat == SM_STR_OK) { /* Copy the provided packet into SRAM skatchboard */ if(PtrPkt != NULL) SM_ifCopyToSRAM((UINT32)(SM_SKETCHBOARD * SM_SRAMPAGESIZE), (void*)PtrPkt, Size); /* Put a save request for the skatchboard SRAM page in the save queue*/ pageInfo = (UINT32)(SM_SKETCHBOARD * SM_SRAMPAGESIZE) + Size - 1; /* The save request was accepted */ /* so lock the skatchboard page: assume here that it will have success */ SM_SavingSkatchboard = TRUE; if(FT_piSavePage(SM_SKETCHBOARD, pageInfo, FileId) != FT_SUCCESS) { /* The save request was refused */ strStat = SM_STR_FAILED; SM_SavingSkatchboard = FALSE; if(SM_NotifyTask_SKETCHBOARD_FREE != NULL_TASK) OS_piEventSend(SM_NotifyTask_SKETCHBOARD_FREE,OS_EVENT_SKETCHBOARD_FREE); } } return (strStat); } /*****************************************************************************/ /* @Function: PM_op_SetExpPktCpyFlag */ /* @Purpose : */ /* This function sets the experiment pkt RAM copy flag */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* Flag IN Flag */ /* @@ */ /*****************************************************************************/ void PM_op_SetExpPktCpyFlag(BOOL Flag) { /* Set the trigger counter for the experiment pkt RAM copy */ SM_PktRamCpyFlag = Flag; } /*****************************************************************************/ /* @Function: PM_op_GetAndIncrPckCnt */ /* @Purpose : */ /* This function get and increase the packet counter */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* UINT32 OUT return the packet counter */ /* @@ */ /*****************************************************************************/ UINT32 PM_op_GetAndIncrPckCnt (void) { return (SM_PacketCounter++); } /*****************************************************************************/ /* @Function: PM_op_CopyToSRAM */ /* @Purpose : */ /* This function copy from RAMStartAddr "Size" bytes to Page selected in */ /* in SRAM Memory. */ /* this function update the value of SM_CalDataLenght for the page selected */ /* with the "size" */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_STRSTAT OUT Store request result */ /* Page IN Page to store data buffer */ /* RAMStartAddr IN Pointer to the caller data buffer */ /* Size IN Size of the packet to be copied into FileId */ /* in bytes */ /* @@ */ /*****************************************************************************/ SM_STRSTAT PM_op_CopyToSRAM (SM_PAGEID Page, void* RAMStartAddr, UINT32 Size) { SM_STRSTAT strStat = SM_STR_OK; unsigned int intLevel; /* Check the packet size */ if(Size == 0 || Size > SM_SKETCHSIZE) { strStat = SM_STR_WRIONGSIZE; } /* check that page selected is valid page */ if ((Page < SM_CALEXP0) || (Page > SM_CALEXP3)) { strStat = SM_STR_WRONGFILE; } if (strStat == SM_STR_OK) { if (PM_opLockHBUS() == SM_SUCCESS) { /* Copy the provided data into SRAM Page Selected */ SM_ifCopyToSRAM((UINT32)(Page * SM_SRAMPAGESIZE), RAMStartAddr, Size); SM_CalDataLenght[Page] = Size; PM_opReleaseHBUS(); } else strStat = SM_STR_BUSY; } return strStat; } /*****************************************************************************/ /* @Function: PM_op_UseCalibrationPage */ /* @Purpose : */ /* This function select the page that must be used for next acquisition */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* Page IN Page to store data buffer */ /* @@ */ /*****************************************************************************/ void PM_op_UseCalibrationPage (SM_PAGEID Page) { SM_CalPageSelected = Page; } /*****************************************************************************/ /* @Function: PM_opLockHBUS */ /* @Purpose : */ /* This function lock the HW HBUS shared resource */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* SM_EXITCODE OUT Lock HBUS request result */ /* @@ */ /*****************************************************************************/ SM_EXITCODE PM_opLockHBUS() { SM_EXITCODE status = SM_SUCCESS; unsigned int intLevel; OS_piInterDisable(&intLevel); if (SM_HBUSIsLocked) status = SM_FAIL; else SM_HBUSIsLocked = TRUE; OS_piInterEnable(intLevel); return status; } /*****************************************************************************/ /* @Function: PM_opReleaseHBUS */ /* @Purpose : */ /* This function release the HW HBUS shared resource */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ void PM_opReleaseHBUS() { unsigned int intLevel; OS_piInterDisable(&intLevel); SM_HBUSIsLocked = FALSE; OS_piInterEnable(intLevel); } /*****************************************************************************/ /* @Function: PM_opGetDataLen */ /* @Purpose : */ /* Returns the length of a page */ /* */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ UINT32 SM_opGetDataLength(SM_PAGEID page) { return SM_CalDataLenght[page]; } /*****************************************************************************/ /* @Function: PM_opFullExp */ /* @Purpose : */ /* Returns wheather or not the is at least one page available on the PIF */ /* (exp page) */ /* @@ */ /* @Parameter Name @Mode @Description */ /* @@ */ /*****************************************************************************/ BOOL SM_opExpPageAvail() { BOOL ret = FALSE; unsigned int intLevel; OS_piInterDisable(&intLevel); switch(SM_AcqMode) { case SM_DIRECT: case SM_DAQSETUP: // ret = !SM_PacketStoreIsOngoing; ret = SM_ExpPageCounter > 0; break; case SM_EXP64: // case SM_EXPERIMENT: ret = SM_ExpPageCounter > 0; break; } OS_piInterEnable(intLevel); return ret; } BOOL SM_opAllExpPageAvail() { BOOL ret = FALSE; unsigned int intLevel; OS_piInterDisable(&intLevel); switch(SM_AcqMode) { case SM_DIRECT: case SM_DAQSETUP: ret = SM_ExpPageCounter == DAQSETUPPAGES; break; case SM_EXP64: ret = SM_ExpPageCounter == EXP64PAGES; break; } OS_piInterEnable(intLevel); return ret; }