main3.c

FPGA flash 编程序,使用CYCLONE和FLASH

#include <excalibur.h>
#include <math.h>
#include "flash.c"

#define RXBUFSIZE    255
#define BASE_ADD     0x800
#define FLASH_BASE_ADD  0X200000  
#define FLASH_BASE_ADD_bake 0x3fc000

#define TIME         50000000

unsigned char jj;

unsigned char RxBuf[RXBUFSIZE];
int RxHead=0;
int RxTail=0;

int First=0;

unsigned int* ResetNumber;

unsigned char Parameter[2];

unsigned char* WriteGate1;
unsigned char* WriteGate2;

int RevStatus=0;
int BeginBitContent=0;

unsigned int Now_MarkRx_Number=0;
int Data_Number=0;
unsigned short CheckByte_Write;
unsigned char CheckByte_Read;

unsigned char CheckData[600];
unsigned char Test_Package_Data[14];

unsigned char* Now_Tail_High;
unsigned char* Now_Tail_Low; 

unsigned int  Now_Tail_Add; 
unsigned int  Now_Head_Add;
unsigned char* Now_Ram_Write_Add;
unsigned char* Now_Ram_Read_Add;
unsigned char* Now_Ram_Read_End_Add;

unsigned char* Rx_Head_High[6];
unsigned char* Rx_Head_Low[6];
unsigned char* Rx_Tail_High[6];
unsigned char* Rx_Tail_Low[6];
unsigned char* Tx_Head_High[6];
unsigned char* Tx_Head_Low[6];
unsigned char* Tx_Tail_High[6];
unsigned char* Tx_Tail_Low[6];

unsigned char Rx_Head_High_test;
unsigned char Rx_Head_Low_test;
unsigned char Rx_Tail_High_test;
unsigned char Rx_Tail_Low_test;
unsigned char Now_Tail_High_test;
unsigned char Now_Tail_Low_test;

unsigned char* MarkTx[6];

//flash基地址变量
unsigned short* Conf_Phase1_Address_Flash;
unsigned short* Conf_Phase2_Address_Flash;
unsigned short* Conf_Stage_Address_Flash;
unsigned short* Conf_Controlstage_Address_Flash;
unsigned short* Conf_Daydesign_Address_Flash;
unsigned short* Conf_Daydesigntable_Address_Flash;

//flash各区域对应的缓冲区地址
unsigned char  Conf_Phase1_Address_Buffer[288];
unsigned char  Conf_Phase2_Address_Buffer[288];
unsigned char  Conf_Stage_Address_Buffer[98];
unsigned char  Conf_Controlstage_Address_Buffer[41];
unsigned char  Conf_Daydesign_Address_Buffer[74];
unsigned char  Conf_Daydesigntable_Address_Buffer[60];

//flash个区域对应的备份基地址
unsigned short* Conf_Phase1_Address_Backup;
unsigned short* Conf_Phase2_Address_Backup;
unsigned short* Conf_Stage_Address_Backup;
unsigned short* Conf_Controlstage_Address_Backup;
unsigned short* Conf_Daydesign_Address_Backup;
unsigned short* Conf_Daydesigntable_Address_Backup;

//flash中的流量存储变量地址
unsigned short* Flow_Information_Base;
unsigned short* Flow_Information_End;
unsigned short* Now_Flow_Information_Add;
//unsigned short* Flow_Information_Backup_Base;
//unsigned short* Now_Flow_Information_Backup_Add;

unsigned char WrRamTimePhase;

unsigned char Receive_From;
unsigned char Finished_Receive;

unsigned char Transmit_Number;
int transparence;
int transparence_valid;
unsigned char Valid_Data;
unsigned char Valid_Data_Number;
unsigned char Test_Bit;
int Direct_Now_Data_Length;
unsigned short Check_Temp;
unsigned char Add_Bit;
int Add_transparence;
int Add_transparence_valid;
unsigned char Flash_Bit;

np_uart* uart_use;

void TransmitComm(np_uart* uartbase);
void Transmit485();
void TransmitEnternet();
int  ReceiveComm();
int  Receive485();
int  ReceiveEnternet();

void TransmitTestPackage(np_uart* uartbase);
void Transmit_Mistake_Package(np_uart* uartbase,unsigned char mistake_mark);
void Transmit_Answer_Package(np_uart* uartbase,unsigned char answer_mark);
void Transmit_Query_Package(np_uart* uartbase,unsigned char query_mark);
void Transmit_Flow_Package(np_uart* uartbase);
void Transmit_Lai_Package(np_uart* uartbase,unsigned char mistake_mark);

int Check_Tx_Mark_Bit();
void Write_Flash();
void Write_Comm(np_uart* uartbase);
void Write_Ram();
void Write_Flash_Flow();
void Handle_Para();

void Check_Transparence();
void Check_Frame();
unsigned short Cal_Crc(unsigned char *ptr, unsigned int len);
void Write_Comm_to_Ram();
void Add_transparences();

