atpte.c

free sources for gsm

   ParameterStructInit(paramArray, 1);
   result = ParseForNOptIntAndString( paramStrPtr, 1, paramArray, &nFinal );

   if((result != DIDIT) || (nFinal > 1))
      return AT_ECMDERROR;

   if(paramArray[0].ParamType != ATCMD_PARAMTYPE_STRING)
      return AT_ECMDERROR;

   
   GSMsprintf( str, "%s", paramArray[0].String.Buffer);

   for( i = 0; i < (sizeof(nvm_offset_size)/sizeof(NVM_ACCESS_DATA)) ; i++ )
   {  
      if ( GSMstrcmp( str, nvm_offset_size[i].name ) == 0 )
      {
         GSMsprintf( str2,"%s:%d,%d",nvm_offset_size[i].name,
                                     nvm_offset_size[i].offset,
                                     nvm_offset_size[i].size);

         NVM_Read( nvm_offset_size[i].offset, nvm_offset_size[i].size, buff );

         GSMstrcpy(buff2,"data:");

         for( j = 0 ; j < nvm_offset_size[i].size ; j++ )
         {
            GSMsprintf( hexstr,"%02xh ", ( UINT8 )buff[j] );
            GSMstrcat( buff2, hexstr );
         }

         GSMstrcat( str2 ,buff2 );
         
         ATSendReply( str2 );

         break;
         }
      }

   return DIDIT;
}

/*- Local Functions ---------------------------------------------------------  */
/* Command for MMI NVM Contents
/* Name: HndlATsMMINVMCONTENTS                                                                                           
/* Type: Set
/* Using : AT+MMINVMCONTENTS="<Field Name>"
/* Desc : MMINVMCONTENTS俊 措茄 蔼 技泼 
/* Returns: OK or ERROR
/* ------------------------------------------------------------------------*/
ATCMD_RESULT HndlATsMMINVMCONTENTS(INT8* paramStrPtr)
{
   INT8  i;
   INT8 *str = ( INT8 * ) GSMMalloc( 256 );
   INT8 *buff = ( UINT8 * ) GSMMalloc( 256 );
   UINT8  nFinal;
   ATCMD_RESULT result;
   PARAMETER_RECORD paramArray[64];

   ParameterStructInit(paramArray, 64);
   result = ParseForNOptIntAndString( paramStrPtr, 64, paramArray, &nFinal );

   if((paramArray[0].ParamType != ATCMD_PARAMTYPE_STRING) ||( nFinal <= 1))
      return AT_ECMDERROR;
   
   GSMsprintf( str, "%s", paramArray[0].String.Buffer);

   for ( i = 0; i < nFinal - 1; i++ )
      {
      buff[i] = paramArray[i+1].Value;
      }

   for( i = 0 ; i < (sizeof(nvm_offset_size)/sizeof(NVM_ACCESS_DATA)) ; i++ )
      {  
      if ( GSMstrcmp( str, nvm_offset_size[i].name ) == 0 )
         {
         NVM_Write( nvm_offset_size[i].offset, nvm_offset_size[i].size, buff );  /* Get Ring Volume */
         break;
         }
      }

   GSMFree( str );
   GSMFree( buff );

//   ATSendReply("SetMmiNVMContents:DONE");
   return DIDIT;
}

