Lemz_SwCtrlStmProj/App/nfm/nfm_base_mem.c

//#include "options.h"
//#define FLASHCHIP_C
//#include "drivers/flash/flashchip.h"
#include "core/config.h"
#include "crc32.h"
#include "app/nfm/nfm_base_excls.h"
#include "string.h"  
#include "drivers/flash/base/extmem_flash.h"
//------------------------------------------------------------------------------
#pragma location=".cache"
static uint8_t g_RomBuffer [ CONFIG_FLASHMEM_CACHE_SIZE ];
        
typedef enum
{
  RomBufCache_undefined,
  RomBufCache_CommonHeader,
  RomBufCache_FactoryChrzHeader,
  RomBufCache_TCompHeader,
  RomBufCache_User1ChrzHeader,
  RomBufCache_User2ChrzHeader,
  RomBufCache_User3ChrzHeader,  
} 
eRomBufCache_t;

static eRomBufCache_t g_RomBuffer_Cache = RomBufCache_undefined;
//------------------------------------------------------------------------------
//const sNFMMemory_ChrzTableMatrix_2Port_t tableMatrix_SC2543_2xPort_NFM_2543_v1 =
//{
//    DECLARE_CHRZTABLETYPE_2PORT(14),
//    
//    .Single = 
//    {
//       /* Port A */
//       .aArray[ ePortComb_A - ePortComb_MIN_SINGLE_2Port ] =           
//       {
//          .aBaseIndex[ ePortStateId_Short - ePortStateId_MIN_SINGLE_2Port ] = 1,  // Short
//          .aBaseIndex[ ePortStateId_Open  - ePortStateId_MIN_SINGLE_2Port ] = 3,  // Open
//          .aBaseIndex[ ePortStateId_Load  - ePortStateId_MIN_SINGLE_2Port ] = 5,  // Load
//          .aBaseIndex[ ePortStateId_Load2 - ePortStateId_MIN_SINGLE_2Port ] =15,  // Load2
//          .aBaseIndex[ ePortStateId_Open2 - ePortStateId_MIN_SINGLE_2Port ] =17,  // Open2
//       },  
//       
//       /* Port B */
//       .aArray[ ePortComb_B - ePortComb_MIN_SINGLE_2Port ] =  
//       {                        
//          .aBaseIndex[ ePortStateId_Short - ePortStateId_MIN_SINGLE_2Port ] = 2,  // Short
//          .aBaseIndex[ ePortStateId_Open  - ePortStateId_MIN_SINGLE_2Port ] = 4,  // Open
//          .aBaseIndex[ ePortStateId_Load  - ePortStateId_MIN_SINGLE_2Port ] = 6,  // Load
//          .aBaseIndex[ ePortStateId_Load2 - ePortStateId_MIN_SINGLE_2Port ] =16,  // Load2
//          .aBaseIndex[ ePortStateId_Open2 - ePortStateId_MIN_SINGLE_2Port ] =18,  // Open2
//       },          
//    },
//    
//    .Thru = 
//    {
//       /* Thru A-B */
//       .aArrays[ ePortComb_AB - ePortComb_MIN_THRU_2Port ] =                      // Thru AB
//       {                                                                    
//          .aBaseIndex[ ePortStateId_S11 - ePortStateId_MIN_THRU_2Port ] = 7,      // S11
//          .aBaseIndex[ ePortStateId_S21 - ePortStateId_MIN_THRU_2Port ] = 8,      // S21
//          .aBaseIndex[ ePortStateId_S12 - ePortStateId_MIN_THRU_2Port ] = 9,      // S12
//          .aBaseIndex[ ePortStateId_S22 - ePortStateId_MIN_THRU_2Port ] = 10,     // S22
//       },
//    },
//    
//    .Check = 
//    {
//       .sArray =                                                            // Check State
//       {
//          .aBaseIndex[ ePortStateId_S11 - ePortStateId_MIN_CHECK_2Port ] = 11,    // S11
//          .aBaseIndex[ ePortStateId_S21 - ePortStateId_MIN_CHECK_2Port ] = 12,    // S21
//          .aBaseIndex[ ePortStateId_S12 - ePortStateId_MIN_CHECK_2Port ] = 13,    // S12
//          .aBaseIndex[ ePortStateId_S22 - ePortStateId_MIN_CHECK_2Port ] = 14,    // S22
//       }
//    },
//};
//
//const sNFMMemory_ChrzTableMatrix_2Port_t tableMatrix_SC2543_2xPort_NFM_2543_v2 =
//{
//    DECLARE_CHRZTABLETYPE_2PORT(14),
//    
//    .Single = 
//    {
//       /* Port A */
//       .aArray[ ePortComb_A - ePortComb_MIN_SINGLE_2Port ] =           
//       {
//          .aBaseIndex[ ePortStateId_Short - ePortStateId_MIN_SINGLE_2Port ] = 1,  // Short
//          .aBaseIndex[ ePortStateId_Open  - ePortStateId_MIN_SINGLE_2Port ] = 3,  // Open
//          .aBaseIndex[ ePortStateId_Load  - ePortStateId_MIN_SINGLE_2Port ] = 5,  // Load
//          .aBaseIndex[ ePortStateId_Load2 - ePortStateId_MIN_SINGLE_2Port ] =15,  // Load2
//          .aBaseIndex[ ePortStateId_Open2 - ePortStateId_MIN_SINGLE_2Port ] =17,  // Open2
//       },  
//       
//       /* Port B */
//       .aArray[ ePortComb_B - ePortComb_MIN_SINGLE_2Port ] =  
//       {                        
//          .aBaseIndex[ ePortStateId_Short - ePortStateId_MIN_SINGLE_2Port ] = 2,  // Short
//          .aBaseIndex[ ePortStateId_Open  - ePortStateId_MIN_SINGLE_2Port ] = 4,  // Open
//          .aBaseIndex[ ePortStateId_Load  - ePortStateId_MIN_SINGLE_2Port ] = 6,  // Load
//          .aBaseIndex[ ePortStateId_Load2 - ePortStateId_MIN_SINGLE_2Port ] =16,  // Load2
//          .aBaseIndex[ ePortStateId_Open2 - ePortStateId_MIN_SINGLE_2Port ] =18,  // Open2
//       },          
//    },
//    
//    .Thru = 
//    {
//       /* Thru A-B */
//       .aArrays[ ePortComb_AB - ePortComb_MIN_THRU_2Port ] =                      // Thru AB
//       {                                                                    
//          .aBaseIndex[ ePortStateId_S11 - ePortStateId_MIN_THRU_2Port ] = 7,      // S11
//          .aBaseIndex[ ePortStateId_S21 - ePortStateId_MIN_THRU_2Port ] = 8,      // S21
//          .aBaseIndex[ ePortStateId_S12 - ePortStateId_MIN_THRU_2Port ] = 9,      // S12
//          .aBaseIndex[ ePortStateId_S22 - ePortStateId_MIN_THRU_2Port ] = 10,     // S22
//       },
//    },
//    
//    .Check = 
//    {
//       .sArray =                                                            // Check State
//       {
//          .aBaseIndex[ ePortStateId_S11 - ePortStateId_MIN_CHECK_2Port ] = 11,    // S11
//          .aBaseIndex[ ePortStateId_S21 - ePortStateId_MIN_CHECK_2Port ] = 12,    // S21
//          .aBaseIndex[ ePortStateId_S12 - ePortStateId_MIN_CHECK_2Port ] = 13,    // S12
//          .aBaseIndex[ ePortStateId_S22 - ePortStateId_MIN_CHECK_2Port ] = 14,    // S22
//       }
//    },
//};

#define NFMBASE_FLASH_MAKEADDRESS_USERBANK0( addr )      ( 0x00000000 | (addr) )  // (addr + AT45FLASH_MINIMUM_ADDRESS)
#define NFMBASE_FLASH_MAKEADDRESS_USERBANK1( addr )      ( 0x80000000 | (addr) )  // (addr - FLASH_USERBANK_0_SIZE)
#define NFMBASE_FLASH_USERBANK0_CHECK( addr )            (!(0x80000000 & (addr) ))
#define NFMBASE_FLASH_USERBANK1_CHECK( addr )            (( 0x80000000 & (addr) ))

#define NFMBASE_FLASH_MIN_ADDRESS                        ( ExtMemHandle.pFlashProperties->minAddress )
#define NFMBASE_FLASH_MAX_ADDRESS                        ( ExtMemHandle.pFlashProperties->maxAddress )
#define NFMBASE_FLASH_BANK0_SIZE                         ( ExtMemHandle.pBanksProperties->factoryBankSize )
#define NFMBASE_FLASH_BANK1_SIZE                         ( ExtMemHandle.pBanksProperties->userBankSize )
#define NFMBASE_FLASH_BANK0_ADDRESS                      ( NFMBASE_FLASH_MIN_ADDRESS )
#define NFMBASE_FLASH_BANK1_ADDRESS                      ( NFMBASE_FLASH_BANK0_ADDRESS + NFMBASE_FLASH_BANK0_SIZE )

#define NFMBASE_FLASH_USERBANK0_MAKEREALADDRESS( addr )  (( (addr) & 0x7FFFFFFF ) + NFMBASE_FLASH_BANK0_ADDRESS )
#define NFMBASE_FLASH_USERBANK1_MAKEREALADDRESS( addr )  (( (addr) & 0x7FFFFFFF ) + NFMBASE_FLASH_BANK1_ADDRESS )
#define NFMBASE_FLASH_MAKEREALADDRESS( addr )            (\
                                                          (NFMBASE_FLASH_USERBANK0_CHECK(addr))\
                                                          ?(\
                                                          NFMBASE_FLASH_USERBANK0_MAKEREALADDRESS(addr)\
                                                          ):(\
                                                            (NFMBASE_FLASH_USERBANK1_CHECK(addr))\
                                                            ?(\
                                                            NFMBASE_FLASH_USERBANK1_MAKEREALADDRESS(addr)\
                                                            ):(\
                                                            0\
                                                            )\
                                                          ))


//const sNFMMemoryProfile_t memProfile_SC2543v1_ADRF_NFM2543_v1 =
//{
//    .BaseAddr_TComp              = NFMBASE_FLASH_MAKEADDRESS_USERBANK0(MEMORY_OFFSET_BLOCK_THERMHEADER_SC2543),
//    .BaseAddr_Chrz[ eChFactory ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK0(MEMORY_OFFSET_BLOCK_DATAHEADER_SC2543),
//    .BaseAddr_Chrz[ eChUser1   ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER1DATA_SC2543),
//    .BaseAddr_Chrz[ eChUser2   ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER2DATA_SC2543),
//    .BaseAddr_Chrz[ eChUser3   ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER3DATA_SC2543),
//    .BaseAddr_Settings = SETTINGS_ADDR_SC2543,
//    .Size_Settings = SETTINGS_SIZE_SC2543,
//    .tbls_2Port = &tableMatrix_SC2543_2xPort_NFM_2543_v1
//};
    
//const sNFMMemoryProfile_t memProfile_NFM =
//{
//    .BaseAddr_TComp              = NFMBASE_FLASH_MAKEADDRESS_USERBANK0(MEMORY_OFFSET_BLOCK_THERMHEADER_SC2543),
//    .BaseAddr_Chrz[ eChFactory ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK0(MEMORY_OFFSET_BLOCK_DATAHEADER_SC2543),
//    .BaseAddr_Chrz[ eChUser1   ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER1DATA_SC2543),
//    .BaseAddr_Chrz[ eChUser2   ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER2DATA_SC2543),
//    .BaseAddr_Chrz[ eChUser3   ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER3DATA_SC2543),
//    .BaseAddr_Settings = SETTINGS_ADDR_SC2543,
//    .Size_Settings = SETTINGS_SIZE_SC2543,
//    .tbls_2Port = &tableMatrix_SC2543_2xPort_NFM_2543_v2
//};   

const sSwitchMemoryProfile_t memProfile_SW = 
{
    .BaseAddr_SwTable  = NFMBASE_FLASH_MAKEADDRESS_USERBANK0(MEMORY_OFFSET_BLOCK_THERMHEADER_SC2543),
    .BaseAddr_Table[ eChValues ] = NFMBASE_FLASH_MAKEADDRESS_USERBANK1(MEMORY_OFFSET_BLOCK_USER1DATA_SC2543),
    .BaseAddr_Settings = SETTINGS_ADDR_SC2543,
    .Size_Settings = SETTINGS_SIZE_SC2543,
};
        
