2410lib.c

武汉创维特的arm培训例程试验程序

    }
    *string='\0';
    Uart_SendByte('\n');
}
/********************************************************************
// Function name	: Uart_GetIntNum
// Description	    : 从串口接收一个字符串，并将其解析为一个整数值
// Return type		: int:收到的整数值
// Argument         : void
*********************************************************************/
int Uart_GetIntNum(void)
{
    char str[30];
    char *string = str;
    int base     = 10;
    int minus    = 0;
    int result   = 0;
    int lastIndex;    
    int i;
    
    Uart_GetString(string);
    
    if(string[0]=='-')
    {
        minus = 1;
        string++;
    }
    
    if(string[0]=='0' && (string[1]=='x' || string[1]=='X'))
    {
        base    = 16;
        string += 2;
    }
    
    lastIndex = strlen(string) - 1;
    
    if(lastIndex<0)
        return -1;
    
    if(string[lastIndex]=='h' || string[lastIndex]=='H' )
    {
        base = 16;
        string[lastIndex] = 0;
        lastIndex--;
    }

    if(base==10)
    {
        result = atoi(string);
        result = minus ? (-1*result):result;
    }
    else
    {
        for(i=0;i<=lastIndex;i++)
        {
            if(isalpha(string[i]))
            {
                if(isupper(string[i]))
                    result = (result<<4) + string[i] - 'A' + 10;
                else
                    result = (result<<4) + string[i] - 'a' + 10;
            }
            else
                result = (result<<4) + string[i] - '0';
        }
        result = minus ? (-1*result):result;
    }
    return result;
}
/********************************************************************
// Function name	: Uart_SendByte
// Description	    : 通过串口发送字符
// Return type		: void
// Argument         : int data:待发送字符
*********************************************************************/
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;
    }       
}               
/********************************************************************
// Function name	: Uart_SendString
// Description	    : 通过串口发送字符串
// Return type		: void
// Argument         : char *pt:字符串指针
*********************************************************************/
void Uart_SendString(char *pt)
{
    while(*pt)
        Uart_SendByte(*pt++);
}
/********************************************************************
// Function name	: Uart_Printf
// Description	    : 串口打印函数
// Return type		: void
// Argument         : char *fmt
// Argument         : ...
*********************************************************************/
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);
}
/********************************************************************
// Function name	: Led_Display
// Description	    : 显示LED灯
// Return type		: void
// Argument         : int data (1 - on, 0 - off)
//                        3    2    1    0
//                     LED4 LED3 LED2 LED1
*********************************************************************/
unsigned char output_0x10000000 = 0xff;
void Led_Display(int data)
{	
	output_0x10000000 &= (~0xf0);
	output_0x10000000 |= (((~data)<< 4) & 0xf0);
	*((unsigned char *)0x10000000) = output_0x10000000;
}
unsigned char seg7table[16] = 
{
    /* 0       1       2       3       4       5       6      7*/
    0xc0,   0xf9,   0xa4,   0xb0,   0x99,   0x92,   0x82,   0xf8,

    /* 8       9      A        B       C       D       E      F*/
    0x80,   0x90,   0x88,   0x83,   0xc6,   0xa1,   0x86,   0x8e,
};

/********************************************************************
// Function name	: Seg7_Display
// Description	    : 数码管显示程序
// Return type		: void
// Argument         : unsigned char mask : 数码管显示掩码 bit0 - bit5 : SEG0 - SEG5
// Argument         : unsigned char * pdata : 数码管对应数据 bit0 - bit5 : SEG0 - SEG5
*********************************************************************/
void Seg7_Display(unsigned char mask, unsigned char * pdata)
{
	int i = 0;
	
	for(i = 0; i < 6; i++)
	{
		if(mask & (1 << i))
		{
			*((unsigned char *)0x10000006) = ~(1 << i) & 0x3f;
			*((unsigned char *)0x10000004) = seg7table[(pdata[i]) & 0xf]; 
			Delay(40);
		}
	}
}

/********************************************************************
// Function name	: Adc_Get_Data
// Description	    : AD采样
// Return type		: int:返回的采样值
// Argument         : int ch:通道0-7
// Argument         : int freq:采样频率
*********************************************************************/
int Adc_Get_Data(int ch, int freq)
{
#define LOOP 10000

    int i;
	volatile U32 preScaler;
    static int prevCh=-1;
    
    preScaler = PCLK/freq -1;               //PCLK:50.7MHz
    
    rADCCON = (1<<14)|(preScaler<<6)|(ch<<3);	//setup channel

    if(prevCh!=ch)
    {
		rADCCON = (1<<14)|(preScaler<<6)|(ch<<3);   //setup channel
		for(i=0;i<LOOP;i++);	//delay to set up the next channel
		prevCh=ch;
    }
    rADCCON|=0x1;   //start ADC

    while(rADCCON & 0x1);	//check if Enable_start is low
    while(!(rADCCON & 0x8000));	//check if EC(End of Conversion) flag is high

    return ( (int)rADCDAT0 & 0x3ff );
}

//========================*[ 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);
}
/********************************************************************
// Function name	: ChangeMPllValue
// Description	    : 设置MPLL值
// Return type		: void
// Argument         : int mdiv
// Argument         : int pdiv
// Argument         : int sdiv
*********************************************************************/
void ChangeMPllValue(int mdiv,int pdiv,int sdiv)
{
    rMPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}
/********************************************************************
// Function name	: ChangeClockDivider
// Description	    : 配置HCLK和PCLK
// Return type		: void
// Argument         : int hdivn
// Argument         : int pdivn
*********************************************************************/
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();
}
/********************************************************************
// Function name	: ChangeUPllValue
// Description	    : 设置UPLL值
// Return type		: void
// Argument         : int mdiv
// Argument         : int pdiv
// Argument         : int sdiv
*********************************************************************/
void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
    rUPLLCON = (mdiv<<12) | (pdiv<<4) | sdiv;
}

unsigned short ntohs(unsigned short s)
{
	return (s >> 8) | (s << 8);
}

unsigned long ntohl(unsigned long l)
{
	return	((l >> 24) & 0x000000ff) |
		((l >>	8) & 0x0000ff00) |
		((l <<	8) & 0x00ff0000) |
		((l << 24) & 0xff000000);
}

unsigned short htons(unsigned short s)
{
	return (s >> 8) | (s << 8);
}

unsigned long htonl(unsigned long l)
{
	return	((l >> 24) & 0x000000ff) |
		((l >>	8) & 0x0000ff00) |
		((l <<	8) & 0x00ff0000) |
		((l << 24) & 0xff000000);
}