/*- Local Functions ---------------------------------------------------------  */
/* Command for MS Personal
/* Name: HndlATrMSPERSONAL                                                                                           
/* Type: Read
/* Using : AT+MSPERSONAL?
/* Desc : HndlATsMSPERSONAL俊 技泼等 蔼阑 焊咯霖促. 
/* Returns: OK or ERROR
/* Note :
/* ------------------------------------------------------------------------*/
ATCMD_RESULT HndlATrMSPERSONAL(void)
{
   UINT8 i,j;
   INT8 hexstr[10];
   //INT8 *buff = ( UINT8 * ) GSMMalloc( sizeof( NVM_MsPersonal_t ) );
   INT8 *str = ( INT8 * ) GSMMalloc( 125 );

   union local_MsPersonal_t{
   INT8  buff[sizeof( NVM_MsPersonal_t )];
   NVM_MsPersonal_t MsPersonal;
   }l_MsPersonal_t;

   NVM_Read( E2P_MS_PERSONAL, l_MsPersonal_t.buff );

   GSMsprintf( str,"TestPattern:%04xh ", l_MsPersonal_t.MsPersonal.TestPattern );
   ATSendReply( str );

   GSMsprintf( str,"LevelOfLock:%02xh ", l_MsPersonal_t.MsPersonal.LevelOfLock );
   ATSendReply( str );

   GSMsprintf( str,"SPCode:%02xh ", l_MsPersonal_t.MsPersonal.SPCode );
   ATSendReply( str );

   GSMsprintf( str,"ImsiMask[%d]:", sizeof( l_MsPersonal_t.MsPersonal.ImsiMask ) );
   for( i = 0 ; i < sizeof( l_MsPersonal_t.MsPersonal.ImsiMask ) ; i++ )
      {
      GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.ImsiMask[i] );
      GSMstrcat( str, hexstr );
      }
   ATSendReply( str );

   GSMsprintf( str,"PCK %08xh ", l_MsPersonal_t.MsPersonal.PCK.Pwd );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.PCK.Attempts );
   GSMstrcat( str, hexstr );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.PCK.MaxAttempts );
   GSMstrcat( str, hexstr );
   ATSendReply( str );

   GSMsprintf( str,"NCK %08xh ", l_MsPersonal_t.MsPersonal.NCK.Pwd );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.NCK.Attempts );
   GSMstrcat( str, hexstr );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.NCK.MaxAttempts );
   GSMstrcat( str, hexstr );
   ATSendReply( str );

   GSMsprintf( str,"SCK %08xh ", l_MsPersonal_t.MsPersonal.SCK.Pwd );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.SCK.Attempts );
   GSMstrcat( str, hexstr );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.SCK.MaxAttempts );
   GSMstrcat( str, hexstr );
   ATSendReply( str );

   GSMsprintf( str,"SPCK %08xh ", l_MsPersonal_t.MsPersonal.SPCK.Pwd );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.SPCK.Attempts );
   GSMstrcat( str, hexstr );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.SPCK.MaxAttempts );
   GSMstrcat( str, hexstr );
   ATSendReply( str );

   GSMsprintf( str,"MCK %08xh ", l_MsPersonal_t.MsPersonal.MCK.Pwd );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.MCK.Attempts );
   GSMstrcat( str, hexstr );
   GSMsprintf( hexstr,"%02xh ", l_MsPersonal_t.MsPersonal.MCK.MaxAttempts );
   GSMstrcat( str, hexstr );
   ATSendReply( str );

   for( i = 0 ; i < sizeof( NVM_MsPersonal_t ) ; i++ )
      {
      GSMstrcpy(str,"data:");
      j = 0;
      while( j < 10 && i < sizeof( NVM_MsPersonal_t ) )
         {
         GSMsprintf(hexstr,"%02xh ", ( UINT8 )l_MsPersonal_t.buff[i] );
         GSMstrcat( str, hexstr );
         j++;
         i++;
         }
         i--;
         ATSendReply( str );
      }
   GSMFree( str );

   return DIDIT;
}
   
