fpga.c

重要代码,FPGA CYCLONE FLASH DRIVER

		{
			add1++;
			add2++;
			flow_num++;
		}
	}
	if(flow_num==10)
	{
	   nr_flash_erase_sector((unsigned short*)na_cfi_flash_0_base,(unsigned short*)(FLASH_BASE_ADD+0x80000));
	   unlock_bypass_mode(fb);
	   for(i=0; i<now_flow_add*2; i++)
	   {
	     flag = nr_flash_write_bypass((unsigned short*)na_cfi_flash_0_base,(unsigned
short*)(FLASH_BASE_ADD+0x80000+i*2),*temp2);
	     temp2++;
	   }
	   reset_bypass_mode(fb);
	}

	for(i=0; i<10; i++)
	{
		if(*add1!=0xffff && *add2==0xffff)
		{
			add1++;
			add2++;
			flow_num++;
		}
	}
	if(flow_num==10)
	{
	   nr_flash_erase_sector((unsigned short*)na_cfi_flash_0_base,(unsigned short*)(FLASH_BASE_ADD+0x90000));
	   unlock_bypass_mode(fb);
	   for(i=0; i<now_flow_add*2; i++)
	   {
	     flag = nr_flash_write_bypass((unsigned short*)na_cfi_flash_0_base,(unsigned
short*)(FLASH_BASE_ADD+0x90000+i*2),*temp1);
	     temp1++;
	   }
	   reset_bypass_mode(fb);
	}
}

/*****************************************************************************
*
*用于流量的测试
*
******************************************************************************/
unsigned short read_even_flow()
{
	unsigned short *temp1;
	temp1=(unsigned short*)(FLASH_BASE_ADD+0x6004);
	return *temp1;
}

/*****************************************************************************
*
*用于流量的测试
*
******************************************************************************/
unsigned char read_flow_data_last()
{
	unsigned short *temp1;
	unsigned char temp2;
	temp1=(unsigned short*)(FLASH_BASE_ADD+0x6006);
	temp2=*temp1;
	return temp2;
}

/**************************************************************************

延迟函数

**************************************************************************/
void delay(int number)
{
	while(number)
	  number--;
}

/**************************************************************************

校验双口ram目前写是否已满

***************************************************************************/

void Check_Ram_Write()
{
	if(++Now_Ram_Write_Add>(unsigned char*)(BASE_ADD+0x7f1))
	     Now_Ram_Write_Add=(unsigned char*)(BASE_ADD+0x80);
}

/**************************************************************************

校验双口ram目前读是否已满

***************************************************************************/

void Check_Ram_Read()
{
	if(++Now_Ram_Read_Add==(unsigned char*)(BASE_ADD+0x7f1))
	     Now_Ram_Read_Add=(unsigned char*)(BASE_ADD+0x80);
}

/*************************************************************************

自适应算法

**************************************************************************/
void SelfAlgorith()
{
	unsigned char* Mark_Address;
	unsigned char* Valid_Address;
	unsigned char* Valid_Number_Address;
	int i;
	unsigned char result;

	Conf_Solution_Address_Buffer[0]=(CheckData[7]-1)*7+CheckData[10];
	Conf_Solution_Address_Buffer[1]=1;
	CheckData[5]=Conf_Solution_Address_Buffer[0];
	Mark_Address=(unsigned char*)((CheckData[5]-1)*40+(unsigned char*)Conf_Solution_Address_Backup+1);
	Valid_Address=Mark_Address+7;
	Valid_Number_Address=(unsigned char*)Conf_CurNumber_Address_Backup;

	if(*Mark_Address!=1)
	{
		for(i=0; i<32; i++)
		{
			if(Conf_Solution_Address_Buffer[8+i]==0)
			{
				Conf_CurNumber_Address_Buffer[i]=0;
			}
			else
			{
				Conf_CurNumber_Address_Buffer[i]=1;
			}
		}
		Conf_Solution_Address_Buffer[1]=1;
	}
	else
	{
		for(i=0; i<32; i++)
		{
			if(Conf_Solution_Address_Buffer[8+i]==0)
			{
				Conf_CurNumber_Address_Buffer[i]=*(Valid_Number_Address+i);
				Conf_Solution_Address_Buffer[8+i]=*(Valid_Address+i);			}
			else
			{
				Conf_CurNumber_Address_Buffer[i]=*(Valid_Number_Address+i)+1;

Conf_Solution_Address_Buffer[8+i]=((*(Valid_Address+i))*(*(Valid_Number_Address+i))+Conf_Solution_Address_Buffer[8+i])/Conf_CurNumber_Address_Buffer[i];

result=((*(Valid_Address+i))*(*(Valid_Number_Address+i))+Conf_Solution_Address_Buffer[8+i])*10/Conf_CurNumber_Address_Buffer[
i];
				if((result-Conf_Solution_Address_Buffer[8+i]*10)>=5)
				    Conf_Solution_Address_Buffer[8+i]=Conf_Solution_Address_Buffer[8+i]+1;
			}
		}
	}
}

