Exemple #1
0
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;
}
Exemple #2
0
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;
	}
}
Exemple #3
0
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;
}
Exemple #4
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();
}
Exemple #5
0
/*!
 * 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();
}
Exemple #8
0
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);
}
Exemple #9
0
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;
}
Exemple #10
0
Fichier : crc.c Projet : othane/mos
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);
}
Exemple #13
0
/**
  * @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);
}
Exemple #14
0
/**
 * @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;
		}
	}
Exemple #15
0
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];
       }
     
      }
  }
}
Exemple #16
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();
}
Exemple #18
0
/*${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_;
}
Exemple #19
0
unsigned int HardGenCrc32(unsigned int* puData, unsigned int uSize)
{
	CRC_ResetDR();
	return CRC_CalcBlockCRC((unsigned int *)puData, (unsigned int)uSize);
}
Exemple #20
0
/**
* @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 */
}
Exemple #21
0
/* 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);
}