/*- Local Functions ---------------------------------------------------------  */
/* Command for MS Personal
/* Name: HndlATsMSPERSONAL                                                                                           
/* Type: Set
/* Using : AT+MSPERSONAL= <value>
/* Desc : MSPERSONAL俊 措茄 蔼 技泼 
/* Returns: OK or ERROR
/* Note : 蔼阑 茄锅俊 弥措 10俺父 技泼 啊瓷 
/* ------------------------------------------------------------------------*/
ATCMD_RESULT HndlATsMSPERSONAL(INT8* paramStrPtr)
{
   UINT16 i,j;
   UINT16 calTableSize = 60;
   INT8 *buff = ( UINT8 * ) GSMMalloc( sizeof(NVM_MsPersonal_t) );
   INT8 *str = ( INT8 * ) GSMMalloc( 256 );
   UINT8  nFinal, addr[10], data[10];
   CHAR  temp[10];
   ATCMD_RESULT result;
   PARAMETER_RECORD paramArray[20];

   ParameterStructInit(paramArray, 20);
   result = ParseForNOptIntAndString( paramStrPtr, 20, paramArray, &nFinal );

   if((result != DIDIT) || (nFinal > 20))
      return AT_ECMDERROR;

   for(j=0; j < nFinal ; j += 2)
   {
      if(paramArray[j].ParamType != ATCMD_PARAMTYPE_NUMERIC)
         return AT_ECMDERROR;
      if(paramArray[j+1].ParamType != ATCMD_PARAMTYPE_STRING)
         return AT_ECMDERROR;
   }
   
   /* Check all indices given are in range */
   for ( i = 0; i < sizeof(NvmAccessElemArray); i += 2 )
      {
      if ( NvmAccessElemArray[i] != 0xFF && NvmAccessElemArray[i] > calTableSize )
         {
         ATSendReply( "SetGainCalTableEl:WRONG:INVALID_INPUT_INDEX" );
         return AT_ECMDERROR;
         }
      }

   GSMmemset(addr, 0x00, 10);
   GSMmemset(data, 0x00, 10);

   for(i=0, j = 0; i < nFinal; i += 2, j++)
   {
      addr[j] = paramArray[i].Value;
      GSMmemset(temp, 0x00, 10);
      GSMmemcpy(temp, paramArray[i+1].String.Buffer, paramArray[i+1].String.Len);
      data[j] = (UINT8)CTAsciiToINT32(temp);
   }

   i = 0, j = 0;

   NVM_Read(E2P_MS_PERSONAL,buff);
/*
   while ( NvmAccessElemArray[i] != 0xFF && i < sizeof(NvmAccessElemArray)  && j < nFinal)
      {
      buff[NvmAccessElemArray[i]] = data[j++];
      i++;
      i++;
      }
*/
   while(i < nFinal / 2)
   {
      buff[addr[i]] = data[i];
      i++;
   }
   
   NVM_Write(E2P_MS_PERSONAL,buff);

   GSMmemset( &NvmAccessElemArray[0], 0xFF, sizeof(NvmAccessElemArray) );   /* Reseting the values of the array. */
   GSMFree( buff );

   return DIDIT;
}


/*- Local Functions ---------------------------------------------------------  */
/* Command for Set Time
/* Name: HndlATrTIME                                                                                          
/* Type: Read
/* Using : AT+SETTIME?
/* Desc : Time 蔼阑 焊咯霖促.
/* Returns: OK or ERROR
/* Note :
/* ------------------------------------------------------------------------*/
ATCMD_RESULT HndlATrTIME(void)
{
   UINT8 i;
   UHDateTime *TheTimebuff = GSMMalloc( sizeof( UHDateTime ) );
   INT8 *str0 = ( INT8 * ) GSMMalloc( 125 );
   INT8 *str1 = ( INT8 * ) GSMMalloc( 125 );
   UINT8 *pTimeStruct;

   pTimeStruct = (UINT8 *)TheTimebuff;

   UHGetTime( (UHDateTime *)TheTimebuff );

   GSMsprintf(str0,"hour:%d", TheTimebuff->hour);
   ATSendReply(str0);
   GSMsprintf(str0,"min:%d", TheTimebuff->min);
   ATSendReply(str0);
   GSMsprintf(str0,"sec:%d", TheTimebuff->sec);
   ATSendReply(str0);
   GSMsprintf(str0,"day:%d", TheTimebuff->day);
   ATSendReply(str0);
   GSMsprintf(str0,"dayofweek:%d", TheTimebuff->dayofweek);
   ATSendReply(str0);
   GSMsprintf(str0,"month:%d", TheTimebuff->month);
   ATSendReply(str0);
   GSMsprintf(str0,"year:%d", TheTimebuff->year);
   ATSendReply(str0);

   GSMstrcpy(str0,"data:");
   for( i=0; i<sizeof( UHDateTime ); i++)
   {
      GSMsprintf(str1,"%d ",pTimeStruct[i]);
      GSMstrcat(str0,str1);
   }
   ATSendReply(str0);

   GSMFree( TheTimebuff );
   GSMFree( str0 );
   GSMFree( str1 );

   //ATSendReply( "GetTime:DONE" );

   return DIDIT;
}