//------------------------------------------------------------------------------
// Set Flash Memory Bank0 Write-Protection
bool NFM_ROM_SetMemoryProtectStatus_Bank0( bool desiredStatus )
{
    return ExtMemHandle.BankProtect( extmem_bank_factory, desiredStatus );    
}
//------------------------------------------------------------------------------
// Get Flash Memory Bank0 Write-Protection status
bool NFM_ROM_GetMemoryProtectStatus_Bank0()
{
    bool status = false;

    if( ExtMemHandle.CheckBankProtect( extmem_bank_factory, &status ) )
    {
        return status;  // report with the actual protection status
    }

    return false; // error, but report that bank is unprotected
}
//------------------------------------------------------------------------------
static sEcalHeaderCRC_t * romGetCommonHeader( uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sEcalHeaderCRC_t) ) 
    return NULL;

  /*
  size_t baseAddr = FLASH_USERBANK_0_ADDR;

         baseAddr += MEMORY_OFFSET_BLOCK_COMMON;
  */ 
  
  size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMBASE_FLASH_MAKEADDRESS_USERBANK0( MEMORY_OFFSET_BLOCK_COMMON ) );
  
  if( FLASH_SUCCESS( flash_read( baseAddr, buffer, sizeof(sEcalHeaderCRC_t) ) ) )
  {
      return (sEcalHeaderCRC_t*)buffer;
  }

  return NULL;
}

// ------------------------------------------------------------------------------
const sEcalHeader_t * NFM_ROM_GetCommonHeader( uint8_t * buffer, size_t size )
{
  sEcalHeaderCRC_t * hdrcrc;
  TCRC crc;
  bool cacheUsed = false;
  
  if( NULL == buffer ) 
  { 
      cacheUsed = true;
      
      if( RomBufCache_CommonHeader == g_RomBuffer_Cache )
      {
          hdrcrc = (sEcalHeaderCRC_t*)g_RomBuffer;
          goto L_NFM_ROM_GetCommonHeader_AlreadyCached;
      }
      
      buffer = (uint8_t*)g_RomBuffer; 
      size = sizeof(g_RomBuffer);
  }

  if( NULL == buffer || size < sizeof(sEcalHeaderCRC_t) ) 
  {      
      return NULL;
  }
  
  if( cacheUsed )
  {  
      g_RomBuffer_Cache = RomBufCache_undefined;
  }
  
  hdrcrc = romGetCommonHeader( buffer, size );

  if( NULL == hdrcrc )
  {      
      return NULL;
  }  

  crc = ICRC32;

  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sEcalHeader_t) ); 

  if( crc != hdrcrc->CRCValue )
  {      
      return NULL;
  }   
  
  if( cacheUsed )
  {
      g_RomBuffer_Cache = RomBufCache_CommonHeader;
  }    
   
L_NFM_ROM_GetCommonHeader_AlreadyCached:
  
  return (sEcalHeader_t *)hdrcrc;
}

//const sTableHeader_t * SW_ROM_GetCommonHeader( uint8_t * buffer, size_t size )
//{
//  sTableHeaderCRC_t * hdrcrc;
//  TCRC crc;
//  bool cacheUsed = false;
//  
//  if( NULL == buffer ) 
//  { 
//      cacheUsed = true;
//      
//      if( RomBufCache_CommonHeader == g_RomBuffer_Cache )
//      {
//          hdrcrc = (sTableHeaderCRC_t*)g_RomBuffer;
//          goto L_SW_ROM_GetCommonHeader_AlreadyCached;
//      }
//      
//      buffer = (uint8_t*)g_RomBuffer; 
//      size = sizeof(g_RomBuffer);
//  }
//
//  if( NULL == buffer || size < sizeof(sTableHeaderCRC_t) ) 
//  {      
//      return NULL;
//  }
//  
//  if( cacheUsed )
//  {  
//      g_RomBuffer_Cache = RomBufCache_undefined;
//  }
//  
//  hdrcrc = romSwGetCommonHeader( buffer, size );
//
//  if( NULL == hdrcrc )
//  {      
//      return NULL;
//  }  
//
//  crc = ICRC32;
//
//  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sTableHeader_t) ); 
//
//  if( crc != hdrcrc->CRCValue )
//  {      
//      return NULL;
//  }   
//  
//  if( cacheUsed )
//  {
//      g_RomBuffer_Cache = RomBufCache_CommonHeader;
//  }    
//   
//L_SW_ROM_GetCommonHeader_AlreadyCached:
//  
//  return (sTableHeader_t *)hdrcrc;
//}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
static sEcalDataHeaderCRC_t * romGetDataHeader( size_t baseAddr, uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sEcalDataHeaderCRC_t) ) 
    return NULL;
  
  if( FLASH_SUCCESS( flash_read( baseAddr, buffer, sizeof(sEcalDataHeaderCRC_t) ) ) )
  {  
      return (sEcalDataHeaderCRC_t*)buffer;
  } 
      
  return NULL;    
}

static sTableTablePoint_t * romGetDataPoint( size_t baseAddr, uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sTableTablePoint_t) ) 
    return NULL;
  
  if( FLASH_SUCCESS( flash_read( baseAddr, buffer, sizeof(sTableTablePoint_t) ) ) )
  {  
      return (sTableTablePoint_t*)buffer;
  } 
      
  return NULL;    
}

static bool romSetDataPoint( size_t baseAddr, uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sTableTablePoint_t) ) 
    return NULL;
  
  NFMClass->methods.xMemoryProtection.disable();
  if( FLASH_SUCCESS( flash_write( baseAddr, buffer, sizeof(sTableTablePoint_t), fwm_safewrite ) ) )
  {
      NFMClass->methods.xMemoryProtection.enable();
      return true;
  }
  NFMClass->methods.xMemoryProtection.enable();
  
  return NULL;    
}
// ------------------------------------------------------------------------------
const sEcalDataHeader_t * NFM_ROM_GetDataHeader( eChrz_t tableId, uint8_t * buffer, size_t size )
{
  extern NFMClassEx_t * NFMClassExtended;
  
  sEcalDataHeaderCRC_t * hdrcrc;
  hdrcrc = (sEcalDataHeaderCRC_t*)g_RomBuffer;
  //TCRC crc;
  //bool cacheUsed = false;
  //size_t baseAddr = 0;
  
//  eRomBufCache_t cacheId = RomBufCache_undefined;
//  
//  switch( tableId )
//  {  
//      case eChFactory : cacheId = RomBufCache_FactoryChrzHeader; break;
//      case eChUser1   : cacheId = RomBufCache_User1ChrzHeader  ; break;
//      case eChUser2   : cacheId = RomBufCache_User2ChrzHeader  ; break;
//      case eChUser3   : cacheId = RomBufCache_User3ChrzHeader  ; break;
//  }
//  
//  if( NULL == buffer ) 
//  { 
//      cacheUsed = true;
//      
//      if( cacheId == g_RomBuffer_Cache && RomBufCache_undefined != g_RomBuffer_Cache )
//      {
//          hdrcrc = (sEcalDataHeaderCRC_t*)g_RomBuffer;
//          goto L_NFM_ROM_GetDataHeader_AlreadyCached;
//      }
//      
//      buffer = (uint8_t*)g_RomBuffer; 
//      size = sizeof(g_RomBuffer); 
//  }
//  
//  if( NULL == NFMClassExtended->private.properties.memProfile )
//  {  
//      return NULL;
//  }
//  
//  baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
//               private.properties.memProfile->
//                  BaseAddr_Chrz[ (tableId%eCh_MAX) ] ); 
//
//  if( NULL == buffer || size < sizeof(sEcalDataHeaderCRC_t) ) 
//  {
//      return NULL;
//  }  
//
//  if( cacheUsed )
//  {  
//      g_RomBuffer_Cache = RomBufCache_undefined;
//  }  
//
//  hdrcrc = romGetDataHeader( baseAddr, buffer, size );
//
//  if( NULL == hdrcrc )
//  {
//      return NULL;
//  }    
//
//  crc = ICRC32;
//
//  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sEcalDataHeader_t) ); 
//
//  if( crc != hdrcrc->CRCValue )
//  {
//      return NULL;
//  }   
//  
//  if( cacheUsed )
//  {
//      g_RomBuffer_Cache = cacheId;
//  }
//  
//L_NFM_ROM_GetDataHeader_AlreadyCached:
//  
  return (sEcalDataHeader_t *)hdrcrc;
}
// ------------------------------------------------------------------------------
// -Table Header functions ------------------------------------------------------
// ------------------------------------------------------------------------------
static sTableHeaderCRC_t * romSetTableHeader( uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sTableHeaderCRC_t) )
      return NULL;
    
  size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMBASE_FLASH_MAKEADDRESS_USERBANK0( MEMORY_OFFSET_BLOCK_THERMHEADER_SC2543 ) );
  
  NFMClass->methods.xMemoryProtection.disable();
  if( FLASH_SUCCESS( flash_write( baseAddr, buffer, sizeof(sTableHeaderCRC_t), fwm_safewrite ) ) )
  {
      NFMClass->methods.xMemoryProtection.enable();
      return (sTableHeaderCRC_t*)buffer;
  }
  NFMClass->methods.xMemoryProtection.enable();

  return NULL;
}

static sTableHeaderCRC_t * romGetTableHeader( uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sTableHeaderCRC_t) )
    return NULL;
    
  size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMBASE_FLASH_MAKEADDRESS_USERBANK0( MEMORY_OFFSET_BLOCK_THERMHEADER_SC2543 ) );
    
  if( FLASH_SUCCESS( flash_read( baseAddr, buffer, sizeof(sTableHeaderCRC_t) ) ) )
  {
      return (sTableHeaderCRC_t*)buffer;
  }

  return NULL;
}

static bool SW_Validate_Table_Header_CRC ( sTableHeaderCRC_t * hdrcrc )
{
    TCRC crc;
    crc = ICRC32;
    crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sTableHeader_t) );
    return hdrcrc->CRCValue == crc ;
}

sTableHeaderCRC_t * SW_ROM_GetTableHeader()
{
  uint8_t * buffer = (uint8_t*)g_RomBuffer; 
  size_t size = sizeof(g_RomBuffer);
  if( NULL == buffer || size < sizeof(sTableHeaderCRC_t) ) 
  {      
      return false;
  }
  
  g_RomBuffer_Cache = RomBufCache_undefined;
  
  return romGetTableHeader( buffer, size );
}

bool SW_ROM_ChangeTableHeader( sTableHeaderCRC_t * hdrcrc )
{
  extern NFMClassEx_t * NFMClassExtended;
  if(hdrcrc == NULL) return false;
  
  uint8_t * buffer = (uint8_t*)g_RomBuffer; 
  size_t size = sizeof(g_RomBuffer);
  
  if( NULL == buffer || size < sizeof(sTableHeaderCRC_t) ) 
  {      
      return false;
  }
  
  g_RomBuffer_Cache = RomBufCache_undefined;

  // Ïîñ÷èòàòü crc äàííûõ â òàáëèöå
  TCRC dataCrc;
  dataCrc = ICRC32;
  for(int i = 0; i < hdrcrc->Hdr.blocks; i++)
  {
      size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
                                                        private.properties.memProfile->
                            BaseAddr_Table[ (eChValues%eChValues_MAX) ] + i * hdrcrc->Hdr.size );
      sTableTablePoint_t TablePoint;
      romGetDataPoint( baseAddr, (uint8_t *)&TablePoint, sizeof(sTableTablePoint_t) );
      dataCrc = CRC32( dataCrc, (const unsigned char*)&TablePoint, sizeof(sTableTablePoint_t) ); 
  }
  
  // Ñ÷èòàåì crc õèäåðà
  TCRC crc;
  crc = ICRC32;
  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sTableHeader_t) ); 
  hdrcrc->CRCValue = crc;

  hdrcrc = romSetTableHeader( (uint8_t *)hdrcrc, sizeof(sTableHeaderCRC_t) );
  
  if( !SW_Validate_Table_Header_CRC( hdrcrc ) )
  {    
      // invalid common header
      // so, create new common header
      hdrcrc = (sTableHeaderCRC_t*)buffer;
      memset(hdrcrc, 0x00, sizeof(sTableHeaderCRC_t));
      return false;
  }

  return true;
}

uint16_t SW_ROM_GetNumberOfPoints()
{
    sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
    
    if( NULL == TableHeader)
    {
        return 0;
    }
    
    return SW_Validate_Table_Header_CRC( TableHeader ) ? TableHeader->Hdr.blocks : 0;
}
// ------------------------------------------------------------------------------
// - Table Data functions -------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
bool SW_ROM_SetDataPoint ( eChunks_t tableId, sTableTablePoint_t * TablePoint )
{
    extern NFMClassEx_t * NFMClassExtended;
    if(NULL == TablePoint ||
       NULL == NFMClassExtended->private.properties.memProfile)
    {
        return false;
    }
    
    sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
    
    if( NULL == TableHeader)
    {
        return false;
    }
    
//    if( !SW_Validate_Table_Header_CRC( TableHeader ) )
//    {
//        memset(TableHeader, 0x00, sizeof(sTableHeaderCRC_t));
//        SW_ROM_ChangeTableHeader( TableHeader );
//        return false;
//    }
    
    size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
                                                    private.properties.memProfile->
                        BaseAddr_Table[ (tableId%eChValues_MAX) ] + TableHeader->Hdr.size );
    romSetDataPoint( baseAddr, (uint8_t *)TablePoint, sizeof(sTableTablePoint_t) );
    TableHeader->Hdr.blocks++;
    TableHeader->Hdr.size = TableHeader->Hdr.blocks * sizeof(sTableTablePoint_t);
    
    if( !SW_ROM_ChangeTableHeader( TableHeader ) )
    {
        return false;
    }
    
    return true;
}

