int HexrecSign(int a) { int i,crc; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_CRC, ENABLE); i=FlashErase(_SIGN_PAGE); CRC_ResetDR(); crc=CRC_CalcBlockCRC((uint32_t *)a,0x8000); i |= FlashProgram32((int)_FW_CRC,crc); // vpisi !!! i |= FlashProgram32((int)_FW_SIZE,0x8000); i |= FlashProgram32((int)_FW_START,a); CRC_ResetDR(); crc=CRC_CalcBlockCRC((uint32_t *)_FW_SIZE,3); i |= FlashProgram32((int)_SIGN_CRC,crc); return i; }
bool CC2500_PacketCheck() { u8 i; u32 *pu32 = NULL; RSSI = CC2500_ReadStatus(CCxxx0_RSSI); LQI = CC2500_ReadStatus(CCxxx0_LQI); CC2500_ReceivePacket(gPacketbuf); ReceiveTime = Timer2Counter; CC2500_SetRxd(); pu32 = (u32*) &gPacketbuf[1]; CRC_ResetDR(); if (CRC_CalcBlockCRC(pu32, CRC_LENGTH - 1) == pu32[CRC_LENGTH - 1]) { if (NodeTimestamp[gPacketbuf[SRC_NUM]] != pu32[CRC_LENGTH - 2]) { NodeTimestamp[gPacketbuf[SRC_NUM]] = pu32[CRC_LENGTH - 2]; return TRUE; } else { return FALSE; } } else { return FALSE; } }
int main(void){ SystemInit(); usart1_init(); // enable clock for CRC unit RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC, ENABLE); unsigned int data = 0x12345678; unsigned int result = CRC_CalcCRC(data); printf("single word crc calculation:\r\n"); printf(" data = 0x%08x\r\n", (unsigned int)data); printf(" result = 0x%08x\r\n", (unsigned int)result); CRC_ResetDR(); int len_datablock = sizeof(data_block); result = CRC_CalcBlockCRC(data_block, len_datablock); printf("block crc calculation (%d bytes):\r\n", len_datablock); printf(" data block can be found in source.\r\n"); printf(" result = 0x%08x\r\n", result); for(;;) { } return 0; }
static uint32_t iap_calc_crc(void) { RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC, ENABLE); CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t *) START_OF_USER_CODE, (SIZE_OF_CODE) >> 2); return CRC_GetCRC(); }
/*! * Compute the CRC32 of a block. */ static uint32_t vrom_crc32( const struct vrom_data_block_t* const block) { struct vrom_data_block_t temp_block; uint32_t size = sizeof(temp_block); const uint8_t* in = (const uint8_t*)(&temp_block); uint32_t tmp; uint32_t crc; memcpy(&temp_block, block, sizeof(temp_block)); temp_block.header.crc32 = 0; CRC_ResetDR(); while(size) { tmp = 0; if (size) { tmp |= (uint32_t)(*(in++)) << 24; size--; } if (size) { tmp |= (uint32_t)(*(in++)) << 16; size--; } if (size) { tmp |= (uint32_t)(*(in++)) << 8; size--; } if (size) { tmp |= (uint32_t)(*(in++)); size--; } crc = CRC_CalcCRC(tmp); } return crc; }
uint16_t set_CRC(uint8_t*pBuf, uint16_t lenght) { uint16_t u32_len, CRCValue, u8_len; if((lenght%4) != 0) { u32_len = (lenght/4)+1; u8_len = u32_len*4; } else { u32_len = lenght/4; u8_len = lenght; } if(u8_len > (RX_BUFSIZE-2)) return 0; CRC_ResetDR(); CRCValue = CRC_CalcBlockCRC((uint32_t *)pBuf, u32_len); memcpy(pBuf+u8_len, &CRCValue, 2); u8_len += 2; return u8_len; }
uint32_t PIOS_BL_HELPER_CRC_Memory_Calc() { const struct pios_board_info * bdinfo = &pios_board_info_blob; PIOS_BL_HELPER_CRC_Ini(); CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t *) bdinfo->fw_base, (bdinfo->fw_size) >> 2); return CRC_GetCRC(); }
void CRC_test(unsigned int calData) { unsigned int temp = 0; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC, ENABLE); CRC_ResetDR(); CRC_CalcCRC(calData); temp = CRC_GetCRC(); //temp = temp; //why ,不加上这句话就看不到temp的真实值。 uart_printf("crc=0x%x\r\n",temp); }
int crcSIGN(void) { int i=-1,crc; #if defined (STM32F10X_HD) RCC_AHBPeriphClockCmd(RCC_AHBPeriph_CRC, ENABLE); #elif defined (STM32F2XX) RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_CRC, ENABLE); #endif if(_Words32Received) { i=EraseFLASH(_SIGN_PAGE); CRC_ResetDR(); crc=CRC_CalcBlockCRC((uint32_t *)_FLASH_TOP,_Words32Received); i |= FlashProgram32((int)_FW_CRC,crc); // vpisi !!! i |= FlashProgram32((int)_FW_SIZE,_Words32Received); CRC_ResetDR(); crc=CRC_CalcBlockCRC(_FW_SIZE,2); i |= FlashProgram32((int)_SIGN_CRC,crc); } return i; }
uint32_t crc_buf_hard(struct crc_h *h, const void *buf, uint32_t len, bool reset) { uint32_t r; // crc hw is a shared resource so we need to lock around it sys_enter_critical_section(); // reset if (reset) CRC_ResetDR(); // mangle length so it is 4 byte aligned as hard requires this if (len & 0x03) len = (len >> 2) + 1; else
bool check_CRC(uint8_t* pBuf, uint16_t lenght) { uint16_t u32_len, CRCValue, crc; if(lenght > RX_BUFSIZE) return false; u32_len = (lenght-2)/4; //转换为u32的长度 memcpy(&CRCValue, pBuf+lenght-2, 2); CRC_ResetDR(); crc = CRC_CalcBlockCRC((uint32_t *)pBuf, u32_len); if(CRCValue != crc) return false; return true; }
static uint32_t s_hal_crc32_hw_compute(hal_crc_info_t *info, const void *data, uint32_t size) { uint8_t tailsize = 0; if(0xffffffff == info->initialvalue) { CRC_ResetDR(); } info->initialvalue = CRC_CalcBlockCRC_networkorder((uint32_t*)data, size/4); tailsize = size%4; if(0 != (tailsize)) { uint8_t tail[4]; memset(tail, 0, 4); memcpy(tail, ((uint8_t*)data) + size-tailsize, tailsize); info->initialvalue = CRC_CalcBlockCRC((uint32_t*)tail, 1); } return(info->initialvalue); }
/** * @brief Cal CRC16 for YModem Packet * @param data * @param length * @retval CRC value */ uint16_t Cal_CRC16(const uint8_t* data, uint32_t size) { uint32_t crc = 0; const uint8_t* dataEnd = data+size; #ifdef USE_CRC_PERIPH /* Reset CRC data register */ CRC_ResetDR(); while(data < dataEnd) { crc = CRC_CalcCRC16bits(__REV16(*(uint16_t *)data)); data+=2; } #else /* USE_CRC_SOFTWARE */ while(data<dataEnd) { crc = UpdateCRC16(crc,*data++); } crc = UpdateCRC16(crc,0); crc = UpdateCRC16(crc,0); #endif /* USE_CRC_PERIPH */ return (crc&0xffffu); }
/** * @brief Computes the 32-bit CRC of a given buffer of byte data. * @param pBuffer: pointer to the buffer containing the data to be computed * @param BufferSize: Size of the buffer to be computed * @retval 32-bit CRC */ uint32_t HAL_Core_Compute_CRC32(const uint8_t *pBuffer, uint32_t bufferSize) { /* Hardware CRC32 calculation */ uint32_t i, j; uint32_t Data; CRC_ResetDR(); i = bufferSize >> 2; while (i--) { Data = *((uint32_t *)pBuffer); pBuffer += 4; Data = __RBIT(Data);//reverse the bit order of input Data CRC->DR = Data; } Data = CRC->DR; Data = __RBIT(Data);//reverse the bit order of output Data i = bufferSize & 3; while (i--) { Data ^= (uint32_t)*pBuffer++; for (j = 0 ; j < 8 ; j++) { if (Data & 1) Data = (Data >> 1) ^ 0xEDB88320; else Data >>= 1; } }
void DMA1_Stream0_IRQHandler(void) { static uint16_t msg_id[2] = {0,0}; static int wrr = 0; static int msg_index = 0; static uint16_t data_temp[2] = {0,0}; static uint32_t mode = DLE_STX; uint32_t *pdata = (uint32_t*)&data_temp[0]; uint16_t *padpcm_msg; uint32_t* pin; uint32_t* pout; uint32_t crc; int i,j,id,adr; DMA_ClearFlag(DMA1_Stream0, DMA_IT_TC | DMA_IT_TE); DMA_ClearITPendingBit(DMA1_Stream0, DMA_IT_TCIF0 | DMA_IT_TEIF0); id = DMA_GetCurrentMemoryTarget(DMA1_Stream0); for(i = 0; i < SPI_RX_DMA; i++) { data_temp[1] = data_temp[0]; data_temp[0] = spi_dma_buffer[id][i]; if(mode == DLE_STX) { if(*pdata == DLE_STX) { mode = DLE_ETX; padpcm_msg = (uint16_t*)&adpcm_msg[msg_index]; wrr = 0; } } else if(mode == DLE_ETX) { if(*pdata == DLE_ETX) { CRC_ResetDR(); crc = CRC_CalcBlockCRC(((uint32_t*)&adpcm_msg[msg_index])+1,msg_32bit_size-1); if(crc == adpcm_msg[msg_index].crc) { if(adpcm_msg[msg_index].msg_id == F415_CHECK_SPI_CONNECT+100) { t_info.f415_spi1_error = 0; t_info.f415_mode = F415_STOP_MODE; } else if(adpcm_msg[msg_index].msg_id == F415_AUDIO_STREAM) { t_info.f415_mode = F415_AUDIO_STREAM_MODE; for(i = 0; i < MAX_CHANNEL; i++) { id = adpcm_ctrl[i].id; adr = adpcm_ctrl[i].adr++; pin = (uint32_t*)&padpcm[id][i]->adpcm_data[adr][0]; pout = (uint32_t*)&adpcm_msg[msg_index].adpcm_block[i].adpcm_data[0]; for(j = 0; j < 28; j++) *(pin++) = *(pout++); if(adr == 0) { padpcm[id][i]->prevsample = adpcm_msg[msg_index].adpcm_block[i].prevsample; padpcm[id][i]->previndex = adpcm_msg[msg_index].adpcm_block[i].previndex; padpcm[id][i]->channel_id = i; padpcm[id][i]->time = GetTime(); adpcm_ctrl[i].crc = crc32_t(-1,padpcm[id][i],116,116); } else if(adr == (ADPCM_MAX_BLOCK-1)) { padpcm[id][i]->crc = crc32_t(adpcm_ctrl[i].crc,&padpcm[id][i]->adpcm_data[adr][0],120,120) ^ 0xffffffff; adpcm_ctrl[i].id ^= 1; adpcm_ctrl[i].adr = 0; adpcm_ctrl[i].done = 1; } else { adpcm_ctrl[i].crc = crc32_t(adpcm_ctrl[i].crc,&padpcm[id][i]->adpcm_data[adr][0],112,112); } } if(adr == (ADPCM_MAX_BLOCK-1)) { for(i = 0; i < MAX_CHANNEL; i++) adpcm_ready |= adpcm_ctrl[i].done; } } } msg_id[0] = adpcm_msg[msg_index].msg_counter; if(msg_id[0] != (msg_id[1]+1)) { //sys_info.L151_stream_error++; t_info.crc_binar_error++; } msg_id[1] = msg_id[0]; *pdata = 0; mode = DLE_STX; msg_index ^= 1; } else if(*pdata == DLE_DLE) { data_temp[0] = 0; } else { if(wrr++ < msg_16bit_size) *(padpcm_msg++) = data_temp[0]; } } } }
/*${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData} ................*/ static QState FlashMgr_WaitingForFWData(FlashMgr * const me, QEvt const * const e) { QState status_; switch (e->sig) { /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData} */ case Q_ENTRY_SIG: { /* Ok, we are ready to receive FW data and start flashing. Post an event letting * CommMgr know we are ready for a data packet. */ FlashStatusEvt *evt = Q_NEW(FlashStatusEvt, FLASH_OP_DONE_SIG); evt->errorCode = me->errorCode; QACTIVE_POST(AO_CommMgr, (QEvt *)(evt), AO_FlashMgr); me->errorCode = ERR_FLASH_WAIT_FOR_DATA_TIMEOUT; /* Set the timeout error code*/ QTimeEvt_rearm( /* Re-arm timer on entry */ &me->flashOpTimerEvt, SEC_TO_TICKS( LL_MAX_TOUT_SEC_FLASH_WAIT_FOR_DATA ) ); status_ = Q_HANDLED(); break; } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData} */ case Q_EXIT_SIG: { QTimeEvt_disarm(&me->flashOpTimerEvt); /* Disarm timer on exit */ status_ = Q_HANDLED(); break; } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData::FLASH_DATA} */ case FLASH_DATA_SIG: { /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData::FLASH_DATA::[ValidSeq?]} */ if (me->fwPacketCurr + 1 == ((FWDataEvt const *)e)->seqCurr) { /* Calculate packet data CRC and make sure it matches the one sent over */ CRC_ResetDR(); uint32_t CRCValue = CRC32_Calc(((FWDataEvt const *)e)->dataBuf, ((FWDataEvt const *)e)->dataLen); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData::FLASH_DATA::[ValidSeq?]::[ValidCRC?]} */ if (CRCValue == ((FWDataEvt const *)e)->dataCRC) { me->fwDataToFlashLen = ((FWDataEvt const *)e)->dataLen; MEMCPY( me->fwDataToFlash, ((FWDataEvt const *)e)->dataBuf, me->fwDataToFlashLen ); status_ = Q_TRAN(&FlashMgr_WritingFlash); } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData::FLASH_DATA::[ValidSeq?]::[else]} */ else { me->errorCode = ERR_FLASH_INVALID_FW_PACKET_CRC; ERR_printf( "Sent CRC (0x%08x) doesn't match calculated (0x%08x) for fw packet: %d. Error: 0x%08x\n", CRCValue, ((FWDataEvt const *)e)->dataCRC, ((FWDataEvt const *)e)->seqCurr, me->errorCode); status_ = Q_TRAN(&FlashMgr_Idle); } } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WaitingForFWData::FLASH_DATA::[else]} */ else { ERR_printf("Invalid fw packet sequence number. Expecting: %d, got %d\n", me->fwPacketCurr + 1, ((FWDataEvt const *)e)->seqCurr); status_ = Q_TRAN(&FlashMgr_Idle); } break; } default: { status_ = Q_SUPER(&FlashMgr_BusyFlash); break; } } return status_; }
uint32_t crc_memory_calc() { CRC_ResetDR(); CRC_CalcBlockCRC((uint32_t *) START_OF_USER_CODE, (SIZE_OF_CODE) >> 2); return CRC_GetCRC(); }
/*${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash} ....................*/ static QState FlashMgr_WritingFlash(FlashMgr * const me, QEvt const * const e) { QState status_; switch (e->sig) { /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash} */ case Q_ENTRY_SIG: { me->errorCode = ERR_FLASH_WRITE_TIMEOUT; /* Set the timeout error code*/ if ( (me->fwPacketCurr + 1) % 100 == 0 ) { DBG_printf("Writing FW data packet %d of %d total.\n", me->fwPacketCurr + 1, me->fwFlashMetadata._imageNumPackets); } QTimeEvt_rearm( /* Re-arm timer on entry */ &me->flashOpTimerEvt, SEC_TO_TICKS( LL_MAX_TOUT_SEC_FLASH_DATA_WRITE ) ); uint16_t bytesWritten = 0; DC3Error_t err = FLASH_writeBuffer( me->flashAddrCurr, me->fwDataToFlash, me->fwDataToFlashLen, &bytesWritten ); me->errorCode = err; if( ERR_NONE != err || bytesWritten != me->fwDataToFlashLen) { /* Error occurred */ WRN_printf("Error flashing data: 0x%08x\n", me->errorCode); QEvt *evt = Q_NEW(QEvt, FLASH_ERROR_SIG); QACTIVE_POST(AO_FlashMgr, (QEvt *)(evt), AO_FlashMgr); } else { /* No errors */ /* Increment addr and counters */ me->flashAddrCurr += bytesWritten; me->fwPacketCurr += 1; QEvt *evt = Q_NEW(QEvt, FLASH_DONE_SIG); QACTIVE_POST(AO_FlashMgr, (QEvt *)(evt), AO_FlashMgr); } status_ = Q_HANDLED(); break; } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE} */ case FLASH_DONE_SIG: { /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[MorePackets?]} */ if (me->fwPacketCurr != me->fwPacketExp) { status_ = Q_TRAN(&FlashMgr_WaitingForFWData); } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]} */ else { DBG_printf("No more fw packets expected\n"); /* Do a check of the FW image and compare all the CRCs and sizes */ CRC_ResetDR(); uint32_t crcCheck = CRC32_Calc( (uint8_t *)FLASH_APPL_START_ADDR, me->fwFlashMetadata._imageSize ); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]} */ if (me->fwFlashMetadata._imageCrc == crcCheck) { DBG_printf("CRCs of the FW image match, writing metadata...\n"); me->errorCode = FLASH_writeApplSize( me->fwFlashMetadata._imageSize ); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]} */ if (ERR_NONE == me->errorCode) { me->errorCode = FLASH_writeApplCRC( me->fwFlashMetadata._imageCrc ); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]} */ if (ERR_NONE == me->errorCode) { me->errorCode = FLASH_writeApplMajVer( me->fwFlashMetadata._imageMaj ); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]::[NoError?]} */ if (ERR_NONE == me->errorCode) { me->errorCode = FLASH_writeApplMinVer( me->fwFlashMetadata._imageMin ); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]::[NoError?]::[NoError?]} */ if (ERR_NONE == me->errorCode) { me->errorCode = FLASH_writeApplBuildDatetime( (uint8_t *)me->fwFlashMetadata._imageDatetime, me->fwFlashMetadata._imageDatetime_len ); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]::[NoError?]::[NoError?]::[NoError?]} */ if (ERR_NONE == me->errorCode) { LOG_printf("Successfully finished upgrading FW!\n"); status_ = Q_TRAN(&FlashMgr_Idle); } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]::[NoError?]::[NoError?]::[else]} */ else { ERR_printf("Unable to write image build datetime after flashing. Error: 0x%08x.\n", me->errorCode); status_ = Q_TRAN(&FlashMgr_Idle); } } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]::[NoError?]::[else]} */ else { ERR_printf("Unable to write image Minor Version after flashing. Error: 0x%08x.\n", me->errorCode); status_ = Q_TRAN(&FlashMgr_Idle); } } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[NoError?]::[else]} */ else { ERR_printf("Unable to write image Major Version after flashing. Error: 0x%08x.\n", me->errorCode); status_ = Q_TRAN(&FlashMgr_Idle); } } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[NoError?]::[else]} */ else { ERR_printf("Unable to write image CRC after flashing. Error: 0x%08x.\n", me->errorCode); status_ = Q_TRAN(&FlashMgr_Idle); } } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[CRCMatch?]::[else]} */ else { ERR_printf("Unable to write image size after flashing. Error: 0x%08x.\n", me->errorCode); status_ = Q_TRAN(&FlashMgr_Idle); } } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_DONE::[else]::[else]} */ else { me->errorCode = ERR_FLASH_INVALID_IMAGE_CRC_AFTER_FLASH; ERR_printf("CRC check failed after flash. Error: 0x%08x.\n", me->errorCode); ERR_printf("Expected : 0x%08x\n", me->fwFlashMetadata._imageCrc); ERR_printf("Calculated: 0x%08x\n", crcCheck); status_ = Q_TRAN(&FlashMgr_Idle); } } break; } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_ERROR} */ case FLASH_ERROR_SIG: { WRN_printf("FLASH_ERROR\n"); /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_ERROR::[RetriesLeft?]} */ if (me->retryCurr < MAX_FLASH_RETRIES) { LOG_printf("Retrying to flash packet, retry %d out of %d max\n", me->retryCurr, MAX_FLASH_RETRIES); status_ = Q_TRAN(&FlashMgr_WritingFlash); } /* ${AOs::FlashMgr::SM::Active::BusyFlash::WritingFlash::FLASH_ERROR::[else]} */ else { ERR_printf("No more retries\n"); status_ = Q_TRAN(&FlashMgr_Idle); } break; } default: { status_ = Q_SUPER(&FlashMgr_BusyFlash); break; } } return status_; }
unsigned int HardGenCrc32(unsigned int* puData, unsigned int uSize) { CRC_ResetDR(); return CRC_CalcBlockCRC((unsigned int *)puData, (unsigned int)uSize); }
/** * @brief This function handles USRAT interrupt request. * @param None * @retval None */ void USARTx_IRQHandler(void) { #ifdef MODE_TRANSMITTER /* ------------------ USART in mode Tramitter ------------------------------*/ if (USART_GetITStatus(USARTx, USART_IT_TXE) == SET) { if (TxIndex < 0x48) { /* Send TxBuffer data */ USART_SendData(USARTx, TxBuffer[TxIndex]); /* Compute 8-bit CRC */ CRC_CalcCRC8bits(TxBuffer[TxIndex++]); } else if (TxIndex == 0x48) { /* Get computed computed value */ TxBuffer[TxIndex] = (uint8_t)CRC_GetCRC(); /* Reset CRC calculation unit */ CRC_ResetDR(); /* Send CRC computed value */ USART_SendData(USARTx, TxBuffer[TxIndex]); /* Disable the USARTx transmit data register empty interrupt */ USART_ITConfig(USARTx, USART_IT_TXE, DISABLE); /*Discard CRC sent value*/ TxBuffer[TxIndex] = 0; /*reset TxBuffer index*/ TxIndex = 0; } } #else /* ------------------ USART in mode Receiver -------------------------------*/ if (USART_GetITStatus(USARTx, USART_IT_RXNE) == SET) { if (RxIndex < 0x48) { /* Receive the USART data */ RxBuffer[RxIndex] = USART_ReceiveData(USARTx); /* compute 8-bit CRC */ CRC_CalcCRC8bits(RxBuffer[RxIndex++]); } else if (RxIndex == 0x48) { /* Get computed computed value */ ComputedCRC = (uint8_t)CRC_GetCRC(); /* Reset CRC calculation unit */ CRC_ResetDR(); /* Recive expected CRC value */ RxBuffer[RxIndex] = USART_ReceiveData(USARTx); /* Compare computed CRC and recived CRC values*/ if (ComputedCRC == RxBuffer[RxIndex]) { /* LED3 Off */ STM_EVAL_LEDOff(LED3); /* Toggle LED2 */ STM_EVAL_LEDToggle(LED2); } else { /* LED3 On */ STM_EVAL_LEDOn(LED3); /* LED2 Off */ STM_EVAL_LEDOff(LED2); } /* Reset RxBuffer index */ RxIndex = 0; } } #endif /* MODE_TRANSMITTER */ }
/* This function runs before the OS start. */ void NetworkConnecting() { int i, p, test, test1; int sendcounter = 0; u32 *pu32 = NULL; test1 = Timer2Counter; test = Timer2Counter; sPacketbuf[DES_NUM] = SELFADDRESS; sPacketbuf[SRC_NUM] = SELFADDRESS; CC2500_SeleChannel(0); CC2500_SetRecvAddr(SELFADDRESS); CC2500_SetRxd(); CC2500_SendPacket(sPacketbuf,PACKET_LEN); CC2500_SetRxd(); sPacketbuf[DES_NUM]=0x00; NbrList[0]=NbrCount; // while(RESET==RNG_GetFlagStatus(RNG_FLAG_DRDY)); // Delay_100us(RNG_GetRandomNumber() & 0x000000f); pu32 = (u32*) &sPacketbuf[1]; while (0 == NodeFlag[SELFADDRESS]) { if (ISIDLE) { NbrList[0] = NbrCount; sPacketbuf[PRC_NUM] = DISCOVERY_MESSAGE; arm_copy_q7(NbrList, sPacketbuf+LEN_NUM, NbrList[0]+1); pu32[CRC_LENGTH - 2] = Timer2Counter;//Add the timestamp. CRC_ResetDR(); pu32[CRC_LENGTH - 1] = CRC_CalcBlockCRC(pu32, CRC_LENGTH - 1); p = Bernoulli(1.0/(MAXNUM-NbrCount+1)); //Delay_100us(1); if (ISIDLE) { if (0 == DelayFlag) { if (p/*Bernoulli(1.0/(MAXNUM-NbrCount+1))*/) { CC2500_SendPacket(sPacketbuf, PACKET_LEN); CC2500_SetRxd(); DelayFlag=1; } } else { Preemptive_Delay_100us(25, &DelayFlag); DelayFlag=0; } } } } test1 = Timer2Counter - test1; while(MAXNUM > NbrCount) { if (0 != DiscoveryHelp) { if (ISIDLE) { Delay_100us(1); if (ISIDLE) { if (Bernoulli(1.0/(MAXNUM-NbrCount+1))) { NbrList[0] = NbrCount; sPacketbuf[PRC_NUM] = DISCOVERY_MESSAGE; arm_copy_q7(NbrList, sPacketbuf+LEN_NUM, NbrList[0]+1); pu32[CRC_LENGTH - 2] = Timer2Counter;//Add the timestamp. CRC_ResetDR(); pu32[CRC_LENGTH - 1] = CRC_CalcBlockCRC(pu32, CRC_LENGTH - 1); CC2500_SendPacket(sPacketbuf, PACKET_LEN); CC2500_SetRxd(); } } } DiscoveryHelp = 0; } } test = Timer2Counter - test; while(RESET==RNG_GetFlagStatus(RNG_FLAG_DRDY)); Delay_100us(RNG_GetRandomNumber() & 0x000000f); pu32[CRC_LENGTH - 2] = Timer2Counter;//Add the timestamp. sendcounter = 3; while (0 != sendcounter) { if (ISIDLE) { Delay_100us(1); if (ISIDLE) { NbrList[0] = NbrCount; sPacketbuf[PRC_NUM] = DISCOVERY_ACCOMPLISHED; arm_copy_q7(NbrList, sPacketbuf+LEN_NUM, NbrList[0]+1); CRC_ResetDR(); pu32[CRC_LENGTH - 1] = CRC_CalcBlockCRC(pu32, CRC_LENGTH - 1); CC2500_SendPacket(sPacketbuf, PACKET_LEN); CC2500_SetRxd(); sendcounter--; } } Delay_100us(10); } printf("NeighbourList:\r\n"); for (i=0;i<MAXNUM;i++) { printf("%#x\r\n",NbrList[1+i]); } printf("t1 = %d\r\n", test1); printf("t = %d\r\n", test); }