fpga.c

重要代码,FPGA CYCLONE FLASH DRIVER

				{
					Add_transparence=0;
                    Add_transparence_valid=0;
				}
				break;
			case 1 :
				if(Add_Bit==1)
				{
					Add_transparence=2;
                    Add_transparence_valid=0;
				}
				else
				{
					Add_transparence=0;
                    Add_transparence_valid=0;
				}
				break;
			case 2:
				if(Add_Bit==1)
				{
					Add_transparence=3;
                    Add_transparence_valid=0;
				}
				else
				{
					Add_transparence=0;
                    Add_transparence_valid=0;
				}
				break;
			case 3:
				if(Add_Bit==1)
				{
					Add_transparence=4;
                    Add_transparence_valid=0;
				}
				else
				{
					Add_transparence=0;
                    Add_transparence_valid=0;
				}
				break;
			case 4:
				if(Add_Bit==1)
				{
					Add_transparence=0;
                    Add_transparence_valid=1;
				}
				else
				{
					Add_transparence=0;
                    Add_transparence_valid=0;
				}
				break;
			}

}


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

crc-16校验

***************************************************************************/
unsigned short Cal_Crc(unsigned char *ptr,unsigned int len)
{
 unsigned char i;
 unsigned short  crc=0;
 while(len--!=0){
	for(i=0x80;i!=0;i/=2){
		if((crc&0x8000)!=0){
			crc*=2;
			crc^=0x1021;
			               }
		else
		  crc*=2;
	    if((*ptr&i)!=0)
	      crc^=0x1021;
		                }
		ptr++;
	            }
  	return(crc);
}


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



**************************************************************************/
void Write_Comm_to_Ram()
{
	int i,m;
	unsigned char temp;
	 
mark:          *Now_Tail_High=*Rx_Tail_High[Now_MarkRx_Number];
		       *Now_Tail_Low=*Rx_Tail_Low[Now_MarkRx_Number];
		       if((((*Now_Tail_High)<<8)+(*Now_Tail_Low)+1)>=0x7f1)
	                    {   //当前尾地址超过0X7F1，返回初始地址
	                      Now_Ram_Write_Add=(unsigned char*)(BASE_ADD+0X80);
	                      Now_Head_Add=0x080;
	                    }
	           if((((*Now_Tail_High)<<8)+(*Now_Tail_Low)+1)<=0x80)
	                    {   //当前尾地址超过0X7F1，返回初始地址
	                      Now_Ram_Write_Add=(unsigned char*)(BASE_ADD+0X80);
	                      Now_Head_Add=0x080;
	                    }
               if(First!=0)
	                { 
	                    if((((*Now_Tail_High)<<8)+(*Now_Tail_Low)+1)>=0x7f1)
	                    {   //当前尾地址超过0X7F1，返回初始地址
	                      Now_Ram_Write_Add=(unsigned char*)(BASE_ADD+0X80);
	                      Now_Head_Add=0x080;
	                    }
	                    else
	                    {  //当前地址偏移处于正常范围
	                      Now_Ram_Write_Add=(unsigned char*)(BASE_ADD+((*Now_Tail_High)<<8)+(*Now_Tail_Low)+1);
				          Now_Head_Add=(((unsigned int)(*Now_Tail_High)<<8)+(unsigned int)(*Now_Tail_Low)+1);
				        }
			        }

					Now_Tail_Add=Now_Head_Add-1;

					for(m=0;m<Data_Number-6;m++)
					{
						  if(++Now_Tail_Add>=0x7f1)
						  Now_Tail_Add=0x080;
					}

//	                 Now_Tail_Add=(unsigned char*)(((unsigned int)(*Now_Tail_High)<<8)+(unsigned int)(*Now_Tail_Low)+Now_Data_Length+3);
	                //分别给有效的接收寄存器赋值
		             Rx_Head_High_test=(unsigned char)((unsigned int)(Now_Head_Add)>>8);
                     Rx_Head_Low_test=(unsigned char)((unsigned int)(Now_Head_Add) & 0x00ff);
                     Rx_Tail_High_test=(unsigned char)((unsigned int)(Now_Tail_Add)>>8);
                     Rx_Tail_Low_test=(unsigned char)((unsigned int)(Now_Tail_Add) & 0x00ff);


                     if(Now_Head_Add<0x80 || Now_Tail_Add>0x7f1)
                     {
	                    return;
	                 }

				     *Rx_Head_High[Now_MarkRx_Number]= Rx_Head_High_test;
		             *Rx_Head_Low[Now_MarkRx_Number]=Rx_Head_Low_test;
		             *Rx_Tail_High[Now_MarkRx_Number]=Rx_Tail_High_test;
		             *Rx_Tail_Low[Now_MarkRx_Number]=Rx_Tail_Low_test;


		            //当前数据存储区的首地址，尾地址
		             if(*WriteGate1==0 && *WriteGate2==0)
		             {
		                *WriteGate1=0;     //FPGA修改首尾地址
		                *WriteGate2=1;
		                if(*WriteGate1==0 && *WriteGate2==1)
		                {
			            
		                *Now_Tail_High=*Rx_Tail_High[Now_MarkRx_Number];
		                *Now_Tail_Low=*Rx_Tail_Low[Now_MarkRx_Number];
		                /////////////////////////////////////////////////
		               
		                *WriteGate1=0;
		                *WriteGate2=0;
		                }
		                else
		                {
			               goto mark;
			            }

		             }else
		             {
                        goto mark;
                     }

			        First=1;
			        for(i=4;i<Data_Number-2;i++)
			        {
				        temp=CheckData[i];
				        if(CheckData[4]==0x82){
					             *Now_Ram_Write_Add=temp;
										     }
			         	*Now_Ram_Write_Add=temp;
				        Check_Ram_Write();
			        }

			if(Finished_Receive!=0)
			{
			  *MarkRx[Now_MarkRx_Number]=Finished_Receive;
		      if(++Now_MarkRx_Number==6)
		      {
		         Now_MarkRx_Number=0;
		      }
			  Finished_Receive=0;
	    	}
			else
			  *MarkRx[Now_MarkRx_Number]=0x87;
}

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

