微处理器开发

开发平台：
Unix_Linux

2410lib.c：源码内容
							//===================================================================
// File Name : 2410lib.c
// Function  : S3C2410 PLL,Uart, LED, Port Init
// Program   : Shin, On Pil (SOP)
// Date      : March 20, 2002
// Version   : 0.0
// History
//   0.0 : Programming start (February 20,2002) -> SOP
//===================================================================
#include "def.h"
#include "option.h"
#include "2410addr.h"
#include "2410lib.h"
#include "2410slib.h" 
#include "timer.h" 
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
//#include <stdio.h>
#include <ctype.h>
extern char Image$$RW$$Limit[];
void *mallocPt=Image$$RW$$Limit;
//***************************[ SYSTEM ]***************************************************
static int delayLoopCount = 400;
void Delay(int time)
{
      // time=0: adjust the Delay function by WatchDog timer.
      // time>0: the number of loop time
      // resolution of time is 100us.
    int i,adjust=0;
    if(time==0)
    {
        time   = 200;
        adjust = 1;
        delayLoopCount = 400;
            //PCLK/1M,Watch-dog disable,1/64,interrupt disable,reset disable
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3); 
        rWTDAT = 0xffff;                              //for first update
        rWTCNT = 0xffff;                              //resolution=64us @any PCLK 
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3)|(1<<5); //Watch-dog timer start
    }
    for(;time>0;time--)
        for(i=0;i<delayLoopCount;i++);
    if(adjust==1)
    {
        rWTCON = ((PCLK/1000000-1)<<8)|(2<<3); //Watch-dog timer stop
        i = 0xffff - rWTCNT;                     //1count->64us, 200*400 cycle runtime = 64*i us
        delayLoopCount = 8000000/(i*64);         //200*400:64*i=1*x:100 -> x=80000*100/(64*i)   
    }
}
//***************************[ PORTS ]****************************************************
void Port_Init(void)
{
    //CAUTION:Follow the configuration order for setting the ports. 
    // 1) setting value(GPnDAT) 
    // 2) setting control register  (GPnCON)
    // 3) configure pull-up resistor(GPnUP)  
    //32bit data bus configuration  
    //*** PORT A GROUP
    //Ports  : GPA22 GPA21  GPA20 GPA19 GPA18 GPA17 GPA16 GPA15 GPA14 GPA13 GPA12  
    //Signal : nFCE nRSTOUT nFRE   nFWE  ALE   CLE  nGCS5 nGCS4 nGCS3 nGCS2 nGCS1 
    //Binary :  1     0      1  , 1   1   1    1   ,  1     1     1     1
    //Ports  : GPA11   GPA10  GPA9   GPA8   GPA7   GPA6   GPA5   GPA4   GPA3   GPA2   GPA1  GPA0
    //Signal : ADDR26 ADDR25 ADDR24 ADDR23 ADDR22 ADDR21 ADDR20 ADDR19 ADDR18 ADDR17 ADDR16 ADDR0 
    //Binary :  1       1      1      1   , 1       1      1      1   ,  1       1     1      0
    rGPACON = 0x5ffffe; 
    //**** PORT B GROUP
    //Ports  : GPB10    GPB9    GPB8    GPB7    GPB6     GPB5    GPB4   GPB3   GPB2     GPB1      GPB0
    //Signal : nXDREQ0 nXDACK0 nXDREQ1 nXDACK1 nSS_KBD nDIS_OFF L3CLOCK L3DATA L3MODE nIrDATXDEN Keyboard
    //Setting: INPUT  OUTPUT   INPUT  OUTPUT   INPUT   OUTPUT   OUTPUT OUTPUT OUTPUT   OUTPUT    OUTPUT 
    //Binary :   00  ,  01       00  ,   01      00   ,  01       01  ,   01     01   ,  01        01  
    rGPBCON = 0x044555;
    rGPBUP  = 0x7ff;     // The pull up function is disabled GPB[10:0]
    //*** PORT C GROUP
    //Ports  : GPC15 GPC14 GPC13 GPC12 GPC11 GPC10 GPC9 GPC8  GPC7   GPC6   GPC5 GPC4 GPC3  GPC2  GPC1 GPC0
    //Signal : VD7   VD6   VD5   VD4   VD3   VD2   VD1  VD0 LCDVF2 LCDVF1 LCDVF0 VM VFRAME VLINE VCLK LEND  
    //Binary :  10   10  , 10    10  , 10    10  , 10   10  , 10     10  ,  10   10 , 10     10 , 10   10
    rGPCCON = 0xaaaaaaaa;       
    rGPCUP  = 0xffff;     // The pull up function is disabled GPC[15:0] 
    //*** PORT D GROUP
    //Ports  : GPD15 GPD14 GPD13 GPD12 GPD11 GPD10 GPD9 GPD8 GPD7 GPD6 GPD5 GPD4 GPD3 GPD2 GPD1 GPD0
    //Signal : VD23  VD22  VD21  VD20  VD19  VD18  VD17 VD16 VD15 VD14 VD13 VD12 VD11 VD10 VD9  VD8
    //Binary : 10    10  , 10    10  , 10    10  , 10   10 , 10   10 , 10   10 , 10   10 ,10   10
    rGPDCON = 0xaaaaaaaa;       
    rGPDUP  = 0xffff;     // The pull up function is disabled GPD[15:0]
    //*** PORT E GROUP
    //Ports  : GPE15  GPE14 GPE13   GPE12   GPE11   GPE10   GPE9    GPE8     GPE7  GPE6  GPE5   GPE4  
    //Signal : IICSDA IICSCL SPICLK SPIMOSI SPIMISO SDDATA3 SDDATA2 SDDATA1 SDDATA0 SDCMD SDCLK I2SSDO 
    //Binary :  10     10  ,  10      10  ,  10      10   ,  10      10   ,   10    10  , 10     10  ,     
    //-------------------------------------------------------------------------------------------------------
    //Ports  :  GPE3   GPE2  GPE1    GPE0    
    //Signal : I2SSDI CDCLK I2SSCLK I2SLRCK     
    //Binary :  10     10  ,  10      10 
    rGPECON = 0x5aaaaaaa;       
    rGPEUP  = 0xffff;     // The pull up function is disabled GPE[15:0]
    //*** PORT F GROUP
    //Ports  : GPF7   GPF6   GPF5   GPF4      GPF3     GPF2  GPF1   GPF0
    //Signal : nLED_8 nLED_4 nLED_2 nLED_1 nIRQ_PCMCIA EINT2 KBDINT EINT0
    //Setting: Output Output Output Output    EINT3    EINT2 EINT1  EINT0
    //Binary :  01      01 ,  01     01  ,     10       10  , 10     10
    rGPFCON = 0x55aa;
    rGPFUP  = 0xff;     // The pull up function is disabled GPF[7:0]
    //*** PORT G GROUP
    //Ports  : GPG15 GPG14 GPG13 GPG12 GPG11    GPG10    GPG9     GPG8     GPG7      GPG6    
    //Signal : nYPON  YMON nXPON XMON  EINT19 DMAMODE1 DMAMODE0 DMASTART KBDSPICLK KBDSPIMOSI
    //Setting: nYPON  YMON nXPON XMON  EINT19  Output   Output   Output   SPICLK1    SPIMOSI1
    //Binary :   11    11 , 11    11  , 10      01    ,   01       01   ,    11         11
    //-----------------------------------------------------------------------------------------
    //Ports  :    GPG5       GPG4    GPG3    GPG2    GPG1    GPG0    
    //Signal : KBDSPIMISO LCD_PWREN EINT11 nSS_SPI IRQ_LAN IRQ_PCMCIA
    //Setting:  SPIMISO1  LCD_PWRDN EINT11   nSS0   EINT9    EINT8
    //Binary :     11         11   ,  10      11  ,  10        10
    rGPGCON = 0xff81ffba;	//GPG10 input,GPG9 input
    rGPGUP  = 0xffff;    // The pull up function is disabled GPG[15:0]
    //*** PORT H GROUP
    //Ports  :  GPH10    GPH9  GPH8 GPH7  GPH6  GPH5 GPH4 GPH3 GPH2 GPH1  GPH0 
    //Signal : CLKOUT1 CLKOUT0 UCLK nCTS1 nRTS1 RXD1 TXD1 RXD0 TXD0 nRTS0 nCTS0
    //Binary :   10   ,  10     10 , 11    11  , 10   10 , 10   10 , 10    10
	rGPHCON = 0xfaaa;//0x2afaaa;
    rGPHUP  = 0x7ff;    // The pull up function is disabled GPH[10:0]
    
    //External interrupt will be falling edge triggered. 
    rEXTINT0 = 0x22222222;    // EINT[7:0]
    rEXTINT1 = 0x22222222;    // EINT[15:8]
    rEXTINT2 = 0x22222222;    // EINT[23:16]
}
//***************************[ UART ]******************************
extern U32 SYS_PCLK;
static int whichUart=0;
void Uart_Init(int pclk,int baud)
{
    int i;    
	rGPHCON = rGPHCON & (~(0xffff)) ;
	rGPHCON = rGPHCON | (0xaaa0) ;
    rGPHUP  = 0x0;    // The pull up function is enable
    if(pclk == 0) pclk = SYS_PCLK;
//	pclk    = PCLK;    
    rUFCON0 = 0x0;   //UART channel 0 FIFO control register, FIFO disable
    rUFCON1 = 0x0;   //UART channel 1 FIFO control register, FIFO disable
    rUFCON2 = 0x0;   //UART channel 2 FIFO control register, FIFO disable
    rUMCON0 = 0x0;   //UART chaneel 0 MODEM control register, AFC disable
    rUMCON1 = 0x0;   //UART chaneel 1 MODEM control register, AFC disable
//UART0
    rULCON0 = 0x3;   //Line control register : Normal,No parity,1 stop,8 bits
     //    [10]       [9]     [8]        [7]        [6]      [5]         [4]           [3:2]        [1:0]
     // Clock Sel,  Tx Int,  Rx Int, Rx Time Out, Rx err, Loop-back, Send break,  Transmit Mode, Receive Mode
     //     0          1       0    ,     0          1        0           0     ,       01          01
     //   PCLK       Level    Pulse    Disable    Generate  Normal      Normal        Interrupt or Polling
    rUCON0  = 0x245;   // Control register
    rUBRDIV0=( (int)(pclk/16./baud+0.5) -1 );   //Baud rate divisior register 0
//UART1
    rULCON1 = 0x3;
    rUCON1  = 0x245;
    rUBRDIV1=( (int)(pclk/16./baud) -1 );
//UART2
    rULCON2 = 0x3;
    rUCON2  = 0x245;
    rUBRDIV2=( (int)(pclk/16./baud) -1 );    
    for(i=0;i<100;i++);
}
//===================================================================
void Uart_Select(int ch)
{
    whichUart = ch;
}
//*****************************************************************************
//在串口1和2之间切换
//*****************************************************************************
void Uart2_Test( void )
{
	U8 m ;
	U8 n = 0 ;
	
	rGPHCON = rGPHCON & (~(0xffff)) ;
	rGPHCON = rGPHCON | (0xaaa0) ;
    rGPHUP  = 0x0;    // The pull up function is enable
	SetClockDivider(1, 1);
	SetSysFclk(DFT_FCLK_VAL);
	Delay( 0 ) ;
	Uart_Init(0, UART_BAUD);
	Uart_Select(0);
	
   	Uart_Printf( "nUART2 Testn" ) ;
   	Uart_Printf( "nPlease pull out COM cable and plug into the UART2 connectorn" ) ;
   	
   	Uart_Select( 1 ) ;
	while( (m=Uart_GetKey()) != ESC_KEY )
	{
	   	if( m != 0 )  
	   	{
	   		puts( "'ESC' key return to UART1, The input of you is " ) ;
	   		putch( m ) ;		puts( "n" ) ;
	   		n = 1 ;
	   	}
	   	else  
	   	{
	   		if( n==0 )
	   		{
		   		puts( "Now is UART2 output, do you see?  Any key to display, 'ESC' key return to UART1 n" ) ;
		   		n = 0 ;
		   		Delay( 6000 ) ;
	   		}
	   	}
	}
   	Uart_Printf( "nPlease pull out COM cable and plug into the UART1 connectorn" ) ;
   	Uart_Select( 0 ) ;
	while( (m=Uart_GetKey()) != ESC_KEY )
	{
   		Uart_Printf( "Please Enter 'ESC' key to Main menu n" ) ;
   		Delay( 6000 ) ;
	}
}
//===================================================================
void Uart_TxEmpty(int ch)
{
    if(ch==0)
        while(!(rUTRSTAT0 & 0x4)); //Wait until tx shifter is empty.
          
    else if(ch==1)
        while(!(rUTRSTAT1 & 0x4)); //Wait until tx shifter is empty.
        
    else if(ch==2)
        while(!(rUTRSTAT2 & 0x4)); //Wait until tx shifter is empty.
}
//=====================================================================
char getch(void)
{
    if(whichUart==0)
    {       
        while(!(rUTRSTAT0 & 0x1)); //Receive data ready
        return RdURXH0();
    }
    else if(whichUart==1)
    {       
        while(!(rUTRSTAT1 & 0x1)); //Receive data ready
        return RdURXH1();
    }
    else if(whichUart==2)
    {
        while(!(rUTRSTAT2 & 0x1)); //Receive data ready
        return RdURXH2();
    }
    return 0;
}
//====================================================================
char getkey(void)
{
    if(whichUart==0)
    {       
        if(rUTRSTAT0 & 0x1)    //Receive data ready
            return RdURXH0();
        else
            return 0;
    }
    else if(whichUart==1)
    {
        if(rUTRSTAT1 & 0x1)    //Receive data ready
            return RdURXH1();
        else
            return 0;
    }
    else if(whichUart==2)
    {       
        if(rUTRSTAT2 & 0x1)    //Receive data ready
            return RdURXH2();
        else
            return 0;
    }    
    return 0;	
}
//====================================================================
void gets(char *string)
{
    char *string2 = string;
    char c;
    while((c = getch())!='r')
    {
        if(c=='b')
        {
            if( (int)string2 < (int)string )
            {
                printf("b b");
                string--;
            }
        }
        else 
        {
            *string++ = c;
            putch(c);
        }
    }
    *string='';
    putch('n');
}
//=====================================================================
int Uart_GetIntNum(void)
{
    char str[30];
    char *string = str;
    int base     = 10;
    int minus    = 0;
    int result   = 0;
    int lastIndex;    
    int i;
    
    gets(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;
}
//*****************************************************************************
//get a number for the uart
//*****************************************************************************
int Uart_GetIntNum_GJ(void)
{
    char string[16] ;
    char *p_string = string ;
    char c;
    int i = 0 ;
    int data = 0 ;
    while(   (c=getch()) != 'r'  )
    {
		if(c=='b')		p_string--;
		else		*p_string++=c;
		
		putch( c ) ;
    }
    *p_string = '';
	i = 0 ;
	while( string[i] != '' )
	{
		data = data * 10 ;
		if( string[i]<'0'||string[i]>'9' )
			return -1 ;
		data = data + ( string[i]-'0' ) ;
		i++ ;		
	}	
	
	return data ;
}
//*****************************************************************************
//=====================================================================
void wait_print_end(void)
{
	int i;
	while(!(rUTRSTAT0 & 0x2));	
	i = 10000;
	while(i--);	
}
void putch(int data)
{
    if(whichUart==0)
    {
        if(data=='n')
        {
            while(!(rUTRSTAT0 & 0x2));
            Delay(1);                 //because the slow response of hyper_terminal 
            WrUTXH0('r');
        }
        while(!(rUTRSTAT0 & 0x2));   //Wait until THR is empty.
        Delay(1);
        WrUTXH0(data);
    }
    else if(whichUart==1)
    {
        if(data=='n')
        {
            while(!(rUTRSTAT1 & 0x2));
            Delay(1);                 //because the slow response of hyper_terminal 
            rUTXH1 = 'r';
        }
        while(!(rUTRSTAT1 & 0x2));   //Wait until THR is empty.
        Delay(1);
        rUTXH1 = data;
    }   
    else if(whichUart==2)
    {
        if(data=='n')
        {
            while(!(rUTRSTAT2 & 0x2));
            Delay(1);                 //because the slow response of hyper_terminal 
            rUTXH2 = 'r';
        }
        while(!(rUTRSTAT2 & 0x2));   //Wait until THR is empty.
        Delay(1);
        rUTXH2 = data;
    }       
}               
//====================================================================
void puts(char *pt)
{
    while(*pt)
        putch(*pt++);
}
//=====================================================================
//If you don't use vsprintf(), the code size is reduced very much.
typedef int *__va_list[1];
int vsprintf(char * /*s*/, const char * /*format*/, __va_list /*arg*/);
void printf(char *fmt,...)
{
    va_list ap;
    char string[256];
    va_start(ap,fmt);
    vsprintf(string,fmt,ap);
    puts(string);
    va_end(ap);
}
//=============================================================
char DbgPause(char *str)
{
	if(str)
		puts(str);
	else	
		puts("Debug breakpoint, press any key to continue...n");
	return getch();
}
//**************************[ BOARD LED ]*********************************
void Led_Display(int data)
{
          //Active is low.(LED On)
          // GPF7  GPF6   GPF5   GPF4
          //nLED_8 nLED4 nLED_2 nLED_1
//    rGPFDAT = (rGPFDAT & 0xf) | !((data & 0xf)<<4);
    rGPFDAT = (rGPFDAT & ~(0xf<<4)) | ((~data & 0xf)<<4);    
}
void Led_Test( void )
{
	Uart_Printf( "nLED TESTn" );
	Uart_Printf( "Press 'ESC' key to Exit this program !nn" );
	while( Uart_GetKey() != ESC_KEY )
	{
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 8<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 4<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 2<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 1<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 0<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 1<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 2<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 4<<4 ) ;
		Delay( 3000 ) ;
		rGPFDAT = rGPFDAT & (~(0xf<<4)) | ( 8<<4 ) ;
		Delay( 3000 ) ;
	}
}
void Buzzer_Freq_Set( U32 freq )
{
	rGPBCON &= ~3;			//set GPB0 as tout0, pwm output
	rGPBCON |= 2;
		
	rTCFG0 &= ~0xff;
	rTCFG0 |= 15;			//prescaler = 15+1
	rTCFG1 &= ~0xf;
	rTCFG1 |= 2;			//mux = 1/8
	rTCNTB0 = (PCLK>>7)/freq;
	rTCMPB0 = rTCNTB0>>1;	// 50%
	rTCON &= ~0x1f;
	rTCON |= 0xb;			//disable deadzone, auto-reload, inv-off, update TCNTB0&TCMPB0, start timer 0
	rTCON &= ~2;			//clear manual update bit
}
void Buzzer_Stop( void )
{
	rGPBCON &= ~3;			//set GPB0 as output
	rGPBCON |= 1;
	rGPBDAT &= ~1;
}
//***************************[ BOARD BEEP ]*******************************
void Beep(U32 freq, U32 ms)
{
	Buzzer_Freq_Set( freq ) ;
	Delay( ms ) ;
	Buzzer_Stop() ;
}
/****************************************************************************
【功能说明】蜂鸣器PWM测试
****************************************************************************/
void BUZZER_PWM_Test( void )
{
	U16 freq = 2000 ;
	
	Uart_Printf( "nBUZZER TEST ( PWM Control )n" );
   	Uart_Printf( "Press +/- to increase/reduce the frequency of BUZZER !n" ) ;
	Uart_Printf( "Press 'ESC' key to Exit this program !nn" );
	
	Buzzer_Freq_Set( freq ) ;
    while( 1 )
    {
		U8 key = Uart_Getch();
		if( key == '+' )
		{
			if( freq < 20000 )
				freq += 10 ;
				
			Buzzer_Freq_Set( freq ) ;
		}
		if( key == '-' )
		{
			if( freq > 11 )
				freq -= 10 ;
				
			Buzzer_Freq_Set( freq ) ;
		}
		
		Uart_Printf( "tFreq = %dn", freq ) ;
		if( key == ESC_KEY )
		{
			Buzzer_Stop() ;
			return ;
		}
	}
}
//*************************[ 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);  
}
//=================================================================
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;
}

						