bios的看门狗功能

1 DSP部分

1.1 初始化系统，时钟问题

这部分分为三个步骤：关看门狗 设置时钟 打开外设时钟

1.1.1 关看门狗

void DisableDog(void)
{
    EALLOW;
    SysCtrlRegs.WDCR= 0x0068;
    EDIS;
}

向寄存器写入0X0068，完成操作

1.1.2 设置时钟(主频)

如图可以看出，芯片时钟是这样的：外部晶振输入，由PLLSTS（OSCOFF选择是否输入，再选择是OSCCLK还是从PLL输入，若是PLL输入，则受PLLSTS(PLLOFF选择使能，PLLCR（DIV选择倍频，PLLSTS（DIVSEL选择分频

InitPll(DSP28_PLLCR,DSP28_DIVSEL);

设置倍频系数和分频系数

if (SysCtrlRegs.PLLSTS.bit.DIVSEL != 0)
 {
   EALLOW;
   SysCtrlRegs.PLLSTS.bit.DIVSEL = 0;
   EDIS;
 }

在写入PLLCR前，PLLSTS（DIVSEL）必须为0，而只有当 PLLSTS[PLLOCKS]=1 时才应被改变。

在 PLL 输出上的分频器是必须的以确保馈入内核的时钟的正确占空比。 出于这个原因， 当 PLL 处于激活状态时， DIVSEL 值不许为 3。

一般使用PLL模式，非零值N=10，DIVSEL=2，CLKIN=30M*10/2=150M

1.1.2 设置外设时钟

SysCtrlRegs.HISPCP.all = 0x0001;
   SysCtrlRegs.LOSPCP.all = 0x0002;

高速时钟：75M

低速时钟：32.5M

XintfRegs.XINTCNF2.bit.XTIMCLK = 1;
   XintfRegs.XINTCNF2.bit.CLKMODE = 1;
   XintfRegs.XINTCNF2.bit.CLKOFF = 0;

XTIMCLK=75M

XCLKOUT=32.5M

SysCtrlRegs.PCLKCR0.bit.SPIAENCLK  = 1;   // SPI-A
   SysCtrlRegs.PCLKCR3.bit.DMAENCLK = 1;       // DMA Clock
   SysCtrlRegs.PCLKCR3.bit.XINTFENCLK = 1;     // XTIMCLK
   SysCtrlRegs.PCLKCR3.bit.GPIOINENCLK = 1;    // GPIO input clock
   SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 0;   // Disable TBCLK within the ePWM
   SysCtrlRegs.PCLKCR1.bit.EPWM1ENCLK = 1;  // ePWM1
   SysCtrlRegs.PCLKCR1.bit.EPWM2ENCLK = 1;  // ePWM2
   SysCtrlRegs.PCLKCR1.bit.EPWM3ENCLK = 1;  // ePWM3
   SysCtrlRegs.PCLKCR1.bit.EPWM4ENCLK = 1;  // ePWM4
   SysCtrlRegs.PCLKCR1.bit.EPWM5ENCLK = 1;  // ePWM5
   SysCtrlRegs.PCLKCR1.bit.EPWM6ENCLK = 1;  // ePWM6
   SysCtrlRegs.PCLKCR0.bit.TBCLKSYNC = 1;   // Enable TBCLK within the ePWM

打开SPIA、EPWM、DMA、GPIO、XTIMCLK时钟

SPIA的时钟为LSPCLK=32.5M

1.2 初始化外部接口的GPIO

void InitXintf16Gpio()
{
     EALLOW;
     GpioCtrlRegs.GPCMUX1.bit.GPIO64 = 3;  // XD15
     GpioCtrlRegs.GPCMUX1.bit.GPIO65 = 3;  // XD14
     GpioCtrlRegs.GPCMUX1.bit.GPIO66 = 3;  // XD13
     GpioCtrlRegs.GPCMUX1.bit.GPIO67 = 3;  // XD12
     GpioCtrlRegs.GPCMUX1.bit.GPIO68 = 3;  // XD11
     GpioCtrlRegs.GPCMUX1.bit.GPIO69 = 3;  // XD10
     GpioCtrlRegs.GPCMUX1.bit.GPIO70 = 3;  // XD19
     GpioCtrlRegs.GPCMUX1.bit.GPIO71 = 3;  // XD8
     GpioCtrlRegs.GPCMUX1.bit.GPIO72 = 3;  // XD7
     GpioCtrlRegs.GPCMUX1.bit.GPIO73 = 3;  // XD6
     GpioCtrlRegs.GPCMUX1.bit.GPIO74 = 3;  // XD5
     GpioCtrlRegs.GPCMUX1.bit.GPIO75 = 3;  // XD4
     GpioCtrlRegs.GPCMUX1.bit.GPIO76 = 3;  // XD3
     GpioCtrlRegs.GPCMUX1.bit.GPIO77 = 3;  // XD2
     GpioCtrlRegs.GPCMUX1.bit.GPIO78 = 3;  // XD1
     GpioCtrlRegs.GPCMUX1.bit.GPIO79 = 3;  // XD0

     GpioCtrlRegs.GPBMUX1.bit.GPIO40 = 3;  // XA0/XWE1n
     GpioCtrlRegs.GPBMUX1.bit.GPIO41 = 3;  // XA1
     GpioCtrlRegs.GPBMUX1.bit.GPIO42 = 3;  // XA2
     GpioCtrlRegs.GPBMUX1.bit.GPIO43 = 3;  // XA3
     GpioCtrlRegs.GPBMUX1.bit.GPIO44 = 3;  // XA4
     GpioCtrlRegs.GPBMUX1.bit.GPIO45 = 3;  // XA5
     GpioCtrlRegs.GPBMUX1.bit.GPIO46 = 3;  // XA6
     GpioCtrlRegs.GPBMUX1.bit.GPIO47 = 3;  // XA7

     //后加的
     GpioCtrlRegs.GPBMUX2.bit.GPIO54 = 3;
     GpioCtrlRegs.GPBMUX2.bit.GPIO55 = 3;
     GpioCtrlRegs.GPBMUX2.bit.GPIO56 = 3;
     GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 3;

     GpioCtrlRegs.GPCMUX2.bit.GPIO80 = 3;  // XA8
     GpioCtrlRegs.GPCMUX2.bit.GPIO81 = 3;  // XA9
     GpioCtrlRegs.GPCMUX2.bit.GPIO82 = 3;  // XA10
     GpioCtrlRegs.GPCMUX2.bit.GPIO83 = 3;  // XA11
     GpioCtrlRegs.GPCMUX2.bit.GPIO84 = 3;  // XA12
     GpioCtrlRegs.GPCMUX2.bit.GPIO85 = 3;  // XA13
     GpioCtrlRegs.GPCMUX2.bit.GPIO86 = 3;  // XA14
     GpioCtrlRegs.GPCMUX2.bit.GPIO87 = 3;  // XA15
     GpioCtrlRegs.GPBMUX1.bit.GPIO39 = 3;  // XA16
     GpioCtrlRegs.GPAMUX2.bit.GPIO31 = 3;  // XA17
     GpioCtrlRegs.GPAMUX2.bit.GPIO30 = 3;  // XA18
     GpioCtrlRegs.GPAMUX2.bit.GPIO29 = 3;  // XA19


     GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 3;  // XREADY
	 GpioCtrlRegs.GPBMUX1.bit.GPIO35 = 3;  // XRNW
     GpioCtrlRegs.GPBMUX1.bit.GPIO38 = 3;  // XWE0

     GpioCtrlRegs.GPBMUX1.bit.GPIO36 = 3;  // XZCS0
     GpioCtrlRegs.GPBMUX1.bit.GPIO37 = 3;  // XZCS7
     GpioCtrlRegs.GPAMUX2.bit.GPIO28 = 3;  // XZCS6

     EDIS;
}

数据线，XD0-15

地址线：XA0-XA19,

控制线：XREADY、XR/W、XWE0、XZCS0、 XZCS7、XZCS6

1.4 初始化SPIA接口的GPIO

void InitSpiaGpio()
{

    EALLOW;
    GpioCtrlRegs.GPBPUD.bit.GPIO54 = 0;   // Enable pull-up on GPIO54 (SPISIMOA)
    GpioCtrlRegs.GPBPUD.bit.GPIO55 = 0;   // Enable pull-up on GPIO55 (SPISOMIA)
    GpioCtrlRegs.GPBPUD.bit.GPIO56 = 0;   // Enable pull-up on GPIO56 (SPICLKA)
    GpioCtrlRegs.GPBPUD.bit.GPIO57 = 0;   // Enable pull-up on GPIO57 (SPISTEA)
    GpioCtrlRegs.GPBQSEL2.bit.GPIO54 = 3; // Asynch input GPIO54 (SPISIMOA)
    GpioCtrlRegs.GPBQSEL2.bit.GPIO55 = 3; // Asynch input GPIO55 (SPISOMIA)
    GpioCtrlRegs.GPBQSEL2.bit.GPIO56 = 3; // Asynch input GPIO56 (SPICLKA)
    GpioCtrlRegs.GPBQSEL2.bit.GPIO57 = 3; // Asynch input GPIO57 (SPISTEA)
    GpioCtrlRegs.GPBMUX2.bit.GPIO54 = 1; // Configure GPIO54 as SPISIMOA
    GpioCtrlRegs.GPBMUX2.bit.GPIO55 = 1; // Configure GPIO55 as SPISOMIA
    GpioCtrlRegs.GPBMUX2.bit.GPIO56 = 1; // Configure GPIO56 as SPICLKA
    GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 0; // Configure GPIO57 as SPISTEA
    //GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 1;
   EDIS;
}

上拉、功能选择、采样间隔时间

1.4.1 GPIO的配置

void gpio_config(void)
{
	EALLOW;
	 GpioCtrlRegs.GPBDIR.bit.GPIO57 = 1;//输出
	 GpioCtrlRegs.GPBDIR.bit.GPIO56 = 0;//输入
	 GpioCtrlRegs.GPAMUX1.bit.GPIO0 = 0;//普通io
	 GpioCtrlRegs.GPADIR.bit.GPIO0 = 1;//输出

	 EDIS;
}

时钟为输入。片选为输出，GPIO0为普通IO

1.5 中断初始化

DINT;
InitPieCtrl();
IER = 0x0000;
IFR = 0x0000;
InitPieVectTable();

1.6 SPI初始化

void spi_init()
{
	SpiaRegs.SPICCR.bit.SPISWRESET = 0;//
	SpiaRegs.SPICCR.all = 0x0047;		//The SPI software resets the polarity bit
											//to 1 (sending data along the falling edge),
											//moving in and out of the 8 bit word length each time,
											//and prohibiting the SPI internal loopback (LOOKBACK) function;

	SpiaRegs.SPICTL.all = 0x0006;		// 0111 Enable master mode, normal phase, // enable talk, and SPI int disabled.
	SpiaRegs.SPISTS.all = 0x0000;		//溢出中断，禁止SPI中断；
	SpiaRegs.SPIBRR = 0x001F;			//SPI波特率=37.5M/24=1.5MHZ；
	SpiaRegs.SPIPRI.bit.FREE = 1;		//Set so breakpoints don't disturb xmission
	SpiaRegs.SPIFFTX.bit.SPIFFENA = 0;
	SpiaRegs.SPICCR.bit.SPISWRESET = 1;
}

先将SPICCR寄存器的SPISWRESET置零，然后操作，然后置1

SPICCR=0x0047 =1000 0111

SPISWRESET=1;复位失效

CLOCK POLARITY=0;上升沿输出，下降沿接收。与CLOCK PHASE共同作用组成4种SPI工作模式

SPILBK=0;回环模式关

低四位为字节长度选择位：0111，表示为8位的字节长度

SPICTL=0x0006=0000 0110

第0位：关闭中断使能

第1位：使能4针传输

第2位：主机模式

第3位：无时钟延时

第4位：关闭中断

SpiaRegs.SPISTS.all = 0x0000; 写零

SPIBRR=0x001f=32.5/25=1.3MHz波特率

SpiaRegs.SPIPRI.bit.FREE = 1; SPI持续运行 SpiaRegs.SPIFFTX.bit.SPIFFENA = 0; 关FIFO

1.7 复位W5500

void Reset_W5500(void)
{
	GpioDataRegs.GPADAT.bit.GPIO0 = 0;
	delay_loop();
	GpioDataRegs.GPADAT.bit.GPIO0 = 1;
	delay_loop();
}

1.8 设置默认MAC、IP、GW、SUB、DNS

uint8 mac[6]={0x00,0x08,0xdc,0x11,0x11,0x12};
  uint8 lip[4]={192,168,1,150};
  uint8 sub[4]={255,255,255,0};
  uint8 gw[4]={192,168,1,1};
  uint8 dns[4]={8,8,8,8};
  memcpy(ConfigMsg.lip, lip, 4);
  //printf("lip: %d.%d.%d.%d\r\n",lip[0],lip[1],lip[2],lip[3]);
  memcpy(ConfigMsg.sub, sub, 4);
 // printf("sub: %d.%d.%d.%d\r\n",sub[0],sub[1],sub[2],sub[3]);
  memcpy(ConfigMsg.gw,  gw, 4);
  //printf("gw: %d.%d.%d.%d\r\n",gw[0],gw[1],gw[2],gw[3]);
  memcpy(ConfigMsg.mac, mac,6);

  memcpy(ConfigMsg.dns,dns,4);
  //printf("dns: %d.%d.%d.%d\r\n",dns[0],dns[1],dns[2],dns[3]);

1.9 设置网络，也就是设置W5500的寄存器

void set_network(void)			// 配置初始化IP信息并打印，初始化8个Socket
{
  uint8 ip[4];
  setSHAR(ConfigMsg.mac);
  //printf("mac:");
  setSUBR(ConfigMsg.sub);
  setGAR(ConfigMsg.gw);
  setSIPR(ConfigMsg.lip);

  sysinit(txsize, rxsize); 											// 初始化8个socket
  setRTR(2000);														// 设置超时时间
  setRCR(3);														// 设置最大重新发送次数
  
  getSIPR (ip);
  printf("IP : %d.%d.%d.%d\r\n", ip[0],ip[1],ip[2],ip[3]);
  getSUBR(ip);
  printf("SN : %d.%d.%d.%d\r\n", ip[0],ip[1],ip[2],ip[3]);
  getGAR(ip);
  printf("GW : %d.%d.%d.%d\r\n", ip[0],ip[1],ip[2],ip[3]);
}

到这一步后，W5500和上位机就能够连接了

初始化Socket大小，8个，每个都是2k

设置超时时间和最大发送次数，都是对寄存器设置

1.10 while(1)函数，switch语句

读取W5500的四种状态，分别是SOCK_CLOSED、SOCK_INIT、SOCK_ESTABLISHED、SOCK_CLOSE_WAIT

读取到的第一个状态是 SOCK_CLOSED

然后进行模式设置，设置为TCP/IP模式

socket(0,Sn_MR_TCP,local_port,Sn_MR_ND);

主要是对Sn_MR寄存器进行操作

0-3位设置为0001

第五位设置为1，无延时。

IINCHIP_WRITE(Sn_PORT0(s) ,(uint8)((local_port & 0xff00) >> 8));
 IINCHIP_WRITE(Sn_PORT1(s) ,(uint8)(local_port & 0x00ff));

对通道0的端口设置

IINCHIP_WRITE( Sn_CR(s) ,Sn_CR_OPEN); // run sockinit Sn_CR

写入OPEN命令

此时：

Sn_SR变为0x13,也就是SOCK_INT

case SOCK_INIT://第二步，初始化，连接服务器
connect(0, server_ip,server_port);
	break;

初始化状态后，使用连接命令

就是连接到服务器的ip和端口，说明该通道是用做客户端模式

如果是监听，则是服务器模式

连接命令成功后，SN_SR会变为0x17，也就是SOCK_ESTABLISHED状态，此时就可以使用send和receive命令了

1.11 选中establish后的程序

if(getSn_IR(0) & Sn_IR_CON)
{
	setSn_IR(0, Sn_IR_CON);
}

读取Sn_IR的值，判断是否为Sn_IR_CON，

然后再将Sn_IR_CON写入Sn_IR

本质是一个中断清零的问题

清零后，读取Sn_RX_RSR寄存器的值，空闲接收缓存寄存器

len=getSn_RX_RSR(0);//读取接收缓存的字节大小

若有数据

先将buffer，buffer16两个数组清零，一个是8位，一个是16位

recv(0,buffer,len);//将W5500的数据写入数组buffer

使用recv命令将W5500接收到的上位机传过来的数据，写入buffer数组里面
8位8位的数据

for(i=0,j=0;j<1024;i++,j++)//将buffer的八位的数据转换成buffer16数组的16位数据
{
	temp1=buffer[i];
    temp1=(temp1<<8);
    temp1=temp1&0xff00;
    temp2=buffer[i+1];
    i++;
  	temp2=temp2&0x00ff;
  	buffer16[j]=temp1|temp2;
}

将buffer里面的8位的数据，存到buffer16中，将8位一个数据转成16位一个的数据

1.12 涉及到FPGA操作的数据

以上都是一个处理的过程，从这儿开始，赋予数据实际的意义
上位机传过来的数据会有一个头，表示数据的开始

for(i=0;i<1024;i++)		//检查数据开头，我觉得用while函数较好，但是要计数
  	{
  	  	if(buffer16[i]==0xaa)
  	  		{
  	  			tempstart=i+1;
  	  			break;
  	  		}
  	}

将接下来的7个16位数据写入cmddata[]数组

delaytime=cmddata[1]*100;		//cmddata[1]代表延时时间
downdata=(uint16 *)0xC000;

for(i=0;i<cmddata[6];i++)		//cmddata[6]代表后面还有多少个字的命令
{
*downdata=buffer16[tempstart];	//将cmddata[6]个数据从0xC000开始写，到0x8000+cmddata[6]
downdata++;
tempstart++;
}

至此，所有的命令已经到了相应位置分别是：
0xaa cmddata[0]…cmddata[6] downdata[0]…downdata[cmddata[6]-1]
共有cmddata[6]+8 个16位数据构成一个井下仪器命令

将downdata的指针复位

至此开始对FPGA进行操作，每一个操作都会在FPGA里面有实际的意义，需要和FPGA部分一起看

downdata=(uint16 *)0xC000;//指针复位

*wrctrl=0x1f1;		//对寄存器wrctrl进行设置，具体需要看fpga程序才能确定
status_edib=*rdstatus;			//读寄存器rdstatus
while(checkbit16(status_edib,0)==1)			//最后一位为1时
{
     status_edib=*rdstatus;
}
*wrcmd=cmddata[0];		//将cmddata[0]的数据写入wrcmd地址

对写控制寄存器wrctrl写入1 111 0001
读取rdstatus的值，当他的第0位不为1时进行下一步
将cmddata[0]的数据写到wrcmd

for(i=0;i<cmddata[6];i++)//在每一次rdstatus的最后一位为1时，将downdata的数据写入wrdata
    {
        status_edib=*rdstatus;
        while(checkbit16(status_edib,0)==1)
        {
          status_edib=*rdstatus;
        }
       temp=*downdata;
       *wrdata=temp;
       downdata++;
    }

在rdstatus最后一位不为1时，将downdata的数据写入wrdata

for(z=0;z<delaytime;z++)
  	{
  	  	for(j=0;j<35;j++)
  	  		 {
  	  			asm(" nop ");
  	  		}
  	  	 asm(" nop ");
  	}
if(cmddata[2]!=0)	//要看wrcmd的含义是什么，才能知道cmddata[0],[2]的用处
  	 {
  	  		status_edib=*rdstatus;
  	  		while(checkbit16(status_edib,0)==1)
  	  			 {
  	  				 status_edib=*rdstatus;
  	  			}
  	  		 *wrcmd=cmddata[2];
  	  			 }

延时后，将cmddata[2]的数据写入wrcmd

/******** wait for encode  *******/
       status_edib=*rdstatus;											//rdstatus=xxxxx10x时，说明解码完成
  while((checkbit16(status_edib,1)==0))
  {
      status_edib=*rdstatus;
 }
    status_edib=*rdstatus;
    while((checkbit16(status_edib,2)!=0))
    {
        status_edib=*rdstatus;
    }
    status_edib=*rdstatus;
/****************************************

当//rdstatus=xxxxx10x时，说明解码完成

对wrctrl写入1 1111 1010
对上来的数据存到哪儿进行定义
将三个通道的数据依次写入定义的外扩ram的地址处

*wrctrl=0x1fc;																		//wrctrl是个很重要的寄存器，需要从fpga弄懂
extram=(Uint32 *)0x200000;
extram2=(Uint32 *)0x200000;
extram5=(Uint32 *)(0x200000+cmddata[3]*2);
extram7=(Uint32 *)(0x200000+cmddata[3]*2+cmddata[4]*2);
timeout_num=0;
while((m2<cmddata[3]||m5<cmddata[4]||m7<cmddata[5])&&(timeout_num<2000))
{
   status_edib=*rdstatus;
   if(checkbit16(status_edib,1)==0)
   {
     temp=*rdm2fifo;
     *extram2=temp;
     m2++;
     *extram2++;
     timeout_num=0;
   }
   if(checkbit16(status_edib,5)==0)
   {
     temp=*rdm5fifo;
     *extram5=temp;
     m5++;
     *extram5++;
     timeout_num=0;
   }
   if(checkbit16(status_edib,7)==0)
   {
      temp=*rdm7fifo;
      *extram7=temp;
      m7++;
      *extram7++;
      timeout_num=0;
   }
   if((checkbit16(status_edib,1)!=0)&&(checkbit16(status_edib,5)!=0)&&(checkbit16(status_edib,7)!=0))
   {
      for(i=0;i<30;i++)
      {
         asm(" nop ");
      }
      timeout_num++;
   }
}
//数据已经到了0x200000
num=m2+m5+m7;

然后再从外扩ram中读取数据，将16位的数据分为8个数据写入buffer中，每2048个8位数据传输一次

for(i=0,j=0;i<num;i++)
      {
         temp32=*extram;
         temp32=(Uint16)temp32;
         temp321=temp32>>8;
         temp322=temp32&0xff;
         buffer[j]=temp321;
         j++;
         buffer[j]=temp322;
         j++;
         *extram++;
         if(j==2048)
         {
        	send(0,buffer,2048);
        	j=0;
        	memset(buffer,0,sizeof(buffer));
         }
      }
	send(0,buffer,2048);
	}

至此完成DSP的内容，再对CMD文件，已经存储映射进行说明

1.13 CMD文件及存储映射

主要需要我们自己设置的其实只有3个区域，其他的都是和本来文件一致的

1：下发的数据存储区域，就是给井下仪器的命令，主要存储在0xC000~0xF000

这是在片内的

RAML       : origin = 0x008000, length = 0x004000

2:FPGA外扩的区域，选择的是外扩分区XINTF Zone0 0x4000-0x5000,片选信号线为XZCS0

`ZONE0: origin = 0x004000, length = 0x001000   /* XINTF zone 0 - data space`

3:SRAM的外扩区域，选择的是外扩分区XINTF Zone7 0x200000~0x300000.片选信号线为XZCS7

ZONE7B : origin = 0x200000, length = 0x010000 /* XINTF zone 7 - data space */

1.14 信号线与地址线的有效时间（有效周期）

由1.1.2的分析已经知道了，XTIMCLK=75M

上文分析了，主要存储区域用了3个区域，现在主要说明两个片外得区域

Xintf Zone0 ，区域：0x004000-0x005000

在xintf.c中配置

首先对所有分区配置：

XintfRegs.XINTCNF2.bit.XTIMCLK = 1;
// No write buffering
XintfRegs.XINTCNF2.bit.WRBUFF = 0;
// XCLKOUT is enabled
XintfRegs.XINTCNF2.bit.CLKOFF = 0;
// XCLKOUT = XTIMCLK/2
XintfRegs.XINTCNF2.bit.CLKMODE = 0;

如上图，XTIMCLK=75MXCLKOUT=32.5M

1.14.1 接下来配置Zone 0

// Zone 0------------------------------------
    // When using ready, ACTIVE must be 1 or greater
    // Lead must always be 1 or greater
    // Zone write timing
    XintfRegs.XTIMING0.bit.XWRLEAD = 3;
    XintfRegs.XTIMING0.bit.XWRACTIVE = 3;
    XintfRegs.XTIMING0.bit.XWRTRAIL = 3;
    // Zone read timing
    XintfRegs.XTIMING0.bit.XRDLEAD = 3;
    XintfRegs.XTIMING0.bit.XRDACTIVE = 3;
    XintfRegs.XTIMING0.bit.XRDTRAIL = 3;
    // double all Zone read/write lead/active/trail timing
    XintfRegs.XTIMING0.bit.X2TIMING = 1;
    // Zone will sample XREADY signal
    XintfRegs.XTIMING0.bit.USEREADY = 0;
    // Size must be either:
    // 0,1 = x32 or
    // 1,1 = x16 other values are reserved
    XintfRegs.XTIMING0.bit.XSIZE = 3;

16位数据长度，不使用READY信号，LEAD、ACTIVE、TRAIL的长度都为6个XTIMCLK周期，也就是6个 75M的周期=12.5M，也就是 6/75M 秒

读和写的周期是一样的，由于分区是对FPGA进行操作的，所以周期比较长

1.14.2 接下来配置Zone 7

Zone 7 是外扩RAM的信号

// Zone 7------------------------------------
// When using ready, ACTIVE must be 1 or greater
// Lead must always be 1 or greater
// Zone write timing
XintfRegs.XTIMING7.bit.XWRLEAD = 1;
XintfRegs.XTIMING7.bit.XWRACTIVE = 1;
XintfRegs.XTIMING7.bit.XWRTRAIL = 1;
// Zone read timing
XintfRegs.XTIMING7.bit.XRDLEAD = 1;
XintfRegs.XTIMING7.bit.XRDACTIVE = 1;
XintfRegs.XTIMING7.bit.XRDTRAIL = 1;

// double all Zone read/write lead/active/trail timing
XintfRegs.XTIMING7.bit.X2TIMING = 0;

// Zone will sample XREADY signal
XintfRegs.XTIMING7.bit.USEREADY = 0;


// Size must be either:
// 0,1 = x32 or
// 1,1 = x16 other values are reserved
XintfRegs.XTIMING7.bit.XSIZE = 3;

上面提到过的就不提了，他的周期就为1个XTIMCLK周期

1.14.3 BANK信号

XintfRegs.XBANK.bit.BANK = 4;
XintfRegs.XBANK.bit.BCYC = 0;

Zone 0 是比较慢的，所以BANK 选 Zone 0，给它4个周期去缓冲一下

具体作用参考 28335的XINTF的文档以下是数据总线和地址总线的读和写的参考时序