typedef  unsigned  int         SLB_INT16U;                       
typedef  unsigned  long        SLB_INT32U;                       
typedef  enum {                                                  
    SLB_FALSE = 0,
    SLB_TRUE
} SLB_BOOL;





typedef  enum  err
{
    ERR_NONE = 0,                                       



} ACQ_ERR;



































typedef enum
{
MEASURE = 0,                                                
SIMULATE,                                                   
INVALID_ACQ_MODE
} eACQ_MODE;


typedef enum
{
    TESTMODE = 0                                                    

} eTOOL_MODE;

typedef enum
{
    COMM = 0,                                                   
    DEV                                                        
} eRAWDATA_MODE;









































typedef struct
{

SLB_BOOL            test;                        


} BLA_INTERNAL_INFO;


















typedef struct msg1
{
    SLB_INT16U dddddd[213];
    SLB_INT16U fffffff[213];
    SLB_INT16U nnnnnnn[213];
} MSG1;

typedef struct msg2
{
    SLB_INT16U dddddd[213];
    SLB_INT16U fffffff[213];
    SLB_INT16U nnnnnnn[213];
} MSG3;


typedef struct msg3
{
    SLB_INT16U dddddd[263];
    SLB_INT16U fffffff[263];
    SLB_INT16U nnnnnnn[263];
} MSG2;


extern void BLA_ReadMEM(eACQ_MODE acqMode, SLB_INT32U addr, SLB_INT16U *rdWrBuf);

extern void BLA_fillFinalData(eACQ_MODE AcqMode, SLB_INT16U StartAddressInMEM, SLB_INT16U LenghtMEMPortion,
     SLB_INT16U FinalBinNumber, SLB_INT16U* FinalDataLocation, SLB_BOOL *pOverflow);
extern void BLA_FillTestPositionInfo(SLB_INT16U sense, SLB_INT16U zone, BLA_INTERNAL_INFO *pPHAInfo);
extern void BLA_fillFinalData(eACQ_MODE AcqMode, SLB_INT16U StartAddressInMEM, SLB_INT16U LenghtMEMPortion,
     SLB_INT16U FinalBinNumber, SLB_INT16U* FinalDataLocation, SLB_BOOL *pOverflow);
extern void BLA_RetrieveTestPositionInfo(SLB_INT16U sense, BLA_INTERNAL_INFO *pPHAInfo, ACQ_ERR *pErr);


