2410lib.cpp

可以在linux和wince下运行

                else
                    result = (result<<4) + string[i] - 'a' + 10;
            }
            else
                result = (result<<4) + string[i] - '0';
        }
        result = minus ? (-1*result):result;
    }
    return result;
}

//=====================================================================
void Uart_SendByte(int data)
{
    if(whichUart==0)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT0 & 0x2));
            Delay(10);                 //because the slow response of hyper_terminal 
            WrUTXH0('\r');
        }
        while(!(rUTRSTAT0 & 0x2));   //Wait until THR is empty.
        Delay(10);
        WrUTXH0(data);
    }
    else if(whichUart==1)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT1 & 0x2));
            Delay(10);                 //because the slow response of hyper_terminal 
            rUTXH1 = '\r';
        }
        while(!(rUTRSTAT1 & 0x2));   //Wait until THR is empty.
        Delay(10);
        rUTXH1 = data;
    }   
    else if(whichUart==2)
    {
        if(data=='\n')
        {
            while(!(rUTRSTAT2 & 0x2));
            Delay(10);                 //because the slow response of hyper_terminal 
            rUTXH2 = '\r';
        }
        while(!(rUTRSTAT2 & 0x2));   //Wait until THR is empty.
        Delay(10);
        rUTXH2 = data;
    }       
}               

//====================================================================
void Uart_SendString(char *pt)
{
    while(*pt)
        Uart_SendByte(*pt++);
}

//=====================================================================
//If you don't use vsprintf(), the code size is reduced very much.
void Uart_Printf(char *fmt,...)
{
    va_list ap;
    char string[256];

    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    Uart_SendString(string);
    va_end(ap);
}

extern void Test_Adc(void);
unsigned short da_data10_bits;
//========================**[ BOARD LED ]=================================
void Led_Display(int data)
{

/*********************the code amended in 2005.10.18**************************/
#if LedSwitchControl 
#define LedCircle 0x00ff
	unsigned int LedCounter;
#endif
/************************the end***********************************************/

	int temp,cyp,temp1,i,j;
	char *addr,*addr1,*addr2,*addr3,buff;
	char high,low;


     rGPECON=0x55555555;
     rGPFCON=0x5555;
//while(0)
{
	 temp=rGPECON;
     rGPEDAT =0xffff;
	 Sleep(5);//cyp add
	 temp=rGPEDAT;
     rGPEDAT =0x0000;
	 temp=rGPEDAT;
	 Sleep(5);//cyp add
}	/*DA init route*/
	temp1=1;
	temp=0;

	addr1=(char *)DA_DATA_ADDR;
	addr2=addr1+3;
    addr3=addr +256;
	 cyp=0;
	while(temp)
	{
	 addr=(char *)DA_CTRL_ADDR; //cyp add
     CTL_REG_WRITE(addr, 0x55);//cyp add
   /*   
	addr=(char *)DA_CTRL_ADDR;
       CTL_REG_WRITE(addr, 0x55);  
	
	da_data10_bits=0;//    
	high=(da_data10_bits & 0x3c0) >> 6;
	low=(da_data10_bits & 0x3f)<< 2;
	addr=(char *)DA_DATA_ADDR;
	addr=addr+3;
       CTL_REG_WRITE(addr, high);
	addr=addr-3;
       CTL_REG_WRITE(addr, low);
	addr=(char *)DA_CTRL_ADDR;
	addr=addr + 257;
     CTL_REG_WRITE(addr, 0x55);
    Sleep(100);

    */
	
   da_data10_bits=cyp;
	high=(da_data10_bits & 0x3c0) >> 6;
	low=(da_data10_bits & 0x3f) ;
	low=low <<2;
	addr1=(char *)DA_DATA_ADDR;
 	addr2=addr1+3;
      CTL_REG_WRITE(addr2, high);
addr2=addr1-3;
       CTL_REG_WRITE(addr1, low);
     addr3=addr +256;
   CTL_REG_WRITE(addr3, 0x55);

	if (cyp>=1023)
	{
      temp1=0;
	}
if (cyp<=0)
	{
	   temp1=1;
	}
	if (temp1)
	{
	 cyp=cyp+5;
	 if (cyp >1023)
		 cyp=1023;

	} 
	else
    {
     cyp=cyp-5;
	  if (cyp<0)
		  cyp=0;
	}
    Sleep(3);

	}


 

//	while(1)

// Test_Adc();

	addr=(char *)V_ADDR;
	temp=1;
	while(temp) /*j5 3~10 */
	{
       CTL_REG_WRITE(addr, 0xff);
	   Sleep(5);
       CTL_REG_WRITE(addr, 0);
      Sleep(5);
	}
	addr=addr + 256;
	temp=0;
	while(temp)/*j5 11~18 */
	{
       CTL_REG_WRITE(addr, 0xff);
	   Sleep(5);
       CTL_REG_WRITE(addr, 0);
       Sleep(5);
	}
	addr=addr + 256;
	temp=0;
	while(temp)   /*j5 19~26 */
	{
       CTL_REG_WRITE(addr, 0xff);
	   Sleep(5);
       CTL_REG_WRITE(addr, 0);
	   Sleep(5);
      
	}
	addr=addr + 256;
	temp=0;
	while(temp)
	{
       buff=CTL_REG_READ(addr);
       buff=CTL_REG_READ(addr);
	   if (buff)
          ERRORMSG(1, (TEXT("High lowel is ok!\r\n")));
	   else
          ERRORMSG(1, (TEXT("Low  lowel is ok!\r\n")));
	}
	addr=addr + 256; 
	temp=0; 
	while(temp)
	{
       buff=CTL_REG_READ(addr);
       buff=CTL_REG_READ(addr);
	   if (buff)
          ERRORMSG(1, (TEXT("High lowel is ok!\r\n")));
	   else
          ERRORMSG(1, (TEXT("Low  lowel is ok!\r\n")));
	}
	addr=addr + 256;
	temp=1;
	while(temp)
	{
       buff=CTL_REG_READ(addr);
       buff=CTL_REG_READ(addr);
	   if (buff)
          ERRORMSG(1, (TEXT("High lowel is ok!\r\n")));
	   else
          ERRORMSG(1, (TEXT("Low  lowel is ok!\r\n")));
	}




/****************************the code amended in 2005.10.18*****************************************************************/
#if LedSwitchControl 
	rGPFDAT = (rGPFDAT & 0xf) | !((data & 0xf)<<4);
	for(LedCounter == 0 ; LedCounter < LedCircle ; LedCounter++);		//just delay for the realization of altering display
	rGPFDAT = (rGPFDAT & 0xf) | ((data & 0xf)<<4);
#undef LedCircle
#else
	rGPFDAT = (rGPFDAT & 0xf) | !((data & 0xf)<<4);
#endif
/****************************the end****************************************************************************************/

/***************************the original code*****************************************
	rGPFDAT = (rGPFDAT & 0xf) | !((data & 0xf)<<4);
**************************************************************************************/
}


