hldkzqv12.c

LED照明行业地砖及护栏控制器程序 从现况来看

    DestBuf = Dst;
	FPGH=(page/256)&0x06;FPGL=5;
	XBYTE[0x8555]=0Xaa;
	FPGL=2;
	XBYTE[0x8aaa]=0x55;
	FPGL=5;
	XBYTE[0x8555]=0Xa0;
	FPGH=page/256;FPGL=page%256;
	*DestBuf=Src;
    Check_Toggle_Ready(DestBuf);    /* wait for TOGGLE bit to get ready */
}


/************************************************************************/
/* PROCEDURE:   Program_One_Sector                                      */
/*                                                                      */
/* This procedure can be used to program a total of 4096 bytes of data  */
/* to the SST39VF016.                                                   */
/*                                                                      */
/* NOTES: 1. It is necessary to first erase the sector before the	*/
/*        programming.                                			*/
/*        2. This sample code assumes the destination address passed	*/
/*        from the calling function is the starting address of the	*/
/*        sector.							*/
/*                                                                      */
/* Input:                                                               */
/*           Src     SOURCE address containing the data which will be   */
/*                   written to the 39VF016                             */
/*           Dst     DESTINATION address which will be written with the */
/*                   data passed in from Src                            */
/*                                                                      */
/* Output:                                                              */
/*           None                                                       */
/************************************************************************/

void Program_One_Sector (uint Dst)
{
        uchar xdata *SourceBuf;
        uchar xdata *DestBuf;

        uint Index;
		page=Dst;
        SourceBuf = 0x1000;
        DestBuf = 0x8000;

        Erase_One_Sector(Dst);          /* erase the sector first */

        for (Index = 0; Index < 4096; Index++)
	        {
			Program_One_Byte( *SourceBuf, DestBuf);
			DestBuf++;
			SourceBuf++;
        	}
}

//***********************************************
//			接收数据
//************************************************
void rece_picture(bit type)
{
uchar i;
uchar xdata *op;
uchar idata *sp;	//0x1000 test 0x1000
//FPGH=send_buf[4];
//FPGL=send_buf[3];
if(type)
	op=(send_buf[5]*64);
else
	op=(send_buf[5]*64)|0x1000;

sp=&send_buf[8];
for(i=0;i<64;i++)*op++=*sp++;	//写入RAM 1000H 单元 位图数据
}
//********************************************
void	delay1s()
{
uint i,j;
for(i=0;i<0xfff;i++)
	{for(j=0;j<0x8;j++);
	wdgclr=!wdgclr;
	}
}
//***********************************************
void test()
{
//uchar xdata *rp;
uchar xdata *p;
//uchar xdata *sp;
p=0x0000;
memset(p,0x00,1024);
delay1s();//1	
p=0x0000;
memset(p,255,255);
delay1s();  //4

p=0x0100;
memset(p,255,255);
delay1s();  //4

p=0x0200;
memset(p,255,255);
delay1s();//8

p=0x0300;
memset(p,255,255);
delay1s();//15
/*
p=0x0000;
memset(p,0x00,1024);
p=0x1000;
memset(p,0x80,4096);
Program_One_Sector(0);
delay1s();//1	

FPGH=0;FPGL=0;
p=0x0000;
sp=0x8000;
rp=memcpy(p,sp,255);
delay1s();//1	
p=0x0100;
sp=0x8100;
rp=memcpy(p,sp,255);
delay1s();//1
p=0x0200;
sp=0x8200;
rp=memcpy(p,sp,255);
delay1s();//1
p=0x0300;
sp=0x8300;
rp=memcpy(p,sp,255);
delay1s();//1XS
*/
}