void MODE_getTimingData(void *pBuf, BLA_INTERNAL_INFO *pPHAInfo, eRAWDATA_MODE RawDataMode,
        eACQ_MODE AcqMode, SLB_INT16U *pCountOverflowStatus, ACQ_ERR *pMsgErr)
{
    SLB_INT16U group;
    SLB_INT16U sense;
    SLB_INT16U zone;
    SLB_INT16U sram_index_in_group;
    SLB_INT16U subzones_treated;
    SLB_INT16U final_data_index;
    SLB_BOOL   hasOverflowOccurred;
    SLB_INT16U* data_destination[3];

    const SLB_INT16U TS_Raw_Bins_Per_Subzones[8] = {50, 384, 11,             64, 25, 50, 100, 5};

    SLB_INT16U TS_Final_Bins_Per_Subzones[8] = {50, 12, 11,             2, 25, 50, 0, 5};    

    const SLB_INT16U TS_Subzones_Per_Group[4] = {1,3,3,1};
    const SLB_INT16U TS_Apparent_MEM_Addresses[3]  = {0x0C00, 0x3E00, 0x7000};;
    const SLB_INT16U TS_Sum_MEM_Addresses[3]       = {(0x0C00 + (0x0200 * 2)), (0x3E00 + (0x0200 * 2)), (0x7000 + (0x0200 * 2))};;
    const SLB_INT16U TS_MEM_Offset[4] = {0, 50,             ( 50 + (384 + 11 + 64) ), ( ( 50 + (384 + 11 + 64) ) + (25 + 50 + 100) )};

    *pMsgErr = ERR_NONE;

    if (RawDataMode == COMM)
    {
        MSG1* pGSHMsg = (MSG1*) pBuf;
        data_destination[0] = pGSHMsg->nnnnnnn;
        data_destination[1] = pGSHMsg->fffffff;
        data_destination[2] = pGSHMsg->dddddd;

        TS_Final_Bins_Per_Subzones[8-2] = 50;
    }
    else if (RawDataMode == DEV)
    {
        MSG2* pGSHMsg = (MSG2*) pBuf;
        data_destination[0] = pGSHMsg->nnnnnnn;
        data_destination[1] = pGSHMsg->fffffff;
        data_destination[2] = pGSHMsg->dddddd;

        TS_Final_Bins_Per_Subzones[8-2] = 100;
    }
    else 
    {
        MSG3* pGSHMsg = (MSG3*) pBuf;
        data_destination[0] = pGSHMsg->nnnnnnn;
        data_destination[1] = pGSHMsg->fffffff;
        data_destination[2] = pGSHMsg->dddddd;

        TS_Final_Bins_Per_Subzones[8-2] = 50;
    }
                                                                
    for (sense = 0 ; sense < 3; sense++)
    {
        SLB_INT16U *destination = data_destination[sense];

        subzones_treated = 0;                                   
        final_data_index = 0;
                                                                
        for (group = 0 ; group < 4; group++)
        {
            sram_index_in_group = 0;                            

            for (zone = 0; zone < TS_Subzones_Per_Group[group]; zone++)
            {
                                                                
                BLA_fillFinalData(AcqMode, TS_Apparent_MEM_Addresses[sense] + TS_MEM_Offset[group] + sram_index_in_group,
                    TS_Raw_Bins_Per_Subzones[subzones_treated], TS_Final_Bins_Per_Subzones[subzones_treated],
                    &destination[final_data_index], &hasOverflowOccurred);

                if (hasOverflowOccurred == SLB_TRUE)
                {
                    (*pCountOverflowStatus) |= ( 1 << ( 3 - (sense) - 1 ) );
                }
                                                                
                if ( group == 1 )
                {
                    BLA_FillTestPositionInfo(sense, zone, pPHAInfo);
                }
                                                                
                sram_index_in_group += TS_Raw_Bins_Per_Subzones[subzones_treated];
                final_data_index += TS_Final_Bins_Per_Subzones[subzones_treated];
                subzones_treated++;
            }
        }
                                                                
        BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[0] + 5 - 1, &destination[final_data_index++] );      
        BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[0] + 30 - 1, &destination[final_data_index++] );      

        BLA_fillFinalData(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[1] + 161 - 1,
            32, 1, &destination[final_data_index++],  &hasOverflowOccurred);                                                         
        if (hasOverflowOccurred == SLB_TRUE)
        {
            (*pCountOverflowStatus) |= ( 1 << ( 3 - (sense) - 1 ) );
        }

        BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[1] + 390 - 1, &destination[final_data_index++] );    

        BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[2] + 6 - 1, &destination[final_data_index++] );      
        BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[2] + 26 - 1, &destination[final_data_index++] );      
        if (RawDataMode == DEV)
        {
            BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[2] + 125 - 1, &destination[final_data_index++] );  
        }
        else 
        {
            BLA_fillFinalData(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[2] + 124 - 1,
                    2, 1, &destination[final_data_index++],  &hasOverflowOccurred);                                              
            if (hasOverflowOccurred == SLB_TRUE)
            {
                (*pCountOverflowStatus) |= ( 1 << ( 3 - (sense) - 1 ) );
            }
        }

        BLA_ReadMEM(AcqMode, TS_Sum_MEM_Addresses[sense] + TS_MEM_Offset[3] + 3 - 1, &destination[final_data_index++] );    

                                                                
        BLA_RetrieveTestPositionInfo(sense, pPHAInfo, pMsgErr);


    } 
}