/**
* @brief Manages the Warm and Cold Reset and get the Answer to Reset from ICC
* @param uint8_t voltage required by host
* @retval None
*/
void SC_AnswerToReset (uint8_t voltage)
{
SCState = SC_POWER_ON;
SC_ADPU.Header.CLA = 0x00;
SC_ADPU.Header.INS = SC_GET_A2R;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
/* Power ON the card */
SC_PowerCmd(ENABLE);
/* Configure the Voltage, Even if IO is still not configured */
SC_VoltageConfig(voltage);
while ((SCState != SC_ACTIVE_ON_T0) && (SCState != SC_NO_INIT))
{ /* If Either The Card has become Active or Become De-Active */
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
if (SCState == SC_ACTIVE_ON_T0)
{
SC_UpdateParams();
/* Apply the Procedure Type Selection (PTS) */
SC_PTSConfig();
SC_SaveVoltage(voltage); /* Save Voltage for Future use */
}
/* Inserts delay(400ms) for Smartcard clock resynchronization */
Delay(400);
}
/**
* @brief SC_SetParams
* Set the parameters for CCID/USART interface
* @param Protocol0_DataStructure_t* pPtr: pointer to buffer containing the
* parameters to be set in USART
* @retval uint8_t status value
*/
uint8_t SC_SetParams (Protocol0_DataStructure_t* pPtr)
{
uint16_t guardTime; /* Keep it 16b for handling 8b additions */
uint32_t fi_new;
uint32_t di_new;
guardTime = pPtr->bGuardTimeT0;
if (guardTime > MAX_EXTRA_GUARD_TIME )
{
return SLOTERROR_BAD_GUARDTIME;
}
fi_new = pPtr->bmFindexDindex;
di_new = pPtr->bmFindexDindex;
/* Check for the FIDI Value set by Host */
di_new &= (uint8_t)0x0F;
if (SC_GetDTableValue(di_new) == 0)
{
return SLOTERROR_BAD_FIDI;
}
fi_new >>= 4;
fi_new &= (uint8_t)0x0F;
if ( SC_GetDTableValue(fi_new) == 0)
{
return SLOTERROR_BAD_FIDI;
}
/* Put Total GuardTime in USART Settings */
USART_SetGuardTime(SC_USART, (uint8_t)(guardTime + DEFAULT_EXTRA_GUARDTIME) );
/* Save Extra GuardTime Value */
Protocol0_DataStructure.bGuardTimeT0 = guardTime;
Protocol0_DataStructure.bmTCCKST0 = pPtr->bmTCCKST0;
Protocol0_DataStructure.bClockStop = pPtr->bClockStop;
/* Save New bmFindexDindex */
SC_Param.SC_hostFiDi = pPtr->bmFindexDindex;
SC_PTSConfig();
Protocol0_DataStructure.bmFindexDindex = pPtr->bmFindexDindex;
return SLOT_NO_ERROR;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
SC_State SCState = SC_POWER_OFF;
/* Setup SysTick Timer for 1 msec interrupts */
SysTick_Config(SystemCoreClock / 1000);
/* Initialize LEDs available on STM324xG-EVAL board *************************/
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Configure Smartcard Interface GPIO pins */
SC_IOConfig();
/*-------------------------------- Idle task ---------------------------------*/
while(1)
{
/* Loop while no Smartcard is detected */
while(CardInserted == 0)
{
}
/* Start SC Demo ---------------------------------------------------------*/
/* Wait A2R --------------------------------------------------------------*/
SCState = SC_POWER_ON;
SC_ADPU.Header.CLA = 0x00;
SC_ADPU.Header.INS = SC_GET_A2R;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
while(SCState != SC_ACTIVE_ON_T0)
{
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Apply the Procedure Type Selection (PTS) */
SC_PTSConfig();
/* Inserts delay(400ms) for Smartcard clock resynchronisation */
Delay(400);
/* Select MF -------------------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = MasterRoot[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
/* Get Response on MF ----------------------------------------------------*/
if(SC_Responce.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Responce.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Select ICCID ----------------------------------------------------------*/
if(((SC_Responce.SW1 << 8) | (SC_Responce.SW2)) == SC_OP_TERMINATED)
{
/* Check if the CHV1 is enabled */
if((SC_Responce.Data[13] & 0x80) == 0x00)
{
CHV1Status = 0x01;
}
/* Send APDU Command for ICCID selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = ICCID[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Read Binary in ICCID --------------------------------------------------*/
if(SC_Responce.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 10;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Select GSMDir ---------------------------------------------------------*/
if(((SC_Responce.SW1 << 8) | (SC_Responce.SW2)) == SC_OP_TERMINATED)
{
/* Copy the ICCID File content into ICCID_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
ICCID_Content[i] = SC_Responce.Data[i];
}
/* Send APDU Command for GSMDir selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = GSMDir[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Select IMSI -----------------------------------------------------------*/
if(SC_Responce.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = IMSI[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Get Response on IMSI File ---------------------------------------------*/
if(SC_Responce.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Responce.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(CHV1Status == 0x00)
{
if(((SC_Responce.SW1 << 8) | (SC_Responce.SW2)) == SC_OP_TERMINATED)
{
/* Enable CHV1 (PIN1) ------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_ENABLE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
}
else
{
if(((SC_Responce.SW1 << 8) | (SC_Responce.SW2)) == SC_OP_TERMINATED)
{
/* Verify CHV1 (PIN1) ------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_VERIFY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(((SC_Responce.SW1 << 8) | (SC_Responce.SW2)) == SC_OP_TERMINATED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 9;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
}
if(((SC_Responce.SW1 << 8) | (SC_Responce.SW2)) == SC_OP_TERMINATED)
{
/* Copy the IMSI File content into IMSI_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
IMSI_Content[i] = SC_Responce.Data[i];
}
}
/* Disable the Smartcard interface */
SCState = SC_POWER_OFF;
SC_Handler(&SCState, &SC_ADPU, &SC_Responce);
CardInserted = 0;
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F103xG HAL library initialization:
- Configure the Flash prefetch
- Systick timer is configured by default as source of time base, but user
can eventually implement his proper time base source (a general purpose
timer for example or other time source), keeping in mind that Time base
duration should be kept 1ms since PPP_TIMEOUT_VALUEs are defined and
handled in milliseconds basis.
- Set NVIC Group Priority to 4
- Low Level Initialization
*/
HAL_Init();
/* Configure the system clock to 72 MHz */
SystemClock_Config();
/* Initialize LEDs *************************/
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
#if defined(HAL_UART_MODULE_ENABLED)
UART_Config();
#endif /* HAL_UART_MODULE_ENABLED */
SC_State SCState = SC_POWER_OFF;
/* Configure Smartcard Interface GPIO pins */
SC_IOConfig();
/*-------------------------------- Idle task ---------------------------------*/
while(1)
{
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- Waiting for card insertion -- (LED1 blinking) \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Loop while no Smartcard is detected */
while(CardInserted == 0)
{
BSP_LED_Toggle(LED1);
HAL_Delay(200);
}
BSP_LED_On(LED1);
/* Start SC Demo ---------------------------------------------------------*/
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- Card inserted -- (All LEDs On) \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Wait A2R --------------------------------------------------------------*/
SCState = SC_POWER_ON;
SC_ADPU.Header.CLA = 0x00;
SC_ADPU.Header.INS = SC_GET_A2R;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
while(SCState != SC_ACTIVE_ON_T0)
{
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- Card powered ON : ATR received -- \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Apply the Procedure Type Selection (PTS) */
SC_PTSConfig();
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- PTS procedure performed -- \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Inserts delay(400ms) for Smartcard clock resynchronisation */
HAL_Delay(400);
/* Select MF -------------------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = MasterRoot[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### SELECT MF ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Get Response on MF ----------------------------------------------------*/
if(SC_Response.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Response.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### GET RESPONSE ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Select ICCID ----------------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Check if the CHV1 is enabled */
if((SC_Response.Data[13] & 0x80) == 0x00)
{
CHV1Status = 0x01;
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- CHV1 is enabled -- \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
}
else
{
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- CHV1 is disabled -- \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
}
/* Send APDU Command for ICCID selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = ICCID[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### SELECT EF ICCID ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
}
/* Read Binary in ICCID --------------------------------------------------*/
if(SC_Response.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 10;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### READ BINARY (ICCID) ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Select GSMDir ---------------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Copy the ICCID File content into ICCID_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
ICCID_Content[i] = SC_Response.Data[i];
}
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ICCID Value = ");
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
printf("%x ",ICCID_Content[i]);
}
printf("\n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Send APDU Command for GSMDir selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = GSMDir[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### SELECT DF GSM ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
}
/* Select IMSI -----------------------------------------------------------*/
if(SC_Response.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = IMSI[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### SELECT EF IMSI ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
}
/* Get Response on IMSI File ---------------------------------------------*/
if(SC_Response.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Response.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(CHV1Status == 0x00)
{
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Enable CHV1 (PIN1) ------------------------------------------------*/
/* CHV1 enabling should be done using proper value of used card CHV1 */
/* Please fill corresponding value in CHV1[array] . Current value is set to "00000000". */
/*
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_ENABLE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x04;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
*/
#if defined(HAL_UART_MODULE_ENABLED)
/* printf("-- ### CHV1 ENABLE ### \n\r"); */
#endif /* HAL_UART_MODULE_ENABLED */
}
}
else
{
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Verify CHV1 (PIN1) ------------------------------------------------*/
/* CHV1 enabling should be done using proper value of used card CHV1 */
/* Please fill corresponding value in CHV1[array] . Current value is set to "00000000". */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_VERIFY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### CHV1 VERIFY ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
}
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### CHV1 Operation successfull ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 9;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
else
{
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### CHV1 Operation unsuccessfull : SW1/SW2=0x%4x ### \n\r", ((SC_Response.SW1 << 8) | (SC_Response.SW2)));
#endif /* HAL_UART_MODULE_ENABLED */
}
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- ### READ BINARY (IMSI) ### \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Copy the IMSI File content into IMSI_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
IMSI_Content[i] = SC_Response.Data[i];
}
}
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- IMSI Value = ");
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
printf("%x ",IMSI_Content[i]);
}
printf("\n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Disable the Smartcard interface */
SCState = SC_POWER_OFF;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- Card powered OFF -- \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
#if defined(HAL_UART_MODULE_ENABLED)
printf("-- Waiting for card removal -- (LED1 blinking) \n\r");
#endif /* HAL_UART_MODULE_ENABLED */
/* Loop while a Smartcard is detected */
while(CardInserted == 1)
{
BSP_LED_Toggle(LED1);
HAL_Delay(200);
}
BSP_LED_Off(LED1);
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* STM32F4xx HAL library initialization:
- Configure the Flash prefetch, instruction and Data caches
- Configure the Systick to generate an interrupt each 1 msec
- Set NVIC Group Priority to 4
- Global MSP (MCU Support Package) initialization
*/
HAL_Init();
/* Configure LED1, LED2, LED3 and LED4 */
BSP_LED_Init(LED1);
BSP_LED_Init(LED2);
BSP_LED_Init(LED3);
BSP_LED_Init(LED4);
/* Configure the system clock to 168 MHz */
SystemClock_Config();
SC_State SCState = SC_POWER_OFF;
/* Configure Smartcard Interface GPIO pins */
SC_IOConfig();
/*-------------------------------- Idle task ---------------------------------*/
while(1)
{
/* Loop while no Smartcard is detected */
while(CardInserted == 0)
{
}
/* Start SC Demo ---------------------------------------------------------*/
/* Wait A2R --------------------------------------------------------------*/
SCState = SC_POWER_ON;
SC_ADPU.Header.CLA = 0x00;
SC_ADPU.Header.INS = SC_GET_A2R;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
while(SCState != SC_ACTIVE_ON_T0)
{
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Apply the Procedure Type Selection (PTS) */
SC_PTSConfig();
/* Inserts delay(400ms) for Smartard clock resynchronisation */
HAL_Delay(400);
/* Select MF -------------------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = MasterRoot[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
/* Get Response on MF ----------------------------------------------------*/
if(SC_Response.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Response.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Select ICCID ----------------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Check if the CHV1 is enabled */
if((SC_Response.Data[13] & 0x80) == 0x00)
{
CHV1Status = 0x01;
}
/* Send APDU Command for ICCID selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = ICCID[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Read Binary in ICCID --------------------------------------------------*/
if(SC_Response.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 10;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Select GSMDir ---------------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Copy the ICCID File content into ICCID_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
ICCID_Content[i] = SC_Response.Data[i];
}
/* Send APDU Command for GSMDir selection */
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = GSMDir[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Select IMSI -----------------------------------------------------------*/
if(SC_Response.SW1 == SC_DF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_SELECT_FILE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x02;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = IMSI[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Get Response on IMSI File ---------------------------------------------*/
if(SC_Response.SW1 == SC_EF_SELECTED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_GET_RESPONCE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = SC_Response.SW2;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(CHV1Status == 0x00)
{
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Enable CHV1 (PIN1) ------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_ENABLE;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
}
else
{
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Verify CHV1 (PIN1) ------------------------------------------------*/
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_VERIFY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x01;
SC_ADPU.Body.LC = 0x08;
for(i = 0; i < SC_ADPU.Body.LC; i++)
{
SC_ADPU.Body.Data[i] = CHV1[i];
}
while(i < LC_MAX)
{
SC_ADPU.Body.Data[i++] = 0;
}
SC_ADPU.Body.LE = 0;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
}
/* Read Binary in IMSI ---------------------------------------------------*/
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
SC_ADPU.Header.CLA = SC_CLA_GSM11;
SC_ADPU.Header.INS = SC_READ_BINARY;
SC_ADPU.Header.P1 = 0x00;
SC_ADPU.Header.P2 = 0x00;
SC_ADPU.Body.LC = 0x00;
SC_ADPU.Body.LE = 9;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
}
if(((SC_Response.SW1 << 8) | (SC_Response.SW2)) == SC_OP_TERMINATED)
{
/* Copy the IMSI File content into IMSI_Content buffer */
for(i = 0; i < SC_ADPU.Body.LE; i++)
{
IMSI_Content[i] = SC_Response.Data[i];
}
}
/* Disable the Smartcard interface */
SCState = SC_POWER_OFF;
SC_Handler(&SCState, &SC_ADPU, &SC_Response);
CardInserted = 0;
}
}