const bool SW_ROM_GetDataPoint( eChunks_t tableId, uint8_t point_number, uint8_t * buffer, size_t size )
{
  extern NFMClassEx_t * NFMClassExtended;
  
  sTableTablePoint_t * TablePoint;
  bool cacheUsed = false;
  size_t baseAddr = 0;
  
  eRomBufCache_t cacheId = RomBufCache_undefined;
  
  if( NULL == buffer ) 
  { 
      cacheUsed = true;
      
      if( cacheId == g_RomBuffer_Cache && RomBufCache_undefined != g_RomBuffer_Cache )
      {
          TablePoint = (sTableTablePoint_t*)g_RomBuffer;
          goto L_NFM_ROM_GetDataHeader_AlreadyCached;
      }
      
      buffer = (uint8_t*)g_RomBuffer; 
      size = sizeof(g_RomBuffer); 
  }
  
  if( NULL == NFMClassExtended->private.properties.memProfile )
  {  
      return NULL;
  }
  
  baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
               private.properties.memProfile->
                  BaseAddr_Table[ (tableId%eChValues_MAX) ] + point_number * sizeof(sTableTablePoint_t) ); 

  if( NULL == buffer || size < sizeof(sTableTablePoint_t) ) 
  {
      return NULL;
  }  

  if( cacheUsed )
  {  
      g_RomBuffer_Cache = RomBufCache_undefined;
  }  

  // Ïðîâåðêà íà äîñòóïíîñòü çíà÷åíèÿ âî flash
  sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
  if( point_number >= TableHeader->Hdr.blocks ||
       !SW_Validate_Table_Header_CRC( TableHeader ) )
  {
      memset(TableHeader, 0x00, sizeof(sTableHeaderCRC_t));
      SW_ROM_ChangeTableHeader( TableHeader );
      return false;
  }
    
  if( NULL == TableHeader ||
     point_number >= TableHeader->Hdr.blocks)
  {
      return false;
  } 
  
  TablePoint = romGetDataPoint( baseAddr, buffer, size );

  if( NULL == TablePoint )
  {
      return NULL;
  }    

  if( cacheUsed )
  {
      g_RomBuffer_Cache = cacheId;
  }
  
L_NFM_ROM_GetDataHeader_AlreadyCached:
  
  return true;
}

uint32_t SW_ROM_Get_Table_crc( eChunks_t tableId )
{
    sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
    
    if( NULL == TableHeader)
    {
        return NULL;
    }
    
    TCRC crc;
    crc = ICRC32;
    sTableTablePoint_t TablePoint;
    
    for(int i = 0; i < TableHeader->Hdr.blocks; i++)
    {
        SW_ROM_GetDataPoint( tableId, i, (uint8_t *)&TablePoint, sizeof(sTableTablePoint_t) );
        crc = CRC32( crc, (const unsigned char*)&TablePoint, sizeof(sTableTablePoint_t) );
    }
    
    return crc;
}

bool SW_ROM_Set_Table_crc ( uint32_t crc )
{
    sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
    
    if( NULL == TableHeader)
    {
        return false;
    }
    TableHeader->table_crc = crc;
    TableHeader = romSetTableHeader( (uint8_t *)TableHeader, sizeof(sTableHeaderCRC_t) );
    if( NULL == TableHeader)
    {
        return false;
    }
    return true;
}

bool SW_ROM_Check_Table_crc()
{
    sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
    
    if( NULL == TableHeader)
    {
        return NULL;
    }
    
    uint32_t crc = SW_ROM_Get_Table_crc( eChValues );
    
    return TableHeader->table_crc == crc;
}

bool SW_ROM_Table_Clear()
{
    sTableHeaderCRC_t * TableHeader = SW_ROM_GetTableHeader();
    
    if( NULL == TableHeader)
    {
        return false;
    }
    memset(TableHeader, 0x00, sizeof(sTableHeaderCRC_t) );
    TableHeader = romSetTableHeader( (uint8_t *)TableHeader, sizeof(sTableHeaderCRC_t) );
    if( NULL == TableHeader)
    {
        return false;
    }
    return true;
}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
static sEcalHeaderCRC_t * romSetCommonHeader( uint8_t * buffer, size_t size )
{
  if( NULL == buffer || size < sizeof(sEcalHeaderCRC_t) ) 
    return NULL;

  /*
  size_t baseAddr = FLASH_USERBANK_0_ADDR;

         baseAddr += MEMORY_OFFSET_BLOCK_COMMON;
  */
  size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMBASE_FLASH_MAKEADDRESS_USERBANK0( MEMORY_OFFSET_BLOCK_COMMON ) );
  
  if( FLASH_SUCCESS( flash_write( baseAddr, buffer, sizeof(sEcalHeaderCRC_t), fwm_safewrite ) ) )
  {
      return (sEcalHeaderCRC_t*)buffer;
  }

  return NULL;
}
// ------------------------------------------------------------------------------
bool NFM_ROM_ChangeModel( eNFMModel_t modelId )
{
  sEcalHeaderCRC_t * hdrcrc;
  TCRC crc;

  uint8_t * buffer = (uint8_t*)g_RomBuffer; 
  size_t size = sizeof(g_RomBuffer);
  
  if( NULL == buffer || size < sizeof(sEcalHeaderCRC_t) ) 
  {      
      return false;
  }
  
  g_RomBuffer_Cache = RomBufCache_undefined;
  
  hdrcrc = romGetCommonHeader( buffer, size );

  if( NULL == hdrcrc )
  {    
      // invalid common header
      // so, create new common header
      hdrcrc = (sEcalHeaderCRC_t*)buffer;
      
      memset( hdrcrc->Hdr.SN, '0', sizeof(hdrcrc->Hdr.SN) );
      memset( hdrcrc->Hdr.Reserved1, 0, sizeof(hdrcrc->Hdr.Reserved1) );
      memset( hdrcrc->Hdr.Reserved2, 0, sizeof(hdrcrc->Hdr.Reserved2) );
  }  
  
  hdrcrc->Hdr.DeviceID = (uint8_t)modelId;

  crc = ICRC32;

  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sEcalHeader_t) ); 

  hdrcrc->CRCValue = crc;
  
  hdrcrc = romSetCommonHeader( buffer, size );
  
  if( NULL == hdrcrc )
  {
      return false;
  }

  return true;
}

//// ------------------------------------------------------------------------------
bool NFM_ROM_ChangeSerialNumber( const char * serial )
{
  sEcalHeaderCRC_t * hdrcrc;
  TCRC crc;

  uint8_t * buffer = (uint8_t*)g_RomBuffer; 
  size_t size = sizeof(g_RomBuffer);
  
  if( NULL == buffer || size < sizeof(sEcalHeaderCRC_t) ) 
  {      
      return false;
  }
  
  g_RomBuffer_Cache = RomBufCache_undefined;
  
  hdrcrc = romGetCommonHeader( buffer, size );

  if( NULL == hdrcrc )
  {    
      // invalid common header
      // so, create new common header
      hdrcrc = (sEcalHeaderCRC_t*)buffer;
      
      memset( hdrcrc->Hdr.SN, '0', sizeof(hdrcrc->Hdr.SN) );
      memset( hdrcrc->Hdr.Reserved1, 0, sizeof(hdrcrc->Hdr.Reserved1) );
      memset( hdrcrc->Hdr.Reserved2, 0, sizeof(hdrcrc->Hdr.Reserved2) );
  }  
  
  memcpy(hdrcrc->Hdr.SN, serial, sizeof(hdrcrc->Hdr.SN));

  crc = ICRC32;

  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sEcalHeader_t) ); 

  hdrcrc->CRCValue = crc;
  
  hdrcrc = romSetCommonHeader( buffer, size );
  
  if( NULL == hdrcrc )
  {
      return false;
  }

  return true;
}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
static sEcalTCompHeaderCRC_t * romGetTCompHeader( uint8_t * buffer, size_t size )
{
  extern NFMClassEx_t * NFMClassExtended;
  
  if( NULL == buffer || size < sizeof(sEcalTCompHeaderCRC_t) ) 
    return NULL;

  if( NULL == NFMClassExtended->private.properties.memProfile )
    return NULL;
  
//  size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->private.properties.memProfile->BaseAddr_TComp );
//  
//  if( FLASH_SUCCESS( flash_read( baseAddr, buffer, sizeof(sEcalTCompHeaderCRC_t) ) ) )
//  {
//      return (sEcalTCompHeaderCRC_t*)buffer;
//  }
  
  return NULL;
}
// ------------------------------------------------------------------------------
const sEcalTCompHeader_t * NFM_ROM_GetTCompHeader( uint8_t * buffer, size_t size )
{
  sEcalTCompHeaderCRC_t * hdrcrc;
  TCRC crc;
  bool cacheUsed = false;
  
  if( NULL == buffer ) 
  { 
      cacheUsed = true;
      
      if( RomBufCache_TCompHeader == g_RomBuffer_Cache )
      {
          hdrcrc = (sEcalTCompHeaderCRC_t*)g_RomBuffer;
          goto L_NFM_ROM_GetTCompHeader_AlreadyCached;
      }
      
      buffer = (uint8_t*)g_RomBuffer; 
      size = sizeof(g_RomBuffer);       
  }

  if( NULL == buffer || size < sizeof(sEcalTCompHeaderCRC_t) ) 
  {
      return NULL;
  }    

  if( cacheUsed )
  {  
      g_RomBuffer_Cache = RomBufCache_undefined;
  }  
  
  hdrcrc = romGetTCompHeader( buffer, size );

  if( NULL == hdrcrc )
  {
      return NULL;
  }    

  crc = ICRC32;

  crc = CRC32( crc, (const unsigned char*)hdrcrc, sizeof(sEcalTCompHeader_t) ); 

  if( crc != hdrcrc->CRCValue )
  {
      return NULL;
  }   
  
  if( cacheUsed )
  {
      g_RomBuffer_Cache = RomBufCache_TCompHeader;
  }

L_NFM_ROM_GetTCompHeader_AlreadyCached:
  return (sEcalTCompHeader_t *)hdrcrc;
}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
size_t NFM_ROM_GetChrzTableIndex( ePortComb_t portCombination, ePortStateId_t portState )
{
//    extern NFMClassEx_t * NFMClassExtended;
//    
//    if(    ePortComb_MAX <= portCombination
//        || ePortComb_UNDEFINED == portCombination
//        || ePortStateId_MAX <= portState
//        || ePortStateId_UNDEFINED == portState
//      )    
//    {
//        return (NFM_CHRZ_TABLEIDX_INVALID);
//    }
//    
//    if( 
//         NULL == NFMClassExtended->private.properties.memProfile
//      || NULL == NFMClassExtended->private.properties.memProfile->tbls_raw )
//    {
//        return (NFM_CHRZ_TABLEIDX_INVALID);
//    }
//           
//    const sNFMMemory_ChrzTableMatrix_XPort_t * tableProfile_XPort = NFMClassExtended->private.properties.memProfile->tbls_raw;
//    const sNFMMemory_ChrzTableMatrix_2Port_t * tableProfile_2Port = NFMClassExtended->private.properties.memProfile->tbls_2Port;
//    const sNFMMemory_ChrzTableMatrix_4Port_t * tableProfile_4Port = NFMClassExtended->private.properties.memProfile->tbls_4Port;
//    
//    if(   ePortComb_MIN_SINGLE_XPort <= portCombination
//       && ePortComb_MAX_SINGLE_XPort >= portCombination )
//    {
//        switch(tableProfile_XPort->Header.ChrzTableType.eType)
//        {
//            case eNfmChrzTable2Port:
//            {
//                if(   ePortComb_MIN_SINGLE_2Port <= portCombination
//                   && ePortComb_MAX_SINGLE_2Port >= portCombination )
//                {
//                   if(   ePortStateId_MIN_SINGLE_2Port <= portState
//                      && ePortStateId_MAX_SINGLE_2Port >= portState )
//                   {
//                                  return tableProfile_2Port->Single.aArray[ 
//                                    (size_t)(portCombination - ePortComb_MIN_SINGLE_2Port) 
//                      ].aBaseIndex [
//                                    (size_t)(portState - ePortStateId_MIN_SINGLE_2Port)
//                      ];
//                   }
//                }
//            }
//            break;
//            case eNfmChrzTable4Port:
//            {
//                if(   ePortComb_MIN_SINGLE_4Port <= portCombination
//                   && ePortComb_MAX_SINGLE_4Port >= portCombination )
//                {
//                   if(   ePortStateId_MIN_SINGLE_4Port <= portState
//                      && ePortStateId_MAX_SINGLE_4Port >= portState )
//                   {
//                      return tableProfile_4Port->Single.aArray[ 
//                        (size_t)(portCombination - ePortComb_MIN_SINGLE_4Port) 
//                      ].aBaseIndex [
//                        (size_t)(portState - ePortStateId_MIN_SINGLE_4Port)
//                      ];
//                   }
//                }
//            }
//            break;
//        }
//        
//        return 0; // unsupported characterization table type
//    }
//    else
//    if(   ePortComb_MIN_THRU_XPort <= portCombination
//       && ePortComb_MAX_THRU_XPort >= portCombination )
//    {
//        switch(tableProfile_XPort->Header.ChrzTableType.eType)
//        {
//            case eNfmChrzTable2Port:
//            {
//               if(   ePortComb_MIN_THRU_2Port <= portCombination
//                  && ePortComb_MAX_THRU_2Port >= portCombination )
//               {
//                   if(   ePortStateId_MIN_THRU_2Port <= portState
//                      && ePortStateId_MAX_THRU_2Port >= portState )
//                   {
//                       return tableProfile_2Port->Thru.aArrays[
//                         (size_t)(portCombination - ePortComb_MIN_THRU_2Port) 
//                       ].aBaseIndex [
//                         (size_t)(portState - ePortStateId_MIN_THRU_2Port)
//                       ];
//                   }
//               }
//            }
//            break;
//            case eNfmChrzTable4Port:
//            {
//               if(   ePortComb_MIN_THRU_4Port <= portCombination
//                  && ePortComb_MAX_THRU_4Port >= portCombination )
//               {
//                   if(   ePortStateId_MIN_THRU_4Port <= portState
//                      && ePortStateId_MAX_THRU_4Port >= portState )
//                   {
//                       return tableProfile_4Port->Thru.aArrays[
//                         (size_t)(portCombination - ePortComb_MIN_THRU_4Port) 
//                       ].aBaseIndex [
//                         (size_t)(portState - ePortStateId_MIN_THRU_4Port)
//                       ];    
//                   }
//               }  
//            }
//            break;
//        }
//        
//        return 0; // unsupported characterization table type
//    }  
//    else
//    if( ePortComb_CHECK == portCombination )
//    {
//       if(   ePortStateId_MIN_CHECK_XPort <= portState
//          && ePortStateId_MAX_CHECK_XPort >= portState )
//       {
//          switch(tableProfile_XPort->Header.ChrzTableType.eType)
//          {
//              case eNfmChrzTable2Port:
//              {
//                 if(   ePortStateId_MIN_CHECK_2Port <= portState
//                    && ePortStateId_MAX_CHECK_2Port >= portState )
//                 {
//                        return tableProfile_2Port->Check.sArray
//                          .aBaseIndex[ 
//                          (size_t)(portState - ePortStateId_MIN_CHECK_2Port)
//                        ];
//                 }
//              }
//              break;
//              case eNfmChrzTable4Port:
//              {
//                 if(   ePortStateId_MIN_CHECK_4Port <= portState
//                    && ePortStateId_MAX_CHECK_4Port >= portState )
//                 {
//                        return tableProfile_4Port->Check.sArray
//                          .aBaseIndex[ 
//                          (size_t)(portState - ePortStateId_MIN_CHECK_4Port)
//                        ];    
//                 }
//              } 
//              break;
//          }
//          
//          return 0; // unsupported characterization table type
//       }
//    } 
    
    return (NFM_CHRZ_TABLEIDX_INVALID);
}

