44blib.c

三星S3C44B0X的一个DEMO代码,实现LCD显示时钟运行.

	rPDATB = (rPDATB & (~(1<<4)));
}

void Close_Machine(void)
{
    rPDATB = (rPDATB & (~(1<<5)));
    Delay(1000);
}


//******************************************************************************
//******************************************************************************
void Timer_Start(int divider)  //0:16us,1:32us 2:64us 3:128us
{
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3);
    rWTDAT=0xffff;
    rWTCNT=0xffff;   

    // 1/16/(65+1),nRESET & interrupt  disable
    rWTCON=((MCLK/1000000-1)<<8)|(divider<<3)|(1<<5);	
}

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


//******************************************************************************
//******************************************************************************
void ChangePllValue(int mdiv,int pdiv,int sdiv)
{
	int i = 1;		
	
	rPLLCON = (mdiv<<12)|(pdiv<<4)|sdiv;
	
	while(sdiv--)
		i *= 2;	 
	
	MCLK = (EXT_OSC_CLK*(mdiv+8))/((pdiv+2)*i);		
}


//******************************************************************************
//******************************************************************************
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;
}

//*****************************************************************************
void Cache_Flush(void)
{
    int i,saveSyscfg;
    
    saveSyscfg=rSYSCFG;

    rSYSCFG=SYSCFG_0KB; 		      
    for(i=0x10004000;i<0x10004800;i+=16)    
    {					   
	*((int *)i)=0x0;		   
    }
    rSYSCFG=saveSyscfg; 			    
}

//*****************************************************************************
//RTC实时时钟程序
//*****************************************************************************
void Get_Rtc(void)
{
    rRTCCON = 0x01;    // R/W enable, 1/32768, Normal(merge), No reset
    //Uart_Printf("This test should be excuted once RTC test(Alarm) for RTC initialization\n");
	date_t[0]=Change_BCD_Hex(rBCDYEAR);
	date_t[1]=Change_BCD_Hex(rBCDMON);
	date_t[2]=Change_BCD_Hex(rBCDDAY);
	date_t[3]=Change_BCD_Hex(rBCDHOUR);
	date_t[4]=Change_BCD_Hex(rBCDMIN);
	date_t[5]=Change_BCD_Hex(rBCDSEC);
	date_t[6]=rBCDDATE;
    rRTCCON = 0x0;    // R/W disable(for power consumption), 1/32768, Normal(merge), No reset
}

U8 Change_BCD_Hex(U8 BCDV)
{ 
   return (BCDV/16)*10+(BCDV%16);
}

U8 Change_Hex_BCD(U8 HexV)
{ 
   return (HexV/10)*16+(HexV%10);
}

//实时中断服务程序*************************************************************************
volatile int isRtcInt;

void __irq Rtc_Int(void)
{
    rI_ISPC=BIT_RTC;  //is needed only when cache=on & wrbuf=on & BSFRD=0
    Uart_Printf("RTC Alarm Interrupt O.K.\n");
    isRtcInt=1;  
}


int Test_Rtc_Alarm(void)  
{
    Uart_Printf("[RTC Alarm Test for S3C44B0X]\n");

    //Rtc_Init();

//    rRTCCON = 0x01; // R/W enable, 1/32768, Normal(merge), No reset

    rALMYEAR=TESTYEAR2 ;
    rALMMON =TESTMONTH2;
    rALMDAY =TESTDAY2  ;
    rALMHOUR=TESTHOUR2 ;
    rALMMIN =TESTMIN2  ;
    rALMSEC =TESTSEC2+9; 

    isRtcInt=0;
    pISR_RTC=(unsigned int)Rtc_Int;
    rRTCALM=0x7f;
    rRTCCON=0x0;
    rINTMSK=~(BIT_GLOBAL|BIT_RTC);

    while(isRtcInt==0);
    
    rINTMSK=BIT_GLOBAL;
    rRTCCON = 0x0;    // R/W disable(for power consumption), 1/32768, Normal(merge), No reset
    return 1;
}