串口1的中断服务函数

****************************************************************************/
void ReceiveISRUart1(int context)
{
	unsigned int sr;
	sr=na_uart1->np_uartstatus;
	if(sr & np_uartstatus_rrdy_mask)
	{
		if(Receive_From!=1)
		  Receive_From=1;
		if(uart_use!=na_uart1)
		  uart_use=na_uart1;
//		na_uart1->np_uartcontrol=0;                          //禁止各种中断
		RxBuf[RxHead]=na_uart1->np_uartrxdata;               //读出接收寄存器的值//
//		na_uart1->np_uarttxdata=RxBuf[RxHead];               //反回串口显示读入的数据
		na_uart1->np_uartstatus=0;                           //清除状态寄存器，从新开始新的发送、接收
//		na_uart1->np_uartcontrol=np_uartcontrol_irrdy_mask;  //使能开接收中断
		if((++RxHead)>(RXBUFSIZE-1))                         //检查环形缓冲区是否满
		  RxHead=0;
    }
}

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

串口2的中断服务函数

****************************************************************************/
void ReceiveISRUart2(int context)
{
	unsigned int sr;
	sr=na_uart2->np_uartstatus;
	if(sr & np_uartstatus_rrdy_mask)
	{
		if(Receive_From!=2)
		  Receive_From=2;
		if(uart_use!=na_uart2)
		  uart_use=na_uart2;
//		na_uart2->np_uartcontrol=0;                          //禁止各种中断
		RxBuf[RxHead]=na_uart2->np_uartrxdata;               //读出接收寄存器的值
//		na_uart2->np_uarttxdata=RxBuf[RxHead];               //反回串口显示读入的数据
		na_uart2->np_uartstatus=0;                           //清除状态寄存器，从新开始新的发送、接收
//		na_uart2->np_uartcontrol=np_uartcontrol_irrdy_mask;  //使能开接收中断
		if((++RxHead)>(RXBUFSIZE-1))                         //检查环形缓冲区是否满
		  RxHead=0;
    }
}

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

判断发送标志位，由此决定是返回0，还是1

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

int Check_Tx_Mark_Bit()
{
	int i;
	unsigned char* Now_Read_Tail;

	Now_Ram_Read_Add=(unsigned char*)((unsigned int)BASE_ADD+(unsigned
int)((*(Tx_Head_High[Transmit_Number]))<<8)+(unsigned int)(*(Tx_Head_Low[Transmit_Number])));
	if(*Now_Ram_Read_Add==0xFD)
	{
//	  na_uart2->np_uarttxdata=0x55;
	  return 1;
    }
	else
	  if(*Now_Ram_Read_Add==0x94 ||*Now_Ram_Read_Add==0x95 ||*Now_Ram_Read_Add==0x96 ||
	     *Now_Ram_Read_Add==0x98 ||*Now_Ram_Read_Add==0x99 ||*Now_Ram_Read_Add==0xCF ||
	     *Now_Ram_Read_Add==0xc6)
	   {
		i=4;
		Now_Read_Tail=(unsigned char*)((unsigned int)BASE_ADD+(unsigned
int)((*Tx_Tail_High[Transmit_Number])<<8)+(unsigned int)(*Tx_Tail_Low[Transmit_Number]));
		while(Now_Ram_Read_Add<=Now_Read_Tail)
		{
			CheckData[i++]=*Now_Ram_Read_Add;
			Check_Ram_Read();
		}
	    return 3;
	   }
	  else
	    if(*Now_Ram_Read_Add==0xc2)
	       return 4;
	    else
	     if(*Now_Ram_Read_Add==0x86)
	     {
			i=4;
			Now_Read_Tail=(unsigned char*)((unsigned int)BASE_ADD+(unsigned
int)((*Tx_Tail_High[Transmit_Number])<<8)+(unsigned int)(*Tx_Tail_Low[Transmit_Number]));
			while(Now_Ram_Read_Add<=Now_Read_Tail)
			{
				CheckData[i++]=*Now_Ram_Read_Add;
				Check_Ram_Read();
			}
	        return 5;
	     }
	     else
	        return 2;
}

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