size_t NFM_ROM_GetTCompTableIndex( ePortComb_t portCombination, ePortStateId_t portState )
{
    extern NFMClassEx_t * NFMClassExtended;
    
    return NFMClassExtended->private.methods.memory.getChrzTableIndex( portCombination, portState );
}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// NFM_ROM_ReadChrzTableHeader:
// Reads the characterization table header by port combination (e.g. A,B, CD, CHECK),
// the port state (LOAD, SHORT, S11...), amount of points in the table (@nPoints) and
// the sector identifier (@sectorId).
// The amount of points must be retrieved before the call and passed into the function.
// You can use NFM_ROM_GetDataHeader() for this purpose.
// The table will be validated by calculating CRC.
// The function returns the base address of the table only in case
// all the conditions listed below are valid:
// - current device model has valid memory profile;
// - tableIdx is valid and not exceed the maximum table index for current memory profile;
// - nPoints is non-zero;
// - pHeader is non-NULL;
// - talbe has valid CRC;
// Otherwise, the function returns 0.
size_t NFM_ROM_ReadChrzTableHeader(   eChrz_t sectorId,
                                      ePortComb_t portCombination, 
                                      ePortStateId_t portState,
                                      size_t nPoints,   // @nPoints = amount of points in the table
                                      sEcalChrzTableHeader_t * pHeader,
                                      unsigned int * pErrCode
                                  )
{
   extern NFMClassEx_t * NFMClassExtended;
   
//   size_t tableIdx = NFM_CHRZ_TABLEIDX_INVALID;
//   
//   if( 
//         NULL == NFMClassExtended->private.properties.memProfile
//      || NULL == NFMClassExtended->private.properties.memProfile->tbls_raw
//      || NULL == pHeader
//      || 0 == nPoints 
//      || NULL == pErrCode  
//     )
//   {
//       if( NULL != pErrCode )
//           *pErrCode = ERR_NFMGETPOINTS_INVAL;
//             
//       // Invalid parameters or model properties
//       return 0;
//   }
//   
//   /*
//   const sNFMMemory_ChrzTableMatrix_XPort_t * tableProfile = NFMClassExtended->private.properties->memProfile->tbls_raw;
//
//   if( tableIdx > tableProfile->Header.maxTableIdx )
//   {
//       // invalid table index
//       return 0;
//   }      
//   */
//         
//   // Validate the combination of @portCombination, @portState and
//   // validate the @portCombination and @portState itself.
//   // Retrieve the table index (ordered index)   
//   tableIdx = NFMClassExtended->private.methods.memory.getChrzTableIndex( portCombination, portState );
//   
//   if( NFM_CHRZ_TABLEIDX_INVALID == tableIdx )
//   {       
//       *pErrCode = ERR_NFMGETPOINTS_INVAL;
//       
//       // Invalid combination or value
//       return 0;
//   }
//   
//   // Retireve the table index offset
//   size_t tableOffset = NFM_CHRZ_TABLEIDX_2_OFFSET( tableIdx );
//   
//   // Calculate the table offset
//   tableOffset *= SIZE_CHRZ_TABLE( nPoints );
//   
//   // shift the offset by the characterization main header
//   tableOffset += SIZE_CHRZ_HEADER;
//   
//   // add the base address of characterization sector to the table offset
//   // to get absolute address
//   tableOffset += NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
//                   private.properties.memProfile->
//                     BaseAddr_Chrz[ (sectorId%eCh_MAX) ] ); 
//   
//   // Validate the table
//   {
//      // use internal buffer
//      g_RomBuffer_Cache = RomBufCache_undefined;
//      
//      size_t nBytes = SIZE_CHRZ_TABLE( nPoints ) - SIZE_CHRZ_TCRC;
//      size_t baseAddr = tableOffset;
//      
//      uint8_t * buffer = g_RomBuffer;
//      size_t bufferSize = sizeof(g_RomBuffer);
//      
//      TCRC crc = ICRC32;
//      
//      while( nBytes > 0 )
//      {
//          if( bufferSize > nBytes )
//          {
//              bufferSize = nBytes;
//          }
//          
//          if( ! FLASH_SUCCESS( flash_read( baseAddr, buffer, bufferSize ) ) )
//          {
//              *pErrCode = ERR_NFMGETPOINTS_IO;
//              
//              // i/o error
//              return 0;
//          }
//        
//          baseAddr += bufferSize;
//          nBytes -= bufferSize;
//          
//          crc = CRC32( crc, buffer, bufferSize ); 
//      }
//      
//      if( ! FLASH_SUCCESS( flash_read( baseAddr, buffer, SIZE_CHRZ_TCRC ) ) )
//      {
//          *pErrCode = ERR_NFMGETPOINTS_IO;
//          
//          // i/o error
//          return 0;
//      }
//      else if( *((TCRC*)buffer) != crc )
//      {
//          *pErrCode = ERR_NFMGETPOINTS_INVTBL;
//          
//          // crc error
//          return 0;
//      }
//   }
//   
//   // actually read the header
//   if( ! FLASH_SUCCESS( flash_read( tableOffset, (uint8_t*)pHeader, SIZE_CHRZ_THDR ) ) )
//   {
//       *pErrCode = ERR_NFMGETPOINTS_IO;
//       
//       // i/o error
//       return 0;
//   }
//   
//   *pErrCode = ERR_NFMGETPOINTS_NOERR;
//   
//   return tableOffset;
   return 0;
}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// NFM_ROM_ReadChrzTablePoints:
// Loads the characterization data points from the memory.
// The input parameters - only @pContext, which contains all required information:
// - @.TableAddress = depends on the selected memory segment and the selected table
// - @.nCount = amount of points to load
// - @.nStartPoint = the offset in "points" of starting point
// - @.pDataArray = the memory buffer to fill with the data
// Note: this structure must be initialized firstly by @NFM_ROM_ReadChrzTableHeader()
// call (aka @NFMClassExtended->private.methods.memory.getChrzTableHeader() )
size_t NFM_ROM_ReadChrzTablePoints( /*const*/ sNFMGetPoints_t * pContext )
{
   // check the input parameters
   if(    NULL == pContext
       || 0 == pContext->in.nCount
       || NULL == pContext->in.pDataArray
       || 0 == pContext->out.nPoints
       || 0 == pContext->out.TableAddress )
   {
       if( NULL != pContext )
           pContext->svc.errCode = ERR_NFMGETPOINTS_INVAL;
         
       return 0; // error
   }
   
   // initialize the first requested point offset
   size_t  
   //  by the table address
   pointOffset  = pContext->out.TableAddress;     
   //  and shift it by the table header size  
   pointOffset += SIZE_CHRZ_THDR;   
   //  and shift it by the size of skipped points
   pointOffset += pContext->in.nStartPoint * SIZE_CHRZ_TPNT;
   
   // use internal buffer
   g_RomBuffer_Cache = RomBufCache_undefined;
   
   // read the points contineously
   for( size_t n = 0; n < pContext->in.nCount; (void)n )
   {
        // calculate amount of points available to be cached
        size_t nPointsRead = sizeof(g_RomBuffer) / SIZE_CHRZ_TPNT;
        
        // limit amount of points to be read by the number of required points
        if( nPointsRead > (pContext->in.nCount-n) )
        {
            nPointsRead = (pContext->in.nCount-n);
        }
        
        // actually read the points
        if( ! FLASH_SUCCESS( flash_read(            // Read the points
               pointOffset,                                 //  with the specified offset of current point
               g_RomBuffer,                                 //   into the internal buffer,
               nPointsRead * SIZE_CHRZ_TPNT                 //    and read only @nPointsRead points
              )) 
          )
        {
            pContext->svc.errCode = ERR_NFMGETPOINTS_IO;
            // i/o error
            return 0;
        }
        
        // cast the buffer @g_RomBuffer to the [sEcalChrzTablePoint_t] array
        const sEcalChrzTablePoint_t * pComplexPoints = (sEcalChrzTablePoint_t*)g_RomBuffer;
                
        // Convert each of @nPointsRead data points from 24-bit format into the double format        
        for( size_t iPoint = 0; iPoint < nPointsRead; ++iPoint )
        {
            // magnitude
            {
                int32_t data24bit;  // 24-bit value in the memory is signed value
                
                {
                    uint32_t U_data24bit; 
                    // Retrieve the 24-bit data of magnitude
                    U_data24bit  = ((uint32_t)pComplexPoints[iPoint].Magn)  <<  0;  // low 16-bits
                    U_data24bit |= ((uint32_t)pComplexPoints[iPoint].Magn2) << 16;  // high 8-bits
                    
                    // check the sign bit
                    if( U_data24bit & (1<<23) )
                    {
                        // negative value
                        U_data24bit ^= 0xFFFFFF;
                        U_data24bit += 0x000001;
                        
                        // convert to signed variable
                        data24bit = -((int32_t)U_data24bit);
                    }                    
                    else
                    {                        
                        // positive value
                      
                        // convert to signed variable
                        data24bit = ((int32_t)U_data24bit);
                    }
                }
                
                // Convert the 24-bit data into the double
                // 24-bit data is amount of descrettes of ((max-min)/16777215)
                // where @min and @max is a magintude value in 0.01dB discrettes
                
              //#define MAGN24_2_DOUBLE(data24bit,min,max) (((data24bit) / (double)16777215.0f) * ((double)( (max) - (min) ) / (double)100.0f))
                #define MAGN24_2_DOUBLE(data24bit,min,max) ( (data24bit) * ((((double)( (max) - (min) )) / ((double)100.0)) / (double)16777215.0) + (((double)( (max) + (min) )) / 200.0))
                // store the result into the output double array
                pContext->in.pDataArray[ n + iPoint ].magn = MAGN24_2_DOUBLE( data24bit, pContext->out.min, pContext->out.max );
            } 
            
            // phase
            {
                int32_t data24bit = 0;  // 24-bit value in the memory is signed value
                
                {
                    uint32_t U_data24bit; 
                    // Retrieve the 24-bit data of phase
                    U_data24bit  = ((uint32_t)pComplexPoints[iPoint].Angle)  <<  0;  // low 16-bits
                    U_data24bit |= ((uint32_t)pComplexPoints[iPoint].Angle2) << 16;  // high 8-bits
                 
                    // check the sign bit
                    if( U_data24bit & (1<<23) )
                    {
                        // negative value
                        U_data24bit ^= 0xFFFFFF;
                        U_data24bit += 0x000001;
                        
                        // convert to signed variable
                        data24bit = -((int32_t)U_data24bit);
                    }
                    else
                    {                        
                        // positive value
                      
                        // convert to signed variable
                        data24bit = ((int32_t)U_data24bit);
                    }
                }
                // Convert the 24-bit data into the double
                // 24-bit data is amount of descrettes of (PI/0x7FFFFF)
                #define PI  (3.141592653589793238462643)
                #define R2D (180.0/PI)
                #define PHAS24_2_DOUBLE(data24bit) (((data24bit) / (double)8388607.0f) * (double)(PI))
                #define PHAS_RAD_2_DEG( rad ) ((rad)*(R2D))

                // store the result into the output double array
                pContext->in.pDataArray[ n + iPoint ].phase = PHAS_RAD_2_DEG(PHAS24_2_DOUBLE( data24bit ));
            }           
        }
        
        // decrease amount of points to read
        n += nPointsRead;
        
        // shift the address
        pointOffset += nPointsRead * SIZE_CHRZ_TPNT;
   }
   
   pContext->svc.errCode = ERR_NFMGETPOINTS_NOERR;
   
   // return amount of points
   return pContext->in.nCount;
}
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------

