#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#ifdef RFID_DEBUG_SIGN
#define DEBUG_INFO 1U
#endif
#define PACKET_HEADERS_BIT_LEN 16U
#define PACKET_HEADERS_DATA 0x0000
#define VALID_DATA_BIT_LEN 64U
#define VALID_DATA_WORD_LEN 2U
#define REC_DAT_LEN 256U
#define EM4305_ONE_CLOCK_MIN 200U
#define EM4305_ONE_CLOCK_MAX 250U
#define EM4305_HALF_CLOCK_MIN 90U
#define EM4305_HALF_CLOCK_MAX 150U
#define IS_ONE_CLOCK_CYCLE(x) ( ((x) > EM4305_ONE_CLOCK_MIN ) \
&&((x) < EM4305_ONE_CLOCK_MAX ))
#define IS_HALF_CLOCK_CYCLE(x) ( ((x) > EM4305_HALF_CLOCK_MIN ) \
&&((x) < EM4305_HALF_CLOCK_MAX ))
typedef enum
{
REC_DATA_EMPTY = 0U,
REC_DATA_FULL = 1U,
}eRecDat_TypeDef;
typedef enum
{
PARS_FAIL = 0U,
PARS_SUCCES = 1U,
}eParsRes_TypeDef;
typedef struct PARS_DATA_STRUCT
{
uint16_t len;
uint8_t *str;
}sPARS_DataTypeDef;
static uint16_t recive_data_full_flag = 0U;
static uint16_t buf[REC_DAT_LEN] = {0};
static uint16_t cnt = 0;
void EM4305_IC_CaptureCallback( TIM_HandleTypeDef *htim )
{
if ( &htim2 != htim )
return ;
TIM2->CR1 &= ~(TIM_CR1_CEN);
buf[cnt++] = TIM2->CCR2;
TIM2->CNT = 0U;
/* negate edge trigger */
/* Happend Falling edge trigger */
if ( (TIM2->CCER&(TIM_CCER_CC2P) ) != (TIM_CCER_CC2P) )
{
TIM2->CCER &= ~(TIM_CCER_CC2P | TIM_CCER_CC2NP);
TIM2->CCER |= (TIM_CCER_CC2P); //set Falling edge trigger and waiting
}
/* Happend Rising edge trigger */
else
{
TIM2->CCER &= ~(TIM_CCER_CC2P | TIM_CCER_CC2NP);
TIM2->CCER |= (0U<<4U); //set Rising edge trigger and waiting
}
if( cnt < REC_DAT_LEN )
TIM2->CR1 |= (TIM_CR1_CEN);
else
{
cnt = 0U;
__HAL_TIM_DISABLE_IT( &htim2, TIM_IT_CC2);
recive_data_full_flag = REC_DATA_FULL;
}
}
static void restart_interrupt_receiving_data(void)
{
TIM2->CCER &= ~(TIM_CCER_CC1P | TIM_CCER_CC1NP);
TIM2->CCER |= (0U<<2U);//set Rising edge trigger and waiting
__HAL_TIM_ENABLE_IT( &htim2, TIM_IT_CC1);
TIM2->CR1|=(TIM_CR1_CEN);
}
static eParsRes_TypeDef EM4305_Bi_Phase_extract_vald_data_segment( uint16_t *rec_data_ptr,
uint16_t recive_data_length_max,
sPARS_DataTypeDef *valid_data_ptr,
uint16_t valid_data_length_min )
{
if ( NULL == rec_data_ptr || 0U == recive_data_length_max
|| NULL == valid_data_ptr || 0U == valid_data_length_min )
return PARS_FAIL;
uint8_t *extract_bit_ptr = valid_data_ptr->str;
uint16_t length = 0;
uint16_t count = 0;
#if (DEBUG_INFO == 1U)
printf("Enter extract_vald_data_segment\r\n");
#endif
do
{
if ( IS_HALF_CLOCK_CYCLE( rec_data_ptr[count] ) && IS_HALF_CLOCK_CYCLE( rec_data_ptr[count+1] ) )
{
extract_bit_ptr[length++] = (uint16_t)0U;
count += 2;
}
else if ( IS_ONE_CLOCK_CYCLE( rec_data_ptr[count] ))
{
extract_bit_ptr[length++] = (uint16_t)1U;
count++;
}
else
{
length = 0U;
count++;
}
}while ( count < recive_data_length_max );
if ( (valid_data_ptr->len = length) < valid_data_length_min )
return PARS_FAIL;
return PARS_SUCCES;
}
static uint8_t *EM4305_Bi_Phase_looking_for_packet_headers( sPARS_DataTypeDef *valid_data_ptr,
uint16_t valid_data_bit_length,
uint16_t packet_headers_data,
uint16_t packet_headers_bit_length )
{
if ( NULL == valid_data_ptr || 0U == valid_data_bit_length || 0U == packet_headers_bit_length )
return NULL;
uint16_t count = 0; uint8_t cnt ;
uint8_t *packet_headers_bit_ptr = NULL;
uint8_t *extract_bit_ptr = NULL;
uint16_t extract_bit_length = 0;
packet_headers_bit_ptr = (uint8_t *)malloc( packet_headers_bit_length );
if ( NULL == packet_headers_bit_ptr )
return NULL;
#if (DEBUG_INFO == 1U)
printf("Enter looking_for_packet_headers\r\n");
#endif
do{
packet_headers_bit_ptr[count] = (uint8_t)((packet_headers_data>>count)&((uint16_t)1U));
}while( ++count < packet_headers_bit_length );
extract_bit_ptr = valid_data_ptr->str;
extract_bit_length = valid_data_ptr->len;
for ( count = 0U; count < extract_bit_length; count++ )
{
if ( extract_bit_ptr[count] != packet_headers_bit_ptr[0] )
continue;
if ( (extract_bit_length - count) < valid_data_bit_length )
goto LOG;
for ( cnt = 1U; cnt < packet_headers_bit_length; cnt++ )
{
if ( extract_bit_ptr[count + cnt] != packet_headers_bit_ptr[cnt] )
break;
if ( cnt == (packet_headers_bit_length - 1U) )
{
valid_data_ptr->str = extract_bit_ptr + count + packet_headers_bit_length;
valid_data_ptr->len = valid_data_bit_length - packet_headers_bit_length;
free( packet_headers_bit_ptr );
return valid_data_ptr->str;
}
}
}
LOG:
free( packet_headers_bit_ptr );
return NULL;
}
static eParsRes_TypeDef EM4305_Bi_Phase_read_verification_code( sPARS_DataTypeDef *read_code_ptr,
uint8_t *half_word_ptr )
{
if ( (NULL == read_code_ptr) || (NULL == half_word_ptr) )
return PARS_FAIL;
uint8_t *read_verification_code_ptr = read_code_ptr->str;
uint16_t length = read_code_ptr->len;
uint16_t cnt = 0, shift = 0;
for ( cnt = 0; cnt < length; cnt++, shift++ )
{
half_word_ptr[cnt/8U] |= (*(read_verification_code_ptr + cnt))<<(shift%8U);
}
return PARS_SUCCES;
}
static eParsRes_TypeDef EM4305_Bi_Phase_parsing_received_data( uint16_t *ptr )
{
sPARS_DataTypeDef pars_data = {0};
uint16_t *rec_buf_ptr = ptr;
uint8_t *valid_data_memory_block_ptr = NULL;
if ( NULL == rec_buf_ptr )
return PARS_FAIL;
valid_data_memory_block_ptr = (uint8_t *)malloc( REC_DAT_LEN );
if ( NULL == valid_data_memory_block_ptr )
return PARS_FAIL;
memset( valid_data_memory_block_ptr, (uint8_t)0U, sizeof(REC_DAT_LEN) );
pars_data.str = valid_data_memory_block_ptr;
if ( PARS_SUCCES != EM4305_Bi_Phase_extract_vald_data_segment( rec_buf_ptr,
REC_DAT_LEN,
&pars_data,
VALID_DATA_BIT_LEN ))
{
free( valid_data_memory_block_ptr );
return PARS_FAIL;
}
if ( NULL == (pars_data.str = EM4305_Bi_Phase_looking_for_packet_headers( &pars_data,
VALID_DATA_BIT_LEN,
PACKET_HEADERS_DATA,
PACKET_HEADERS_BIT_LEN )))
{
free( valid_data_memory_block_ptr );
return PARS_FAIL;
}
if ( PARS_SUCCES != EM4305_Bi_Phase_read_verification_code( &pars_data, half_word ) )
{
free( valid_data_memory_block_ptr );
return PARS_FAIL;
}
memset( valid_data_memory_block_ptr, (uint8_t)0U, sizeof(REC_DAT_LEN) );
if ( NULL != valid_data_memory_block_ptr )
{
free( valid_data_memory_block_ptr );
pars_data.str = NULL;
}
return PARS_SUCCES;
}
网友评论