/*- Local Functions ---------------------------------------------------------  */
/* Command for Set Time
/* Name: HndlATsTIME                                                                                          
/* Type: Set
/* Using : AT+SETTIME=<Hour>,<min>,<sec>,<day>,<dayofweek>,<month>,<year>
/* Desc : Time 蔼阑 技泼茄促.
/* Returns: OK or ERROR
/* Note :
/* ------------------------------------------------------------------------*/
ATCMD_RESULT HndlATsTIME(INT8* paramStrPtr)
{
   UINT16 i;
   INT8 *str = ( INT8 * ) GSMMalloc( 40 );
//   UINT8 *buff = ( UINT8 * ) GSMMalloc( 100 );
   UHDateTime data;
   UINT8  nFinal;
   ATCMD_RESULT result;
   PARAMETER_RECORD paramArray[7];

   ParameterStructInit(paramArray, 7);
   result = ParseForNOptIntAndString( paramStrPtr, 7, paramArray, &nFinal );

   if(result != DIDIT)
      return AT_ECMDERROR;

/*
   for ( i = 0; i< nFinal; i++ )
      {
      buff[i] = (UINT8)paramArray[i].Value;
      }
*/

   data.hour = paramArray[0].Value;
   data.min = paramArray[1].Value;
   data.sec = paramArray[2].Value;
   data.day = paramArray[3].Value;
   data.dayofweek = paramArray[4].Value;
   data.month = paramArray[5].Value;
   data.year = paramArray[6].Value;
   
   /* data check */
   if(0)
   {
      ATSendReply( "Unknown Time Data format" );
      return AT_ECMDERROR;
   }

//   UHSetTime( (UHDateTime *)buff );
   UHSetTime(&data);

   GSMFree( str );
//   GSMFree( buff );

   return DIDIT;
}

/*- Local Functions ---------------------------------------------------------  */
/* Command for SecListCalData
/* Name: HndlATsSECLISTCALDATA                                                                                         
/* Type: Set
/* Using : AT+SECLISTCALDATA = vlaue
/* Desc : 
/* Returns: OK or ERROR
/* Note : value 狼 蔼捞 1牢 版快俊 悼累茄促. 
/* ------------------------------------------------------------------------*/
ATCMD_RESULT HndlATsSECLISTCALDATA(INT8* paramStrPtr)
{
#if !defined (SILABS_RF)
   INT8 *str = ( INT8 * ) GSMMalloc( 512 );
   INT8 *str_temp = ( INT8 * ) GSMMalloc( 512 );
   INT16 i;
   _RF_RAMP_CONFIG_S *TxConfigRampData;

   union RxGainTable{
   INT8  Hw_Rf_Gain_Cal_Table[60];
   _RF_GAIN_CAL_S  rf_gain_cal_s;
   }local_rx_gain_cal_val;

   UINT8 battlevel[8];
   UINT8  nFinal;
   ATCMD_RESULT result;
   PARAMETER_RECORD paramArray[1];