/*
************************************
	通讯协议解析			接收数据
*******************************************8
*/
void receive(void)
{
uchar *p;
wdgclr=!wdgclr;
/*
uchar xdata *p;
uchar xdata *rp;
uchar xdata *sp;*/
switch(send_buf[2])//命令标志
	{
	case 1:rec_sta=1;TR0=0;//进入接收状态
		break;	
	case 2:			//接收数据
		rece_picture(0);
		break;	
	case 0:			//加载某一帧数据到显存
		dis_page=send_buf[4]*256+send_buf[3];
		load_data(dis_page);
		break;	
	case	3:		//将一扇区数据写闪存
		Program_One_Sector(send_buf[4]*256+send_buf[3]);
		break;
	case	4:		//测试
		test();
		break;
	case 5:		//接收到显存
		rece_picture(1);
	case 6:		//同步信号
		dis_page=send_buf[4]*256+send_buf[3];
		ms=0;
	break;
	case 7:			//进入自动播放
		page_sta=send_buf[4]*256+send_buf[3];
		dis_page=page_sta;
		page_end=send_buf[6]*256+send_buf[5];
		send_buf[7]=0xaa;
		zhepe=100/send_buf[8];
		p=&send_buf[3];
		Write24c02(p,0,6);
		ms=0;
		TR0=1;
	break;
	case 8:
		Erase_One_Sector (send_buf[4]*256+send_buf[3]);
	break;
	default:break;
	}
}



//********************************************
//					 主程序
//********************************************
void main()
{
uchar Temp[6];
uchar *p;
PS=1;
ES=0;
SM0=1;
SM1=1;
T2CON=0X30;
RCAP2H=0XFF;
TH2=0XFF;
RCAP2L=0Xfb;	//9600bps= c4  115200bps =fb 57600= f6 19200 = e2
TL2=0Xfb;
TR2=1;

REN=1;
TMOD=0x05;	//定时器0 模式1 外部时钟
//TMOD=0x01;	//定时器0 模式1 外部时钟
TL0=V_TL0;
TH0=V_TH0;
//TR0=1;
ET0=1;
ES=1;
EA=1;
SM2=1;
ADD=(~P1)&0x1f;
//ADD=1;
frameok=0;
test();
p=&Temp[0];
Read24c02(p,0,6);
if(Temp[4]==0xaa)
	{
	page_sta=Temp[1]*256+Temp[0];
	page_end=Temp[3]*256+Temp[2];
	dis_page=page_sta;
	zhepe=100/Temp[5];
	TR0=1;
	}
while(1)
	{
	wdgclr=!wdgclr;
	if(timout)
		{load_data(dis_page);dis_page++;timout=0;
		if(dis_page>page_end)dis_page=page_sta;
		}

	if(frameok)
		{receive();frameok=0;}
	}//while(1)
}
/************************************************/
void send_delay( void)
{
uint	Count;
for (Count=0;Count<=200;Count++);

}
//*****************************************
//			串口中断服务程序
//*****************************************
void send(void) interrupt  4 
{
uchar d;
if(!TI && RI && !frameok)
 {RI=0;
  d=SBUF;
	if(pointer==0)
    	{if(d==ADD)
			{subchk=d;send_buf[0]=d;TB8=1;senden=1;
			send_delay();SBUF=d;while(!TI);TI=0;send_delay();
			senden=0;SM2=0;TB8=0;pointer++;}//71
		else if(d==0xff)
			{subchk=d;SM2=0;pointer++;}
			
     	}
  else 
		{if(pointer==72)
       	{send_buf[pointer]=d;
			if(d==subchk)
				{senden=1;send_delay();SBUF=subchk;while(!TI);send_delay();senden=0;TI=0;frameok=1;}
			else
				{senden=1;send_delay();SBUF=~subchk;while(!TI);send_delay();TI=0;senden=0;}
			SM2=1;pointer=0;
			}
     	else
          {send_buf[pointer]=d;subchk+=d;pointer++;}
		}        
  }//end if
}
//*************************************
void timer1() interrupt  1  
{TL0=V_TL0;
TH0=V_TH0;
ms++;
if(ms>zhepe)
	{timout=1;
	ms=0;
	}
}