/*************************************************************************

计算流量发送中两个地址之间的数据量

**************************************************************************/
int length(unsigned char* begin,unsigned char* end)
{
	int temp1;
	int temp2;
	Flow_Information_Base=(unsigned short*)(FLASH_BASE_ADD+0x10000);
	Flow_Information_End=(unsigned short*)(FLASH_BASE_ADD+0x60000);
	if((unsigned long)end>(unsigned long)Flow_Information_Base &&
	   (unsigned long)end>(unsigned long)begin)
	{
	   temp1=(unsigned long)begin-(unsigned long)Flow_Information_Base+1;
	   temp2=(unsigned long)Flow_Information_End-(unsigned long)end;
	   return temp1+temp2;
    }
    if((unsigned long)end<(unsigned long)begin)
    {
	   temp1=(unsigned long)begin-(unsigned long)end;
	   return temp1;
    }
    return -1;
}

/*************************************************************************

帧标志检查

**************************************************************************/
void Check_Frame()
{
	  switch(BeginBitContent)
   		  {
					case 0:
					  if(Test_Bit==0)
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   else
						BeginBitContent=0;
					   break;
					case 1 :
					  if(Test_Bit==1)
						{
						 BeginBitContent=2;
						 RevStatus=0;
						}
					  else
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   break;
					case 2 :
					  if(Test_Bit==1)
						{
						 BeginBitContent=3;
						 RevStatus=0;
						}
					  else
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   break;
					case 3 :
					  if(Test_Bit==1)
						{
						 BeginBitContent=4;
						 RevStatus=0;
						}
					  else
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   break;
					case 4 :
					  if(Test_Bit==1)
						{
						 BeginBitContent=5;
						 RevStatus=0;
						}
					  else
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   break;
					case 5 :
					  if(Test_Bit==1)
						{
						 BeginBitContent=6;
						 RevStatus=0;
						}
					  else
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   break;
					case 6 :
					  if(Test_Bit==1)
						{
						 BeginBitContent=7;
						 RevStatus=0;
						}
					  else
						{
						 BeginBitContent=1;
						 RevStatus=0;
						}
					   break;
					case 7 :
					  if(Test_Bit==0)
						{
						 BeginBitContent=0;
						 RevStatus=1;
						}
					  else
						{
						 BeginBitContent=0;
						 RevStatus=0;
						 //增加停止
						}
					   break;
					default :                       //例外情况下初始化原变量
						 BeginBitContent=0;
						 RevStatus=0;
					   break;
	 }
}

/**************************************************************************

透明性检查

***************************************************************************/
void Check_Transparence()
{
		switch(transparence)
		{
			case 0 :
				if(Test_Bit==1)
				{
					transparence=1;
                    transparence_valid=0;
				}
				else
				{
					transparence=0;
                    transparence_valid=0;
				}
				break;
			case 1 :
				if(Test_Bit==1)
				{
					transparence=2;
                    transparence_valid=0;
				}
				else
				{
					transparence=0;
                    transparence_valid=0;
				}
				break;
			case 2:
				if(Test_Bit==1)
				{
					transparence=3;
                    transparence_valid=0;
				}
				else
				{
					transparence=0;
                    transparence_valid=0;
				}
				break;
			case 3:
				if(Test_Bit==1)
				{
					transparence=4;
                    transparence_valid=0;
				}
				else
				{
					transparence=0;
                    transparence_valid=0;
				}
				break;
			case 4:
				if(Test_Bit==1)
				{
					transparence=5;
                    transparence_valid=0;
				}
				else
				{
					transparence=0;
                    transparence_valid=0;
				}
				break;
			case 5:
				if(Test_Bit==0)
				{
					transparence=0;
                    transparence_valid=1;
				}
				else
				{
					transparence=6;
                    transparence_valid=1;
				}
				break;
			case 6 :
				if(Test_Bit==0)
				{
					transparence=0;
					transparence_valid=1;
					RevStatus=0;
				}
				else
				{
					transparence=0;
					transparence_valid=0;
					RevStatus=-1;
				}
			}

}



/**************************************************************************

对将要发送的数据增加透明性

***************************************************************************/
void Add_transparences()
{
		switch(Add_transparence)
		{
			case 0 :
				if(Add_Bit==1)
				{
					Add_transparence=1;
                    Add_transparence_valid=0;
				}
				else