// NFM_ROM_GetTCompMagnTableHeader:
// Reads the thermocompensation magnitude table header by port combination (e.g. A,B, CD, CHECK),
// the port state (LOAD, SHORT, S11...), amount of points in the table (@nPoints) and
// the sector identifier (@sectorId).
// The amount of points must be retrieved before the call and passed into the function.
// You can use NFM_ROM_GetTCompHeader() for this purpose.
// The table will be validated by calculating CRC.
// The function returns the base address of the table only in case
// all the conditions listed below are valid:
// - current device model has valid memory profile;
// - tableIdx is valid and not exceed the maximum table index for current memory profile;
// - nPoints is non-zero;
// - pHeader is non-NULL;
// - talbe has valid CRC;
// Otherwise, the function returns 0.
size_t NFM_ROM_GetTCompMagnTableHeader( ePortComb_t portCombination, ePortStateId_t portState,
                                        size_t nPoints, sEcalTCompTableMagnHeader_t * pHeader,
                                        unsigned int * pErrCode
                                      )
{
   extern NFMClassEx_t * NFMClassExtended;
   
   return 0;
//   size_t tableIdx = NFM_CHRZ_TABLEIDX_INVALID;
//   
//   if( 
//         NULL == NFMClassExtended->private.properties.memProfile
//      || NULL == NFMClassExtended->private.properties.memProfile->tbls_raw
//      || NULL == pHeader
//      || 0 == nPoints )
//   {
//       if( NULL != pErrCode )
//           *pErrCode = ERR_NFMGETPOINTS_INVAL;
//       
//       // Invalid parameters or model properties
//       return 0;
//   }
//   
//   /*
//   const sNFMMemory_ChrzTableMatrix_XPort_t * tableProfile = NFMClassExtended->private.properties->memProfile->tbls_raw;
//
//   if( tableIdx > tableProfile->Header.maxTableIdx )
//   {
//       // invalid table index
//       return 0;
//   }      
//   */
//         
//   // Validate the combination of @portCombination, @portState and
//   // validate the @portCombination and @portState itself.
//   // Retrieve the table index (ordered index)   
//   tableIdx = NFMClassExtended->private.methods.memory.getTCompTableIndex( portCombination, portState );
//   
//   if( NFM_CHRZ_TABLEIDX_INVALID == tableIdx )
//   {
//       *pErrCode = ERR_NFMGETPOINTS_INVAL;
//       
//       // Invalid combination or value
//       return 0;
//   }
//   
//   // Retireve the table index offset
//   size_t tableOffset = NFM_TCOMP_MAGN_TABLEIDX_2_OFFSET( tableIdx );
//   
//   // Calculate the table offset
//   tableOffset *= SIZE_TCOMP_MAGN_TABLE( nPoints );
//   
//   // shift the offset by the thermocompensation main header
//   tableOffset += SIZE_TCOMP_HEADER;
//   
//   // add the base address of thermocompensation sector to the table offset
//   // to get absolute address
//   tableOffset += NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
//                   private.properties.memProfile->
//                     BaseAddr_TComp ); 
//   
//   // Validate the table
//   {
//      // use internal buffer
//      g_RomBuffer_Cache = RomBufCache_undefined;
//      
//      size_t nBytes = SIZE_TCOMP_MAGN_TABLE( nPoints ) - SIZE_TCOMP_TCRC;
//      size_t baseAddr = tableOffset;
//      
//      uint8_t * buffer = g_RomBuffer;
//      size_t bufferSize = sizeof(g_RomBuffer);
//      
//      TCRC crc = ICRC32;
//      
//      while( nBytes > 0 )
//      {
//          if( bufferSize > nBytes )
//          {
//              bufferSize = nBytes;
//          }
//          
//          if( ! FLASH_SUCCESS( flash_read( baseAddr, buffer, bufferSize ) ) )
//          {
//              *pErrCode = ERR_NFMGETPOINTS_IO;
//              
//              // i/o error
//              return 0;
//          }
//        
//          baseAddr += bufferSize;
//          nBytes -= bufferSize;
//          
//          crc = CRC32( crc, buffer, bufferSize ); 
//      }
//      
//      if( ! FLASH_SUCCESS( flash_read( baseAddr, buffer, SIZE_TCOMP_TCRC ) ) )
//      {
//          *pErrCode = ERR_NFMGETPOINTS_IO;
//          
//          // i/o error
//          return 0;
//      }
//      else if( *((TCRC*)buffer) != crc )
//      {
//          *pErrCode = ERR_NFMGETPOINTS_INVTBL;
//          
//          // crc error
//          return 0;
//      }
//   }
//   
//   // actually read the header
//   if( ! FLASH_SUCCESS( flash_read( tableOffset, (uint8_t*)pHeader, SIZE_TCOMP_MAGN_THDR ) ) )
//   {
//       *pErrCode = ERR_NFMGETPOINTS_IO;
//       
//       // i/o error
//       return 0;
//   }
//   
//   *pErrCode = ERR_NFMGETPOINTS_NOERR;
//   
//   return tableOffset;
}

// NFM_ROM_GetTCompPhaseTableHeader:
// Reads the thermocompensation phase table header by port combination (e.g. A,B, CD, CHECK),
// the port state (LOAD, SHORT, S11...), amount of points in the table (@nPoints) and
// the sector identifier (@sectorId).
// The amount of points must be retrieved before the call and passed into the function.
// You can use NFM_ROM_GetTCompHeader() for this purpose.
// The table will be validated by calculating CRC.
// The function returns the base address of the table only in case
// all the conditions listed below are valid:
// - current device model has valid memory profile;
// - tableIdx is valid and not exceed the maximum table index for current memory profile;
// - nPoints is non-zero;
// - pHeader is non-NULL;
// - talbe has valid CRC;
// Otherwise, the function returns 0.
size_t NFM_ROM_GetTCompPhaseTableHeader( ePortComb_t portCombination, ePortStateId_t portState,
                                        size_t nPoints, sEcalTCompTablePhaseHeader_t * pHeader,
                                        unsigned int * pErrCode
                                       )
{
   extern NFMClassEx_t * NFMClassExtended;
   
//   size_t tableIdx = NFM_CHRZ_TABLEIDX_INVALID;
//   
//   if( 
//         NULL == NFMClassExtended->private.properties.memProfile
//      || NULL == NFMClassExtended->private.properties.memProfile->tbls_raw
//      || NULL == pHeader
//      || 0 == nPoints 
//      || NULL == pErrCode  
//     )
//   {
//       if( NULL != pErrCode )
//           *pErrCode = ERR_NFMGETPOINTS_INVAL;
//       
//       // Invalid parameters or model properties
//       return 0;
//   }
//   
//   /*
//   const sNFMMemory_ChrzTableMatrix_XPort_t * tableProfile = NFMClassExtended->private.properties->memProfile->tbls_raw;
//
//   if( tableIdx > tableProfile->Header.maxTableIdx )
//   {
//       // invalid table index
//       return 0;
//   }      
//   */
//         
//   // Validate the combination of @portCombination, @portState and
//   // validate the @portCombination and @portState itself.
//   // Retrieve the table index (ordered index)   
//   tableIdx = NFMClassExtended->private.methods.memory.getTCompTableIndex( portCombination, portState );
//   
//   if( NFM_CHRZ_TABLEIDX_INVALID == tableIdx )
//   {
//       *pErrCode = ERR_NFMGETPOINTS_INVAL;
//       
//       // Invalid combination or value
//       return 0;
//   }
//   
//   // Retireve the table index offset
//   size_t tableOffset = NFM_TCOMP_PHASE_TABLEIDX_2_OFFSET( tableIdx );
//   
//   // Calculate the table offset
//   tableOffset *= SIZE_TCOMP_PHASE_TABLE( nPoints );
//   
//   // shift the offset by the thermocompensation main header
//   tableOffset += SIZE_TCOMP_HEADER;
//   
//   // add the base address of thermocompensation sector to the table offset
//   // to get absolute address
//   tableOffset += NFMBASE_FLASH_MAKEREALADDRESS( NFMClassExtended->
//                   private.properties.memProfile->
//                     BaseAddr_TComp ); 
//   
//   // Validate the table
//   {
//      // use internal buffer
//      g_RomBuffer_Cache = RomBufCache_undefined;
//      
//      size_t nBytes = SIZE_TCOMP_PHASE_TABLE( nPoints ) - SIZE_TCOMP_TCRC;
//      size_t baseAddr = tableOffset;
//      
//      uint8_t * buffer = g_RomBuffer;
//      size_t bufferSize = sizeof(g_RomBuffer);
//      
//      TCRC crc = ICRC32;
//      
//      while( nBytes > 0 )
//      {
//          if( bufferSize > nBytes )
//          {
//              bufferSize = nBytes;
//          }
//          
//          if( ! FLASH_SUCCESS( flash_read( baseAddr, buffer, bufferSize ) ) )
//          {
//              *pErrCode = ERR_NFMGETPOINTS_IO;
//              
//              // i/o error
//              return 0;
//          }
//        
//          baseAddr += bufferSize;
//          nBytes -= bufferSize;
//          
//          crc = CRC32( crc, buffer, bufferSize ); 
//      }
//      
//      if( ! FLASH_SUCCESS( flash_read( baseAddr, buffer, SIZE_TCOMP_TCRC ) ) )
//      {
//          *pErrCode = ERR_NFMGETPOINTS_IO;
//          
//          // i/o error
//          return 0;
//      }
//      else if( *((TCRC*)buffer) != crc )
//      {
//          *pErrCode = ERR_NFMGETPOINTS_INVTBL;
//          
//          // crc error
//          return 0;
//      }
//   }
//   
//   // actually read the header
//   if( ! FLASH_SUCCESS( flash_read( tableOffset, (uint8_t*)pHeader, SIZE_TCOMP_PHASE_THDR ) ) )
//   {
//       *pErrCode = ERR_NFMGETPOINTS_IO;
//       
//       // i/o error
//       return 0;
//   }
//   
//   *pErrCode = ERR_NFMGETPOINTS_NOERR;
//   
//   return tableOffset;
   return 0;
}
                                         