//========================*[ Timer ]==============================**
void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON = ((PCLK/1000000-1)<<8)|(divider<<3);  //Watch-dog timer control register
    rWTDAT = 0xffff;  //Watch-dog timer data register
    rWTCNT = 0xffff;  //Watch-dog count register

      //Watch-dog timer enable & interrupt  disable
//    rWTCON = rWTCON |(1<<5) & !(1<<2);  //?
    rWTCON = rWTCON | (1<<5) | ~(1<<2);  //May 06, 2002 SOP
}

//=================================================================
int Timer_Stop(void)
{
    rWTCON = ((PCLK/1000000-1)<<8);
    return (0xffff - rWTCNT);
}


//========================*[ MPLL ]==============================*
void ChangeMPllValue(int mdiv,int pdiv,int sdiv)
{
    rMPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}


//========================[ HCLK, PCLK ]===========================
void ChangeClockDivider(int hdivn,int pdivn)
{
     // hdivn,pdivn FCLK:HCLK:PCLK
     //     0,0         1:1:1 
     //     0,1         1:1:2 
     //     1,0         1:2:2
     //     1,1         1:2:4
    rCLKDIVN = (hdivn<<1) | pdivn;    
    
/*
    if(hdivn)
        MMU_SetAsyncBusMode();
    else 
        MMU_SetFastBusMode();
*/
}


//========================**[ UPLL ]==============================*
void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
    rUPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}


//========================*[ General Library ]=====================*
void * malloc(unsigned nbyte) 
//Very simple; Use malloc() & free() like Stack
//void *mallocPt=Image$$RW$$Limit;
{
    void *returnPt = mallocPt;

    mallocPt = (int *)mallocPt+nbyte/4+((nbyte%4)>0); //To align 4byte

    if( (int)mallocPt > HEAPEND )
    {
        mallocPt = returnPt;
        return NULL;
    }
    return returnPt;
}

//-------------------------------------------------------------------
void free(void *pt)
{
    mallocPt = pt;
}

/************************the code amended in 2005.10.18*********************/
#undef LedSwitchControl
/***************************the end***************************************/