特征参数的处理

********************************************************************************/
void Handle_Para()
{
	int i;

	Now_Ram_Read_Add=(unsigned char*)((unsigned int)BASE_ADD+(unsigned int)
	((*Tx_Head_High[Transmit_Number])<<8)+(unsigned int)(*Tx_Head_Low[Transmit_Number]));

    for(i=0; i<17; i++)
    {
	  if(i==0)      //新中新增补标志
	   Synjones_flag=*Now_Ram_Read_Add;
	  if(i==1)
	   Synjones_detail=*Now_Ram_Read_Add;
	  if(i==12)     //本机路口编号
	   Parameter[0]=*Now_Ram_Read_Add;
	  if(i==13)
	   Parameter[1]=*Now_Ram_Read_Add;
	  if(i==14)    //对应的主机路口编号
	   Parameter[2]=*Now_Ram_Read_Add;
	  if(i==15)
	   Parameter[3]=*Now_Ram_Read_Add;
	  if(i==16)    //主从机标志，1为主机，0为从机
	   Main_Flag=*Now_Ram_Read_Add;
	  if(i==0)
	   Test_Package_Data[i]=0xf1;
	  else         //特征参数测试包赋值
	   Test_Package_Data[i]=*Now_Ram_Read_Add;
	  Check_Ram_Read();
    }
}

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

把方案信息写进ram

********************************************************************************/
void Write_Ram()
{
	int i;
	unsigned char true_number;
	unsigned char* Valid_Address;

	true_number=(CheckData[5]-1)*7+CheckData[6];
	Valid_Address=(true_number-1)*40+(unsigned char*)Conf_Solution_Address_Flash;

	memcpy(&CheckData[5],Valid_Address,40);

	CheckData[4]=0xc6;
	Data_Number=47;
	Finished_Receive=Receive_From;
	Write_Comm_to_Ram();
//	Finished_Receive=1;
}

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

往FLASH写流量、故障信息

******************************************************************************/
void Write_Flash_Flow()
{
	int flag;
	int i;
	unsigned short temp=0;
//	unsigned char flow_data[69];
	unsigned short* flow_add_temp;


	volatile unsigned short *fb  = (unsigned short *) na_cfi_flash_0_base;
	#ifdef nasys_main_flash
	  if (-1 == (int)fb)
	    fb = nasys_main_flash;
	#endif

	Now_Flow_Information_Add=(unsigned short*)read_last_flow_add();

	Now_Ram_Read_Add=(unsigned char*)((unsigned int)BASE_ADD+(unsigned int)
	((*Tx_Head_High[Transmit_Number])<<8)+(unsigned int)(*Tx_Head_Low[Transmit_Number]));
    Now_Ram_Read_End_Add=(unsigned char*)((unsigned int)BASE_ADD+(unsigned int)
	((*Tx_Tail_High[Transmit_Number])<<8)+(unsigned int)(*Tx_Tail_Low[Transmit_Number]));
	Check_Ram_Read();

	for(i=0;i<69;i++)
	{
		flow_data[i]=*Now_Ram_Read_Add;
		Check_Ram_Read();
	}
//	for(i=5;i<70;i++)
//	{
//		flow_data[i]=(i-5)%64;
//	}

//	getdataflow();
//	even_flow=read_even_flow();

	write_flow_add();

	flow_add_temp=Now_Flow_Information_Add;

	for(i=0;i<2;i++)
	{
		if((unsigned int)Now_Flow_Information_Add%0x10000==0 && Flash_Bit==0)
		{
			flag=nr_flash_erase_sector((unsigned short*)na_cfi_flash_0_base,(unsigned
short*)Now_Flow_Information_Add);
		}
		if(++Now_Flow_Information_Add==Flow_Information_End)
		  Now_Flow_Information_Add=Flow_Information_Base;
	}