void Rtc_Init(void)
{
    rRTCCON  = 0x01;	// R/W enable, 1/32768, Normal(merge), No reset
    rBCDYEAR = date_t[0];
    rBCDMON  = date_t[1];
    rBCDDAY  = date_t[2];
    rBCDHOUR = date_t[3];
    rBCDMIN  = date_t[4];
    rBCDSEC  = date_t[5];
    rBCDDATE = date_t[6];	// SUN:1 MON:2 TUE:3 WED:4 THU:5 FRI:6 SAT:7
    rRTCCON  = 0x0;    // R/W disable(for power consumption), 1/32768, Normal(merge), No reset
}

void __irq Rtc_Tick(void)
{
    rI_ISPC=BIT_TICK;  
    Have_1S=1;         //arrive 1S
}


//*************************common data**********************************
U8  handle_run_year(U8 year)
{
      U8   value;
      U16  temp;

      temp = 0x7d0+year;
      value = 0;

      if(!(temp%400))         value = 1;
      else
      {
          if(!(temp%100))   { value = 0;return value;}
          if(!(temp%4))       value = 1;
      }
      return value;
}

//*******************date +1
void date_add_one(void)         //return year:buff[0]  month:buff[1]  day:buff[2]
{
     buff[2]=buff[2]+1;
     if (buff[2]<29) return;    //if date>28   call handle_date
     switch(buff[1])            //month
          {
                 case 1:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =2;}
                         break;
                 case 2:
                          if(handle_run_year(buff[0]))
                            { if (buff[2] == 30)
                               {buff[2] =1;
                                buff[1] =3;}
                             }
                          else
                            { if (buff[2] == 29)
                               {buff[2] =1;
                                buff[1] =3;}
                             }
                          break;
                 case 3:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =4;}
                         break;
                 case 4:
                         if (buff[2] == 31)
                          { buff[2] =1;
                            buff[1] =5;}
                         break;
                 case 5:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =6;}
                         break;
                 case 6:
                         if (buff[2] == 31)
                          { buff[2] =1;
                            buff[1] =7;}
                         break;
                 case 7:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =8;}
                         break;
                 case 8:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =9;}
                         break;
                 case 9:
                         if (buff[2] ==31)
                          { buff[2] =1;
                            buff[1] =10;}
                         break;
                 case 10:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =11;}
                         break;
                 case 11:
                         if (buff[2] == 31)
                          { buff[2] =1;
                            buff[1] =12;}
                         break;
                 case 12:
                         if (buff[2] == 32)
                          { buff[2] =1;
                            buff[1] =1;
                            buff[0] =buff[0]+1;}  //problem
         }
}


//***************************int program******************
void __irq Eint0RTL(void)       //INT0:RTL
{
     rI_ISPC=BIT_EINT0;	//clear pending_bit
}

void __irq Eint1GPS(void)   //INT1:GPS
{
     rI_ISPC=BIT_EINT1;	//clear pending_bit
}

//************************************************************
void set_serial_command(U8 *str, U8 t0, U8 t1, U8 t2, U8 t3, U8 t4, U8 t5)
{
    *(str+0) = t0; *(str+1) = t1; *(str+2) = t2;
    *(str+3) = t3; *(str+4) = t4; *(str+5) = t5;
}

U8 calculate_checksum(U8 *str, U16 strlen)
{
    U8   temp;
    U16  i;

    temp = *str;
    for(i=1;i< strlen; i++)
        temp = temp ^ *(str+i);     //xor data
    return(temp);
}

void write_chinese_to_flash(U8 *str,U8 which4K)
{
      U16 l,k,j,m;
      U32 DesStart;
      l=*(str+6);
      l=l << 8;
      l=l | *(str+7);             //compute addr   DBUF[6]*256+DBUF[7]
      k=*(str+6)>>4;
      m=*(str+5);
      j=m<<4;
      k=k | j;                    //compute A19-A12   DBUF[5] *8+DBUF[6] low 4 bit
      j=*(str+5);
      DesStart=(j<<16) | l;
      SST39LF160_EraseSector(k);            //high8
      if (which4K)
         write_ram_to_flash(DBUF1,0x8,DesStart,0x1000);      //start,dest,len
      else
         write_ram_to_flash(DBUF0,0x8,DesStart,0x1000);      //start,dest,len
}

//move from receive buffer to temp BUFFER

void move_string(U8 *str_long, U16 sourcepoint,U8 *str,U16 destpoint,U16 bufferlen)
{     U16  k;
      for (k=0;k<bufferlen;k++)
          *(str+destpoint+k)= *(str_long+sourcepoint+k);
}