size_t NFM_ROM_GetTCompMagnPoints( /*const*/ sNFMGetPoints_t * pContext )
{
   // check the input parameters
   if(    NULL == pContext
       || 0 == pContext->in.nCount
       || NULL == pContext->in.pDataArray
       || 0 == pContext->out.nPoints
       || 0 == pContext->out.TableAddress )
   {
       if( NULL != pContext )
           pContext->svc.errCode = ERR_NFMGETPOINTS_INVAL;
       
       return 0; // error
   }
   
   // initialize the first requested point offset
   size_t  
   //  by the table address
   pointOffset  = pContext->out.TableAddress;     
   //  and shift it by the table header size  
   pointOffset += SIZE_TCOMP_MAGN_THDR;   
   //  and shift it by the size of skipped points
   pointOffset += pContext->in.nStartPoint * SIZE_TCOMP_MAGN_TPNT;
   
   // use internal buffer
   g_RomBuffer_Cache = RomBufCache_undefined;
   
   // read the points contineously
   for( size_t n = 0; n < pContext->in.nCount; (void)n )
   {
        // calculate amount of points available to be cached
        size_t nPointsRead = sizeof(g_RomBuffer) / SIZE_TCOMP_MAGN_TPNT;
        
        // limit amount of points to be read by the number of required points
        if( nPointsRead > (pContext->in.nCount-n) )
        {
            nPointsRead = (pContext->in.nCount-n);
        }
        
        // actually read the points
        if( ! FLASH_SUCCESS( flash_read(            // Read the points
               pointOffset,                                 //  with the specified offset of current point
               g_RomBuffer,                                 //   into the internal buffer,
               nPointsRead * SIZE_TCOMP_MAGN_TPNT           //    and read only @nPointsRead points
              )) 
          )
        {
            pContext->svc.errCode = ERR_NFMGETPOINTS_IO;
            
            // i/o error
            return 0;
        }
        
        // cast the buffer @g_RomBuffer to the [sEcalChrzTablePoint_t] array
        const sEcalTCompTableMagnPoint_t * pComplexPoints = (sEcalTCompTableMagnPoint_t*)g_RomBuffer;
        
      
        // Convert each of @nPointsRead data points from 24-bit format into the double format        
        for( size_t iPoint = 0; iPoint < nPointsRead; ++iPoint )
        {
            // thermocompensation magnitude
            {
                // Convert the 16-bit data into the double
                // 16-bit data is amount of descrettes of ((max-min)/65536)
                // where @min and @max is a magintude value in 0.01dB/C discrettes              
              
                double max = (double)(pContext->out.max) / 100.0;
                double min = (double)(pContext->out.min) / 100.0;
                double mean = (min + max) / 2.0;

                // Note: each point is signed 16-bit integer
                // store the result into the output double array
                pContext->in.pDataArray[ n + iPoint ].phase = 0; // not used
                pContext->in.pDataArray[ n + iPoint ].magn 
                  = mean + (double)pComplexPoints[iPoint].Magn * (max - min) / 65535.0;
            }
            /*
            {
                // Convert the 16-bit data into the double
                // 16-bit data is amount of descrettes of ((max-min)/65536)
                // where @min and @max is a magintude value in 0.01dB/C discrettes              
                #define MAGN16_DISCRETTE(min,max)    ((( (double)(max) - (double)(min) )) / ((double)6553500.0))
                #define MAGN16_MEAN(min,max)         ((( (double)(max) + (double)(min) )) / ((double)200.0))

                // Note: each point is signed 16-bit integer
                // store the result into the output double array
                pContext->in.pDataArray[ n + iPoint ].phase = 0; // not used
                pContext->in.pDataArray[ n + iPoint ].magn = 
                  MAGN16_MEAN( pContext->out.min, pContext->out.max ) +
                    ((double)(pComplexPoints[iPoint].Magn)) *
                      MAGN16_DISCRETTE( pContext->out.min, pContext->out.max );
            }
            */
        }
        
        // decrease amount of points to read
        n += nPointsRead;
        
        // shift the address
        pointOffset += nPointsRead * SIZE_TCOMP_MAGN_TPNT;
   }
   
   pContext->svc.errCode = ERR_NFMGETPOINTS_NOERR;
   
   // return amount of points
   return pContext->in.nCount;
}

size_t NFM_ROM_GetTCompPhasePoints( /*const*/ sNFMGetPoints_t * pContext )
{
   // check the input parameters
   if(    NULL == pContext
       || 0 == pContext->in.nCount
       || NULL == pContext->in.pDataArray
       || 0 == pContext->out.nPoints
       || 0 == pContext->out.TableAddress )
   {
       if( NULL != pContext )
           pContext->svc.errCode = ERR_NFMGETPOINTS_INVAL;
       
       return 0; // error
   }
   
   // initialize the first requested point offset
   size_t  
   //  by the table address
   pointOffset  = pContext->out.TableAddress;     
   //  and shift it by the table header size  
   pointOffset += SIZE_TCOMP_PHASE_THDR;   
   //  and shift it by the size of skipped points
   pointOffset += pContext->in.nStartPoint * SIZE_TCOMP_PHASE_TPNT;
   
   // use internal buffer
   g_RomBuffer_Cache = RomBufCache_undefined;
   
   // read the points contineously
   for( size_t n = 0; n < pContext->in.nCount; (void)n )
   {
        // calculate amount of points available to be cached
        size_t nPointsRead = sizeof(g_RomBuffer) / SIZE_TCOMP_PHASE_TPNT;
        
        // limit amount of points to be read by the number of required points
        if( nPointsRead > (pContext->in.nCount-n) )
        {
            nPointsRead = (pContext->in.nCount-n);
        }
        
        // actually read the points
        if( ! FLASH_SUCCESS( flash_read(            // Read the points
               pointOffset,                                 //  with the specified offset of current point
               g_RomBuffer,                                 //   into the internal buffer,
               nPointsRead * SIZE_TCOMP_PHASE_TPNT          //    and read only @nPointsRead points
              )) 
          )
        {
            pContext->svc.errCode = ERR_NFMGETPOINTS_IO;
            
            // i/o error
            return 0;
        }
        
        // cast the buffer @g_RomBuffer to the [sEcalChrzTablePoint_t] array
        const sEcalTCompTablePhasePoint_t * pComplexPoints = (sEcalTCompTablePhasePoint_t*)g_RomBuffer;
        
      
        // Convert each of @nPointsRead data points from 16-bit format into the double format        
        for( size_t iPoint = 0; iPoint < nPointsRead; ++iPoint )
        {
            // thermocompensation phase
            {
                // Convert the 16-bit data into the double
                // 16-bit data is amount of descrettes of ((max-min)/65536)
                // where @min and @max is a magintude value in 0.01deg/C discrettes
              
                double max = (double)(pContext->out.max) / 100.0;
                double min = (double)(pContext->out.min) / 100.0;
                double mean = (min + max) / 2.0;
                
                // Note: each point is signed 16-bit integer
                // store the result into the output double array
                pContext->in.pDataArray[ n + iPoint ].magn = 0; // not used
                pContext->in.pDataArray[ n + iPoint ].phase 
                  = mean + (double)(pComplexPoints[iPoint].Phase) * (max - min) / 65535.0;
            }
            /*
            {
                // Convert the 16-bit data into the double
                // 16-bit data is amount of descrettes of ((max-min)/65536)
                // where @min and @max is a magintude value in 0.01deg/C discrettes
              //#define PHASE16_DISCRETTE(min,max)    (((double)( (max) - (min) )) / ((double)6553500.0))
              //#define PHASE16_MEAN(min,max)         (((double)( (max) + (min) )) / ((double)200.0))
                #define PHASE16_DISCRETTE(min,max)    ((( (double)(max) - (double)(min) )) / ((double)6553500.0))
                #define PHASE16_MEAN(min,max)         ((( (double)(max) + (double)(min) )) / ((double)200.0))
                
                // Note: each point is signed 16-bit integer
                // store the result into the output double array
                pContext->in.pDataArray[ n + iPoint ].magn = 0; // not used
                pContext->in.pDataArray[ n + iPoint ].phase = 
                  PHASE16_MEAN( pContext->out.min, pContext->out.max ) +
                    ((double)(pComplexPoints[iPoint].Phase)) *
                      PHASE16_DISCRETTE( pContext->out.min, pContext->out.max );
            }
            */
        }
        
        // decrease amount of points to read
        n += nPointsRead;
        
        // shift the address
        pointOffset += nPointsRead * SIZE_TCOMP_PHASE_TPNT;
   }
   
   pContext->svc.errCode = ERR_NFMGETPOINTS_NOERR;
   
   // return amount of points
   return pContext->in.nCount;
}

size_t NFM_ROM_ReadDeviceSettings( uint8_t * buffer, size_t nOffset, size_t nBytesToRead )
{
  extern NFMClassEx_t * NFMClassExtended;
  const sSwitchMemoryProfile_t * memProfile = NFMClassExtended->private.properties.memProfile;
  
  if( NULL != NFMClassExtended->private.properties.memProfile )
  if( 0 < memProfile->Size_Settings )
  {
      if( (NULL != buffer) && (nOffset < memProfile->Size_Settings) && (0 < nBytesToRead) )
      {        
          size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( (nOffset) + NFMClassExtended->private.properties.memProfile->BaseAddr_Settings );
          
          if( FLASH_SUCCESS( flash_read( baseAddr, buffer, nBytesToRead ) ) )
          {
              return nBytesToRead;
          }
      }
  }

  return 0; // failed
}

size_t NFM_ROM_GetDeviceSettingsSize()
{
  extern NFMClassEx_t * NFMClassExtended;
  const sSwitchMemoryProfile_t * memProfile = NFMClassExtended->private.properties.memProfile;
  
  if( NULL != NFMClassExtended->private.properties.memProfile )
  {
      return memProfile->Size_Settings;
  }

  return 0; // failed
}

bool NFM_ROM_ValidateUserSettings()
{
    if( sizeof(sNFMSettingsBlockCrc_t) == NFM_ROM_GetDeviceSettingsSize() )
    {
        sNFMSettingsBlockCrc_t sSettingsBlock;

        if( NFM_ROM_ReadDeviceSettings( (uint8_t*)&sSettingsBlock,
                                       0,
                                       sizeof(sSettingsBlock) ) )
        {
            TCRC crc = ICRC32;
            crc = CRC32( crc, (uint8_t *)&sSettingsBlock.settings, sizeof(sSettingsBlock.settings));
            if(crc != sSettingsBlock.CRCValue)
            {
                return false;
            }
        }
    }
    else 
        return false;
    return true;
}

size_t NFM_ROM_WriteDeviceSettings( uint8_t * buffer, size_t nOffset, size_t nBytesToWrite )
{
  extern NFMClassEx_t * NFMClassExtended;
  const sSwitchMemoryProfile_t * memProfile = NFMClassExtended->private.properties.memProfile;
  
  if( NULL != NFMClassExtended->private.properties.memProfile )
  if( 0 < memProfile->Size_Settings )
  {
      if( (NULL != buffer) && (nOffset < memProfile->Size_Settings) && (0 < nBytesToWrite) )
      {        
          size_t baseAddr = NFMBASE_FLASH_MAKEREALADDRESS( (nOffset) + NFMClassExtended->private.properties.memProfile->BaseAddr_Settings );
          
          if( FLASH_SUCCESS( flash_write( baseAddr, buffer, nBytesToWrite, fwm_safewrite ) ) )
          {
              return nBytesToWrite;
          }
      }
  }

  return 0; // failed
}