void ReceiveISRUart1(int context);
void ReceiveISRUart2(int context);
void myisr(int context);
int leddata=0x8;
int ledd=0x3;
volatile int nnn=0;
void myisr(int context)
{
	na_led_pio->np_piodata=ledd;
	ledd=ledd^0xff;
	nnn++;
	if(nnn==15)
	{
		TransmitTestPackage(uart_use);
		nnn=0;
	}
	na_timer1->np_timerstatus=0;
}

void Check_Ram_Write();
void Check_Ram_Read();

void delay(int number);

unsigned short* Flash_Add_Sh;
unsigned char Phase_Number;
unsigned char Time_Phase;
unsigned char Green_Phase[17];

unsigned char Flash__Scheme_First[24];

unsigned short aaa,bbb;
	
int main()
{
	unsigned char* MarkRx[6];
	unsigned char* p_Rx;
	unsigned char* p_Tx;
	int context1=0;
	int context2=0;	
	int lednumber=0;
	int i=0;
	int j=0;
	int k=0;
	int m=0;
	int n=0;
	int u;
	int y;
	int flag;
	int num;
	
//	ResetNumber=(unsigned int*)0x01fc000;
//	num=*ResetNumber;
//mxl:	flag=nr_flash_erase_sector_4kB((unsigned short*)na_cfi_flash_0_base,(unsigned short*)0x200000);
//	if(flag!=0)
//	{
//	flash_reset((unsigned short*)na_cfi_flash_0_base);
//	goto mxl;
//   }
//	num++;
//	flag=nr_flash_write((unsigned short*)na_cfi_flash_0_base,(unsigned short*)0x200000,0x00);
		
//	Transmit_Answer_Package(na_uart1,0);
	
	for(y=4;y<100;y++)
	{
		CheckData[y]=0;
	}
	
	na_timer1->np_timerperiodl=(short)(TIME & 0X0000FFFF);
	na_timer1->np_timerperiodh=(short)((TIME>>16) & 0X0000FFFF);
	nr_installuserisr(na_timer1_irq,myisr,context2);
	na_timer1->np_timerstatus=0;
	na_timer1->np_timercontrol = np_timercontrol_start_mask | np_timercontrol_cont_mask | np_timercontrol_ito_mask;
	
	
	Receive_From=0;
	Finished_Receive=0;
	CheckByte_Write=0;
	CheckByte_Read=0;
	
	WriteGate1=(unsigned char*)(BASE_ADD+0x23);
	WriteGate2=(unsigned char*)(BASE_ADD+0x24);
	
	*WriteGate1=0;
	*WriteGate2=0;
	
	Now_Tail_High=(unsigned char*)(BASE_ADD+0x21);
	Now_Tail_Low =(unsigned char*)(BASE_ADD+0x22);
	
	*Now_Tail_High=(unsigned char)(0x80>>8 & 0x00ff);
	*Now_Tail_Low =(unsigned char)(0x80 & 0x00ff);
	
	Now_Tail_High_test=*Now_Tail_High;
	Now_Tail_Low_test=*Now_Tail_Low;
	
	Now_Head_Add=((unsigned int)(*Now_Tail_High)<<8)+(unsigned int)(*Now_Tail_Low);
	Now_Tail_Add=Now_Head_Add;
	Now_Ram_Write_Add=(unsigned char*)(BASE_ADD+0x80);
	Now_Ram_Read_Add=(unsigned char*)(BASE_ADD+0x80);
	Now_Ram_Read_End_Add=(unsigned char*)(BASE_ADD+0x80);
	

    //初始化关于FLASH的三个地址
    Conf_Phase1_Address_Flash=(unsigned short*)(FLASH_BASE_ADD+0x00);
    Conf_Phase2_Address_Flash=(unsigned short*)(FLASH_BASE_ADD+0x120);
    Conf_Stage_Address_Flash=(unsigned short*)(FLASH_BASE_ADD+0x242);
    Conf_Controlstage_Address_Flash=(unsigned short*)(FLASH_BASE_ADD+0xe82);
    Conf_Daydesign_Address_Flash=(unsigned short*)(FLASH_BASE_ADD+0x13a2);
    Conf_Daydesigntable_Address_Flash=(unsigned short*)(FLASH_BASE_ADD+0x1ce2);

    Conf_Phase1_Address_Backup=(unsigned short*)(FLASH_BASE_ADD_bake+0x00);
    Conf_Phase2_Address_Backup=(unsigned short*)(FLASH_BASE_ADD_bake+0x120);
    Conf_Stage_Address_Backup=(unsigned short*)(FLASH_BASE_ADD_bake+0x242);
    Conf_Controlstage_Address_Backup=(unsigned short*)(FLASH_BASE_ADD_bake+0xe82);
    Conf_Daydesign_Address_Backup=(unsigned short*)(FLASH_BASE_ADD_bake+0x13a2);
    Conf_Daydesigntable_Address_Backup=(unsigned short*)(FLASH_BASE_ADD_bake+0x1ce2);

    //初始化flash中的流量信息
	Flow_Information_Base=(unsigned short*)(FLASH_BASE_ADD+0x4000);
	Flow_Information_End=(unsigned short*)(FLASH_BASE_ADD+0x58000);
	Now_Flow_Information_Add=Flow_Information_Base;
//	Flow_Information_Backup_Base=(unsigned short*)(FLASH_BASE_ADD+0x58000);
//	Now_Flow_Information_Backup_Add=Flow_Information_Backup_Base;


	for(i=0; i<6; i++)
	{
		MarkRx[i]=(unsigned char*)(BASE_ADD+0x50+5*i);
		p_Rx=MarkRx[i];
		*p_Rx=0x87;
		MarkTx[i]=(unsigned char*)(BASE_ADD+0x30+5*i);
		p_Tx=MarkTx[i];
//		*p_Tx=0x87;
	
        Rx_Head_High[i] =(unsigned char*)(BASE_ADD+0x51+5*i);
		Rx_Head_Low[i]  =(unsigned char*)(BASE_ADD+0x52+5*i);
		Rx_Tail_High[i] =(unsigned char*)(BASE_ADD+0x53+5*i);
		Rx_Tail_Low[i]  =(unsigned char*)(BASE_ADD+0x54+5*i);
		Tx_Head_High[i] =(unsigned char*)(BASE_ADD+0x31+5*i);
		Tx_Head_Low[i]  =(unsigned char*)(BASE_ADD+0x32+5*i);
		Tx_Tail_High[i] =(unsigned char*)(BASE_ADD+0x33+5*i);
		Tx_Tail_Low[i]  =(unsigned char*)(BASE_ADD+0x34+5*i);
		
	}

    delay(1000);
	Data_Number=7;
	CheckData[0]=0x00;
	CheckData[1]=0x00;
	CheckData[2]=0x00;
	CheckData[3]=0x00;
	CheckData[4]=0x82;
	CheckData[5]=0x00;
	CheckData[6]=0x00;	
	Write_Comm_to_Ram();			
	Finished_Receive=1;		
	
	Parameter[0]=0x00;
	Parameter[1]=0x00;
	
	nr_installuserisr(na_uart1_irq,ReceiveISRUart1,context1);
//	nr_installuserisr(na_usrt2_irq,ReceiveISRUart2,context2);
	na_uart1->np_uartcontrol=np_uartcontrol_irrdy_mask;
//	na_uart2->np_uartcontrol=np_uartcontrol_irrdy_mask;	
	
	while(1)
	{
		if(!ReceiveComm())
		  break;
		
//		if(na_timer1->np_timerstatus & np_timerstatus_to_mask)
//		{
            lednumber++;
            if(lednumber==50000000)
//			na_led_pio->np_piodata=leddata&ledd;;
			leddata=0x8;
//			if(leddata==0x10)
//			  leddata=0x2;
//			if(lednumber==10)
//			{
//			TransmitTestPackage(uart_use);
 //              lednumber=0;
//			}
			  
//			na_timer1->np_timerstatus=0;
//		}
		
		p_Tx=MarkTx[j];
		switch(*p_Tx)
		{
			case 1 :
			  Transmit_Number=j;
			  uart_use=na_uart1;
			  TransmitComm(uart_use);
			 break;
			case 2 :
			  Transmit_Number=j;
			  uart_use=na_uart1;
//			  TransmitComm(uart_use);
			 break;
			case 3 :
			  Transmit_Number=j;
			  Transmit485();
			 break;
			case 4 :
			  Transmit_Number=j;
			  TransmitEnternet();
			 break;
			case 87 :
			 break;
			default :
			  //error
			 break;
		}
		if(++j==6)
		  j=0;
		
		switch(Finished_Receive)
		{
			case 1 :
			  *MarkRx[Now_MarkRx_Number]=1;
			if(++Now_MarkRx_Number==6)
		         Now_MarkRx_Number=0;
		     Finished_Receive=0;
			 break;
			case 2 :
			  *MarkRx[Now_MarkRx_Number]=2;	
			if(++Now_MarkRx_Number==6)
		         Now_MarkRx_Number=0;
		     Finished_Receive=0;	 
			 break;
			case 3 :
			  *MarkRx[Now_MarkRx_Number]=3;	
			if(++Now_MarkRx_Number==6)
		         Now_MarkRx_Number=0;
		     Finished_Receive=0;	
			 break;
			case 4 :
			  *MarkRx[Now_MarkRx_Number]=4;
			if(++Now_MarkRx_Number==6)
		         Now_MarkRx_Number=0;
		     Finished_Receive=0;
			 break;
			default :
			  *MarkRx[Now_MarkRx_Number]=0x87;
			 break;
		}
	}
}

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

延迟函数

**************************************************************************/
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 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;