//find string from Dgps[] and move to DBUFA[]
U16 find_string_move(U8 *str_long, U16 startpoint,U8 *str,U16 bufferlen)
{
      U16 i,j,k;
      for (i=0;i<675;i++)
       { j= startpoint+i;
         if  ((*(str_long+(j+0)%bufferlen)==*(str+0)) &&
              (*(str_long+(j+1)%bufferlen)==*(str+1)) &&
              (*(str_long+(j+2)%bufferlen)==*(str+2)) &&
              (*(str_long+(j+3)%bufferlen)==*(str+3)) &&
              (*(str_long+(j+4)%bufferlen)==*(str+4)) &&
              (*(str_long+(j+5)%bufferlen)==*(str+5)))
            {for (k=0;k<306;k++)                                 //mov 306byte to DBUFA
                DBUFA[k]= *(str_long+(j+k)%bufferlen);
             return  j % bufferlen;            //find
            }
        }
      return bufferlen+1;                       //no find
}

//find string from DBUFA[] return point,no find return 0
U16 find_string(U8 *str_long, U16 startpoint,U16 endpoint,U8 *str,U8 substrlen)
{
      U16  i;
      U8   j;
      U8   temp_bool;
      for (i=startpoint;i<startpoint+endpoint-substrlen+1;i++)
       { temp_bool=1;
         for (j=0;j<substrlen;j++)
               temp_bool=temp_bool && (*(str_long+i+j)==*(str+j));
         if  (temp_bool)
             { if (i>0) return  i;                         //find
               else     return  1;                         //find
             }
        }
      return 0;                                 //no find
}



// ****************************************
// *  PWM Timer Interrupt0/1/2/3/4/5 test *
// ****************************************
void TimerInt(void)
{

    //rINTMSK=~(BIT_GLOBAL|BIT_TIMER0|BIT_TIMER1);
    pISR_TIMER0=(unsigned)Timer_0INT;
    pISR_TIMER1=(unsigned)Timer_1INT;

    rTCFG0=0x3b3b3b;	//dead zone=0,0x3b=59,pre2=59=0x3b,pre1=59,pre0=59
//    rTCFG1=0x401234;	//all interrupt,mux5=EXTCLK,mux2=1/2,mux3=1/4,mux2=1/8,mux1=1/16,mux0=1/32
    rTCFG1=0x04444;	//all interrupt,mux5=1/2,mux2=1/2,mux3=1/32,mux2=1/32,mux1=1/32,mux0=1/32
    
    rTCNTB0=0xc35;	//(1/(60MHz/60/32))*0x7a12=0.1s
    rTCNTB1=0xcf85;	//(1/(60MHz/60/32))*0xcf85=1.7s
//    rTCNTB2=0xffff;	//(1/(66MHz/15/8 ))*0xffff=0.12s
//    rTCNTB3=0xffff;	//(1/(66MHz/15/4 ))*0xffff=0.06s
//    rTCNTB4=0xffff;	//(1/(66MHz/15/2 ))*0xffff=0.03s
//    rTCNTB5=0xffff;	//(1/(66MHz/15/2 ))*0xffff=0.03s
//    rTCNTB5=0xffff;	//(1/(1MHz)*0xffff=0.06s, EXTCLK
//    rTCON=0x2222202;	//update T5/T4/T3/T2/T1/T0

    rTCON=0x2222202;	//update T5/T4/T3/T2/T1/T0
    rTCON=0x4888008;	//T5/T4/T3/T2/T0=auto reload,T1=one shot,all_stop

}


void __irq Timer_0INT(void)
{
     rI_ISPC=BIT_TIMER0;    //arrive to 0.1s
     if (bool_start_count) count_time=count_time+1;
     count_timer0_overflow =(count_timer0_overflow +1) % Top_Count_T0_Overflow;

     if (count_timer0_overflow%10==0)                       //1s
         { display_time_arrive=1;
         }

     check_key_time_arrive=1;
}



void __irq Timer_1INT (void)      //open kjc
{
    rI_ISPC=BIT_TIMER1;	          //clear pending_bit
}

//0.display time.....
void display_time_program(void)
{     display_time_arrive=0;
      if (MenuStatus==0)
      {
          run_screen_time(Display_Which_Screen);
       }
}