//////
//////TECALTCOMPHEADERCRC  * __ROM_GetTermHeader( char * buffer, unsigned int buffersize, unsigned int address )
//////{
//////  if( buffer == NULL || buffersize < sizeof(TECALTCOMPHEADERCRC) ) return NULL;
//////
//////  //read_flash( address, buffer, sizeof(TECALTCOMPHEADERCRC) );
//////  BREAKPOINT;
//////  
//////  return (TECALTCOMPHEADERCRC*)buffer;
//////}
//////
//////// ------------------------------------------------------------------------------                                                              ------
//////
//////TECALTCOMPHEADER * ROM_GetTermHeader( char * buffer, unsigned int buffersize )
//////{
//////  char * recievebuffer = buffer;
//////
//////  //---------------------------------
//////  if( LastReadAddress != ROM_TERM_COMP_ADDR )  // ���� ��������� ����� ������ �� ����� �������� ������ ������
//////          BufferChached = 0;  // ����� ����������� �� ��������������
//////  else
//////          BufferChached = 1; // ����� ����� �������������� ��� ��� ROM SPI 
//////  //---------------------------------
//////  if( recievebuffer == NULL ) {   // ���� ������������ ROMHeaderBuffer
//////          recievebuffer = (char*)&ROMHeaderBuffer; 
//////          buffersize = SPIROMHeaderBufferSize; // !!! �������� ������� ������ ������� ��� �������� TECALTCOMPHEADERCRC !!!
//////          LastReadAddress = ROM_TERM_COMP_ADDR; 
//////  }  
//////  else 
//////  {  BufferChached = 0;  // ������������ ������, ������� ������, �� ����� ROMHeaderBuffer
//////     if( INT(recievebuffer)%sizeof(unsigned int) ) return NULL; // not aligment . 
//////  }
//////  //---------------------------------
//////  /*- RET -*/if( recievebuffer == NULL || buffersize < sizeof(/*CRC*/TECALTCOMPHEADERCRC/*CRC*/) ) return NULL;
//////  //---------------------------------
//////  TECALTCOMPHEADERCRC * hdrcrc;
//////  if( BufferChached != 1 )  hdrcrc = __ROM_GetTermHeader(recievebuffer, buffersize, ROM_TERM_COMP_ADDR);
//////  else                      hdrcrc = (TECALTCOMPHEADERCRC *)recievebuffer; // !!! ������������ ������ ��� � ������ � �������� ������ !!!
//////  //---------------------------------
//////  /*- RET -*/if(hdrcrc == NULL) return NULL;
//////  //---------------------------------
//////  TCRC crc = ICRC32; // �������������� CRC32
//////  //---------------------------------
//////  crc = CRC32( crc, (unsigned char const *)hdrcrc, sizeof(TECALTCOMPHEADER)); 
//////  //---------------------------------
//////  if( crc == hdrcrc->CRCValue ) return (TECALTCOMPHEADER *)hdrcrc;
//////  else 
//////  {  if(BufferChached == 1) // �������� � RAM ����� �����������
//////     { LastReadAddress = 0xffffffff;
//////       return ROM_GetTermHeader( /*!!!*/buffer/*!!!*/, buffersize); // ������ ��� ���, �� ��� �����������
//////     } else return NULL;
//////  }                    
//////  //---------------------------------
//////}
//////
//////// ------------------------------------------------------------------------------
//////char * ROM_GetConnectorString( unsigned int ID )
//////{
//////   if(ID<=12)
//////    return (char*)Connector[ID];
//////   else
//////    return NULL;
//////}
//////
//////
//////TECALDATAHEADERCRC  * __ROM_GetHeader( char * buffer, unsigned int buffersize, unsigned int address )
//////{
//////  if( buffer == NULL || buffersize < sizeof(TECALDATAHEADERCRC) ) return NULL;
//////
//////  flash_read( address, buffer, sizeof(TECALDATAHEADERCRC) );  
//////  
//////  return (TECALDATAHEADERCRC*)buffer;
//////}
//////
//////// -------                                                                 ------
//////
//////TECALDATAHEADER * ROM_GetHeader( char * buffer, unsigned int buffersize, EROMHEADER HeaderID )
//////{
//////  char * recievebuffer = buffer;
//////
//////  if( ! ( HeaderID <= 5 ) ) return NULL;
//////
//////  //---------------------------------
//////  if( LastReadAddress != ROM_MAP[HeaderID] )  // ���� ��������� ����� ������ �� ����� �������� ������ ������
//////          BufferChached = 0;  // ����� ����������� �� ��������������
//////  else
//////          BufferChached = 1; // ����� ����� �������������� ��� ��� ROM SPI 
//////  //---------------------------------
//////  if( recievebuffer == NULL ) {   // ���� ������������ ROMHeaderBuffer
//////          recievebuffer = (char*)&ROMHeaderBuffer; 
//////          buffersize = SPIROMHeaderBufferSize; // !!! �������� ������� ������ ������� ��� �������� TECALDATAHEADERCRC !!!
//////          LastReadAddress = ROM_MAP[HeaderID]; 
//////  }  
//////  else 
//////  {  BufferChached = 0;  // ������������ ������, ������� ������, �� ����� ROMHeaderBuffer
//////     if( INT(recievebuffer)%sizeof(unsigned int) ) return NULL; // not aligment . 
//////  }
//////  //---------------------------------
//////  /*- RET -*/if( recievebuffer == NULL || buffersize < sizeof(/*CRC*/TECALDATAHEADERCRC/*CRC*/) ) return NULL;
//////  //---------------------------------
//////  TECALDATAHEADERCRC * hdrcrc;
//////  if( BufferChached != 1 )  hdrcrc = __ROM_GetHeader(recievebuffer, buffersize, ROM_MAP[HeaderID]);
//////  else                      hdrcrc = (TECALDATAHEADERCRC *)recievebuffer; // !!! ������������ ������ ��� � ������ � �������� ������ !!!
//////  //---------------------------------
//////  /*- RET -*/if(hdrcrc == NULL) return NULL;
//////  //---------------------------------
//////  TCRC crc = ICRC32; // �������������� CRC32
//////  //---------------------------------
//////  crc = CRC32( crc, (unsigned char const *)hdrcrc, sizeof(TECALDATAHEADER)); 
//////  //---------------------------------
//////  if( crc == hdrcrc->CRCValue ) return (TECALDATAHEADER *)hdrcrc;
//////  else 
//////  {  if(BufferChached == 1) // �������� � RAM ����� �����������
//////     { LastReadAddress = 0xffffffff;
//////       return ROM_GetHeader( /*!!!*/buffer/*!!!*/, buffersize, HeaderID); // ������ ��� ���, �� ��� �����������
//////     } else return NULL;
//////  }                    
//////  //---------------------------------
//////}
////////
//////
//////
//////// ######################################################################################################################################
//////// ######################################################################################################################################
//////unsigned int ROM_GetStartAddress( EROMHEADER HeaderID )
//////{
//////  return ROM_MAP[HeaderID] + sizeof(TECALDATAHEADERCRC);
//////}
//////
//////BOOL ROM_GetArray( TGETARRAYIN  * stGetArrayParameters, TGETARRAYOUT * stoutArrayParams  )
//////{
////////      
////////(dwStartAddress)            
////////*----------->|              (CHARACTERIZATION_)
////////             |             /
////////         --->|--------|<--+
////////             |        |   
//////// +-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
//////// |   BLOCK   | BLOCK  |        |        |        |        |        |        |        |        |        |        |
//////// |   HEADER  |  CRC   |  SH_A  |  SH_B  |  OP_A  |  OP_B  |  LD_A  |  LD_B  |  T_11  |  T_21  |  T_12  |  T_22  |
//////// | F/U1/../U5| F/./U5 |        |        |        |        |        |        |        |        |        |        |
//////// +-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
////////                     /          \
////////                    /            \
////////                   /              \
////////                  /                \
////////                 /                  \
////////                /                    \
////////               /                      \
////////              /      -ARRAY-           \
////////             /                          \
////////            +-------+------------+-------+
////////            | mindB |      N     |       |
////////            |       |...POINTS...|  CRC  |
////////            | maxdB |            |ARRAY  |
////////            +-------+------------+-------+
////////         
//////
//////// IN: TGETARRAYIN                         OUT: TGETARRAYOUT
///////*char * buffer;                           
//////  unsigned int buffersize;                 FIRSTPOINT FirstPoint;
//////  // --------------------                  --------------------
//////  unsigned int nMaxPoints;                 unsigned int   dwPointsAddress;       
//////  // ---------------------                 unsigned int   dwArrayCRC;
//////  unsigned int Version;                    void  *        pPoints;
//////  // ---------------------
//////  EPORT port;
//////  ESTATE state;
//////  // ---------------------
//////  unsigned int startaddress;*/
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  if( stGetArrayParameters == NULL || stoutArrayParams == NULL) return NULL;
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  unsigned int ps;
//////  unsigned int as;
//////  unsigned int of/*, rd*/;
//////  unsigned int adr_crc;
//////  unsigned int adr_points;
//////  unsigned int adr_minmax;
//////  char * data = stGetArrayParameters->buffer;
//////
//////  if( (stGetArrayParameters->cFlags & (1<<0)) == 0 ) // get characterization array
//////  {
//////    ps = POINTSIZE;   
///////*
//////    as = CHARACTERIZATION_ARRAY_SIZE(stGetArrayParameters->nMaxPoints,ps);
//////*/ 
//////    as = CHARACTERIZATION_TABLE_SIZE( stGetArrayParameters->nMaxPoints );
//////
//////  } else {                       
//////
//////    as = TERMCOMPENSATION_ARRAY_SIZE(stGetArrayParameters->nMaxPoints ); 
//////
//////    ps = sizeof(struct TEtermPoint); 
//////
//////  }
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  if( stGetArrayParameters->buffer == NULL || stGetArrayParameters->buffersize < ps ) return NULL;
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  // �������� ������������ �������� ������ � ��������� ������
//////  if( !(     ( stGetArrayParameters->state == eSTATE_SHORT ||  
//////               stGetArrayParameters->state == eSTATE_LOAD  ||  
//////               stGetArrayParameters->state == eSTATE_OPEN  ||
//////               stGetArrayParameters->state == eSTATE_T11   ||
//////               stGetArrayParameters->state == eSTATE_T12   ||
//////               stGetArrayParameters->state == eSTATE_T21   ||
//////               stGetArrayParameters->state == eSTATE_T22   ||
//////               stGetArrayParameters->state == eSTATE_LOAD2 ||  
//////               stGetArrayParameters->state == eSTATE_OPEN2 ||
//////               stGetArrayParameters->state == eSTATE_A11   ||
//////               stGetArrayParameters->state == eSTATE_A12   ||
//////               stGetArrayParameters->state == eSTATE_A21   ||
//////               stGetArrayParameters->state == eSTATE_A22   
//////  
//////             ) 
//////             &&
//////             ( stGetArrayParameters->port  == ePORT_A      ||
//////               stGetArrayParameters->port  == ePORT_B      ||
//////               stGetArrayParameters->port  == ePORT_AB     
//////             )
//////       ) 
//////    ) return FALSE;
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  // �������� ������������ �������� ����� (A/B) ��� ���������� SH/LD/OP/LD2/OP2
//////    if(  (   ( stGetArrayParameters->state == eSTATE_SHORT ||  
//////               stGetArrayParameters->state == eSTATE_LOAD  ||  
//////               stGetArrayParameters->state == eSTATE_OPEN  ||
//////               stGetArrayParameters->state == eSTATE_LOAD2 ||  
//////               stGetArrayParameters->state == eSTATE_OPEN2 
//////             ) 
//////             &&
//////             ( stGetArrayParameters->port  != ePORT_A      &&
//////               stGetArrayParameters->port  != ePORT_B      
//////             )
//////         ) 
//////    ) return FALSE;  
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  // �������� ������������ �������� ����� (AB) ��� ���������� T11/T12/T21/T22
//////    if(  (   ( stGetArrayParameters->state == eSTATE_T11   ||
//////               stGetArrayParameters->state == eSTATE_T12   ||
//////               stGetArrayParameters->state == eSTATE_T21   ||
//////               stGetArrayParameters->state == eSTATE_T22     
//////             ) 
//////             &&
//////             ( stGetArrayParameters->port  != ePORT_AB
//////             )
//////       ) 
//////    ) return FALSE;      
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  // �������� ������������ �������� ����� (AB) ��� ���������� A11/A12/A21/A22
//////    if(  (   ( stGetArrayParameters->state == eSTATE_A11   ||
//////               stGetArrayParameters->state == eSTATE_A12   ||
//////               stGetArrayParameters->state == eSTATE_A21   ||
//////               stGetArrayParameters->state == eSTATE_A22     
//////             ) 
//////             &&
//////             ( stGetArrayParameters->port  != ePORT_AB
//////             )
//////       ) 
//////    ) return FALSE;     
//////  //---------------------------------------------------------------------------------------------------------------------------------------
//////  // ���������� ������ �������
//////
//////if(  (stGetArrayParameters->cFlags & (1<<0)) == 0 ) // get characterization array
//////{                 
//////
//////      // *============================ ������ �������������� ==================================   
//////
//////              // ���� ������� SH,OP,LD. �� ��� ����� � ������� SH * 2, OP * 2, LD * 2.
//////              // ������ A ���� ������ B       SHA,SHB,OPA,OPB,LDA,LDB
//////              if( stGetArrayParameters->state == eSTATE_SHORT ||  stGetArrayParameters->state == eSTATE_LOAD ||  stGetArrayParameters->state == eSTATE_OPEN )
//////              {
//////                if( stGetArrayParameters->state == eSTATE_SHORT ) of  = 0;
//////                if( stGetArrayParameters->state == eSTATE_OPEN  ) of  = 2;
//////                if( stGetArrayParameters->state == eSTATE_LOAD  ) of  = 4;  
//////            
//////                if( stGetArrayParameters->port ==  ePORT_A      ) of += 0;
//////                if( stGetArrayParameters->port ==  ePORT_B      ) of += 1;
//////            
//////              } else 
//////              if( stGetArrayParameters->state == eSTATE_T11 ||  stGetArrayParameters->state == eSTATE_T12 ||  stGetArrayParameters->state == eSTATE_T21 ||  stGetArrayParameters->state == eSTATE_T22)
//////              {                                                  
//////                                                                 of  = 6;
//////                if( stGetArrayParameters->state == eSTATE_T11  ) of += 0;
//////                if( stGetArrayParameters->state == eSTATE_T21  ) of += 1;
//////                if( stGetArrayParameters->state == eSTATE_T12  ) of += 2;
//////                if( stGetArrayParameters->state == eSTATE_T22  ) of += 3;
//////              }    
//////              else 
//////              if( stGetArrayParameters->state == eSTATE_A11 ||  stGetArrayParameters->state == eSTATE_A12 ||  stGetArrayParameters->state == eSTATE_A21 ||  stGetArrayParameters->state == eSTATE_A22)
//////              {                                                  
//////                                                                 of  = 10;
//////                if( stGetArrayParameters->state == eSTATE_A11  ) of += 0;
//////                if( stGetArrayParameters->state == eSTATE_A21  ) of += 1;
//////                if( stGetArrayParameters->state == eSTATE_A12  ) of += 2;
//////                if( stGetArrayParameters->state == eSTATE_A22  ) of += 3;    
//////            
//////              }  
//////              else 
//////              if( stGetArrayParameters->state == eSTATE_LOAD2 ||  stGetArrayParameters->state == eSTATE_OPEN2 )
//////              {                                                  
//////                                                                   of  =14; /*28*/
//////                if( stGetArrayParameters->state == eSTATE_LOAD2  ) of += 0;
//////                if( stGetArrayParameters->state == eSTATE_OPEN2  ) of += 2; /*4*/
//////            
//////                if( stGetArrayParameters->port ==  ePORT_A      )  of += 0;
//////                if( stGetArrayParameters->port ==  ePORT_B      )  of += 1; /*2*/ 
//////                /*                                                             ��� �� �� ����������������, ��� ��� PHASE
//////                if( stGetArrayParameters->tca_type ==  eTCA_MAGN  ) of += 0;
//////                if( stGetArrayParameters->tca_type ==  eTCA_PHASE ) of += 1;*/
//////              }  
////// 
//////      // *====================================================================================
//////
//////} else /// get termo compensation array
//////{
////////                     +---------+------------+-------+
////////                     |  minRAD |      N     |       |
////////                     | ------- |...POINTS...|  CRC  |
////////                     |  maxRAD |            | ARRAY |
////////                     +---------+------------+-------+
////////                     \                             /
////////                      \                           /
////////                       \                         /                                                                                                                                                                                                                                  
////////                        \                       /                                                                                                                                                                                                                                   
////////                         \   - PHASE ARRAY -   /                                                                                                                                                                                                                                    
////////                          \                   /                                                                                                                                                                                                                                     
////////                           \                 /                                                                                                                                                                                                                                      
////////                            \               /
////////                             \             /
////////                              \           /
////////                               \         /
//////// +-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
//////// |   BLOCK   | TERMO  |    0   |    1   |    2   |    3   |    4   |    5   |    6   |    7   |    8   |    9   |   10   |   11   |   12   |   13   |   14   |   15   |   16   |   17   |   18   |   19   |   20   |   21   |   22   |   23   |   24   |   25   |   26   |   27   |   28   |   29   |   30   |   31   |   32   |   33   |   34   |   35   |
//////// |   HEADER  | COMPEN |  SH_A  |  SH_A  |  SH_B  |  SH_B  |  OP_A  |  OP_A  |  OP_B  |  OP_B  |  LD_A  |  LD_A  |  LD_B  |  LD_B  |  T_11  |  T_11  |  T_21  |  T_21  |  T_12  |  T_12  |  T_22  |  T_22  |  A_11  |  A_11  |  A_21  |  A_21  |  A_12  |  A_12  |  A_22  |  A_22  |  LD2A  |  LD2A  |  LD2B  |  LD2B  |  OP_A  |  OP_A  |  OP_B  |  OP_B  |
//////// | TERMOCOMP |  CRC   | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  | MAGN   | PHASE  |
//////// +-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
////////                     /          \
////////                    /            \
////////                   /              \
////////                  /                \
////////                 /                  \
////////                /                    \
////////               /                      \
////////              /  - MAGNITUDE ARRAY -   \
////////             /                          \
////////            +-------+------------+-------+
////////            | mindB |      N     |       |
////////            | ----- |...POINTS...|  CRC  |
////////            | maxdB |            |ARRAY  |
////////            +-------+------------+-------+                                                     
//////
//////
//////  // * ============================ ������ ���������������� =====================================         
//////
//////  if( stGetArrayParameters->state == eSTATE_SHORT ||  stGetArrayParameters->state == eSTATE_LOAD ||  stGetArrayParameters->state == eSTATE_OPEN ||  stGetArrayParameters->state == eSTATE_LOAD2 ||  stGetArrayParameters->state == eSTATE_OPEN2 )
//////  {
//////    if( stGetArrayParameters->state == eSTATE_SHORT ) of  = 0;
//////    if( stGetArrayParameters->state == eSTATE_OPEN  ) of  = 4;
//////    if( stGetArrayParameters->state == eSTATE_LOAD  ) of  = 8;  
//////
//////    if( stGetArrayParameters->state == eSTATE_OPEN2 ) of  = 32;
//////    if( stGetArrayParameters->state == eSTATE_LOAD2 ) of  = 28; 
//////
//////    if( stGetArrayParameters->port ==  ePORT_A      ) of += 0;
//////    if( stGetArrayParameters->port ==  ePORT_B      ) of += 2; 
//////
//////    if( stGetArrayParameters->tca_type ==  eTCA_MAGN  ) of += 0;
//////    if( stGetArrayParameters->tca_type ==  eTCA_PHASE ) of += 1;
//////
//////  } else 
//////  if( stGetArrayParameters->state == eSTATE_T11 ||  stGetArrayParameters->state == eSTATE_T12 ||  stGetArrayParameters->state == eSTATE_T21 ||  stGetArrayParameters->state == eSTATE_T22 
//////      ||
//////      stGetArrayParameters->state == eSTATE_A11 ||  stGetArrayParameters->state == eSTATE_A12 ||  stGetArrayParameters->state == eSTATE_A21 ||  stGetArrayParameters->state == eSTATE_A22 )
//////  {                                                  
//////                                                     of  = 12;  
//////
//////    if( stGetArrayParameters->state == eSTATE_T11  ) of += 0;
//////    if( stGetArrayParameters->state == eSTATE_T21  ) of += 2;
//////    if( stGetArrayParameters->state == eSTATE_T12  ) of += 4;
//////    if( stGetArrayParameters->state == eSTATE_T22  ) of += 6;  
//////
//////    if( stGetArrayParameters->state == eSTATE_A11  ) of += 8;
//////    if( stGetArrayParameters->state == eSTATE_A21  ) of += 10;
//////    if( stGetArrayParameters->state == eSTATE_A12  ) of += 12;
//////    if( stGetArrayParameters->state == eSTATE_A22  ) of += 14;
//////
//////    if( stGetArrayParameters->tca_type ==  eTCA_MAGN  ) of += 0;
//////    if( stGetArrayParameters->tca_type ==  eTCA_PHASE ) of += 1;
////// 
//////  }   
//////
//////  // * ====================================================================================
//////
//////}
//////  // ------------------------------
//////  // of �������� � ������� �������
//////  of *= as;
//////  // of �������� � ������
//////  // ------------------------------
//////
//////  // -----------------------------------------------------
//////  // ���������� � of ��������� ����� ������ �������� 
//////  // (����� ����� ��������� ������ FACT / US1 / ... / US5)
//////  of += stGetArrayParameters->dwStartAddress;
//////  // -----------------------------------------------------
//////  //
//////    adr_minmax = of;
//////    adr_points = adr_minmax + sizeof(FIRSTPOINT);
//////    adr_crc    = adr_points + stGetArrayParameters->nMaxPoints * ps;  
//////    stoutArrayParams->dwPointsAddress = adr_points;
//////  //  
//////  // -----------------------------------------------
//////  // of ��������� �� ������ ������� (����� min/max )
//////  // -----------------------------------------------
//////  //read_flash( adr_minmax, (char*)&stoutArrayParams->FirstPoint, sizeof(FIRSTPOINT)  ); // ������ FirstPoint (MindB / MaxdB)
//////  //read_flash( adr_crc   , (char*)&stoutArrayParams->dwArrayCRC, sizeof(unsigned int)); // ������ CRC
//////  BREAKPOINT;
//////  // -----------------------------------------------
//////  (void)(adr_crc);
//////
//////  // -----------------------------------------------
//////  TCRC crc = ICRC32; // �������������� CRC32
//////  unsigned int maxread = stGetArrayParameters->buffersize - stGetArrayParameters->buffersize%ps;
//////  unsigned int pointsbytes = as - sizeof(unsigned int); //-crc
//////  unsigned int bytes = maxread;       
//////  // -----------------------------------------------
//////  unsigned int address = adr_minmax;
//////  unsigned int readcnt = 0;
//////
//////  while(readcnt < pointsbytes)
//////  {
//////     bytes = pointsbytes - readcnt;
//////     if(bytes > maxread) bytes = maxread;
//////     
//////     //read_flash( address, (char*)data, bytes ); 
//////     BREAKPOINT;
//////
//////     crc =  CRC32( crc, (unsigned char const *)data, bytes);
//////
//////     address    += bytes;
//////     readcnt    += bytes;
//////  }//0xA9D5BE5A
//////  // -----------------------------------------------
//////  if((stoutArrayParams->dwArrayCRC != crc)) stoutArrayParams->dwPointsAddress = 0;
//////  // -----------------------------------------------
//////  return (stoutArrayParams->dwArrayCRC==crc)?(TRUE):(FALSE);
//////}
//////// ######################################################################################################################################
//////// ######################################################################################################################################
//////// -------------------------------------------------------------------------------------------------------------
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////
//////TECALPOINT2 * ROM_ReadPoints( char * buffer, unsigned int buffersize, unsigned int address, unsigned int length )
//////{
//////  if( length > buffersize || buffer == NULL ) return NULL;
//////
//////  //read_flash( address, buffer, length );
//////  BREAKPOINT;
//////
//////  return (TECALPOINT2 *)buffer;
//////}
//////// ------------------------------------------------------------------------------
///////*
//////TECALPOINT * ROM_GetPoints( char * buffer, unsigned int buffersize, EROMHEADER HeaderID, unsigned int dwPointsStart, unsigned int dwPointsCount )
//////{
//////
//////  TECALPOINT * pPoints;
//////  char * recievebuffer = buffer;
//////  if( ! ( HeaderID >= 0 && HeaderID <= 5 ) ) return NULL;
//////  //---------------------------------
//////  unsigned int address;
//////            if(address > MAX_POINTS_MEMORY_SECTOR) return NULL;
//////               address+= ROM_MAP[HeaderID];
//////  //---------------------------------
//////  if( LastReadAddress != address )  // ���� ��������� ����� ������ �� ����� �������� ������ ������
//////          BufferChached = 0;  // ����� ����������� �� ��������������
//////  else
//////          BufferChached = 1; // ����� ����� �������������� ��� ��� ROM SPI 
//////  //---------------------------------
//////  if( recievebuffer == NULL ) {   // ���� ������������ ROMHeaderBuffer
//////          recievebuffer = (char*)&ROMHeaderBuffer; 
//////          buffersize = SPIROMHeaderBufferSize; // !!! �������� ������� ������ ������� ��� �������� TECALDATAHEADERCRC !!!
//////          LastReadAddress = address; 
//////  }  
//////  else 
//////  {  
//////         BufferChached = 0;  // ������������ ������, ������� ������, �� ����� ROMHeaderBuffer 
//////         if( INT(recievebuffer)%sizeof(unsigned int) ) return NULL; // not aligment . 
//////  }
//////  //---------------------------------
//////  if( dwPointsCount > buffersize / sizeof(TECALPOINT) ) return NULL;
//////  //---------------------------------
//////  if( BufferChached != 1 )  pPoints = ROM_ReadPoints( recievebuffer, buffersize, address, dwPointsCount*sizeof(TECALPOINT)); 
//////  else                      pPoints = (TECALPOINT *)recievebuffer; // !!! ������������ ������ ��� � ������ � �������� ������ !!!
////// 
////// return pPoints;
//////}  
//////// ------------------------------------------------------------------------------
//////*/