/*
********************************************************************************
*
* (c) Copyright 2002, Vineyard Technologies, Inc.
*
* Filename : lib.c
* Programmer(s): Steve KyeongHyeon Lee
* Created : 2003/05/07
* Modified :
*
* Description : Small library functions being used for every major functions
********************************************************************************
*/
#include "types.h"
#include
#include
#include "lib.h"
#include "gosd.h"
#include "gio.h"
//=============================================================================
// Change hexa ascii string (just 2 ascii characters) into number
//=============================================================================
#ifdef CONIF
u8 hatoc(u8 *str)
{
u8 num=0, i;
for(i=0; i if ( str[i]>='0' && str[i] else if( str[i]>='A' && str[i] else if( str[i]>='a' && str[i] }
return num;
}
#endif //CONIF
//=============================================================================
// Change unsigned character into 2 byte hex string
//=============================================================================
void hctoa(u8 ch, u8* hex)
{
u8 i,c;
for(i=0;i {
if (i == 0) c = ch >> 4;
else c = ch;
c &= 0x0f;
if (c >= 0 && c else hex[i] = 'A' + c - 10;
}
}
/*
//=============================================================================
// Change unsigned long 32bit into 8 byte hex string
//=============================================================================
void u32toa(u32 ch, u8* hex)
{
u8 i,c;
for(i=0;i c = ch>>(4*(7-i));
c &= 0x0f;
if( c>=0 && c else hex[i] = 'A'+c-10;
}
}
*/
//=============================================================================
// Change ascii string into number
//=============================================================================
#ifdef NOT_JUNK
u16 a2i(u8 *str, u8 size)
{
u8 num=0, i;
for(i=0; i if( str[i]>='0' && str[i] }
return num;
}
#endif //NOT_JUNK
/*
//=============================================================================
// Change unsigned character into 3 byte decimal string
//=============================================================================
void ctoa(u8 ch, u8* decimal)
{
decimal[0] = '0' + ch/100;
ch = ch%100;
decimal[1] = '0' + ch/10;
ch = ch%10;
decimal[2] = '0' + ch;
}
//=============================================================================
// Change unsigned character into 2 byte decimal string
//=============================================================================
void ctoa_s(u8 ch, u8* decimal)
{
decimal[0] = '0' + ch/10;
ch = ch%10;
decimal[1] = '0' + ch;
}
*/
//=============================================================================
// Change unsigned character into n byte decimal string
//=============================================================================
void dtoa(u16 val, u8* decimal_str, u8 len)
{
u16 i,d=1;
for(i=0;i for(i=0;i {
decimal_str[i] = '0' + val/d;
val = val%d;
d = d / 10;
}
}
//=============================================================================
// Change hexa ascii string (just 4 ascii characters) into number
//=============================================================================
#ifdef CONIF
u16 hatoi(u8 *str)
{
u16 num=0, i;
for(i=0; i if ( str[i]>='0' && str[i] else if( str[i]>='A' && str[i] else if( str[i]>='a' && str[i] }
return num;
}
#endif
//=============================================================================
//
//=============================================================================
void mem_set(u8* ptr, u8 val, u16 len)
{
u16 i;
for(i=0;i *ptr++ = val;
}
//=============================================================================
// Change hexa ascii string (just 8 ascii characters) into number
//=============================================================================
#if defined(DEBUG_HDD_DUMP)
u32 hatol(u8 *str)
{
xdata u32 num=0, i;
for(i=0; i if ( str[i]>='0' && str[i] else if( str[i]>='A' && str[i] else if( str[i]>='a' && str[i] }
return num;
}
#endif
//=============================================================================
//
//=============================================================================
u8 mem_cmp(u8* ptr1, u8* ptr2, u16 len)
{
u16 i;
for(i=0;i if( *ptr1++ != *ptr2++ ){
return 1;
}
}
return 0;
}
//=============================================================================
//
//=============================================================================
void mem_cpy(u8* pDst, u8* pOrg, u16 len)
{
u16 i;
for(i=0;i *pDst++ = *pOrg++;
}
/*#if defined(DEBUG_EVT)
//=============================================================================
//
//=============================================================================
void mem_dump( u16 addr, u16 size )
{
u16 i,j;
u8 line[16],ch;
printf("\n\rDUMP ADDR=0x%04x SIZE=0x%04x\n\r", addr, size);
for(i=0;i if((i%16) == 0)
printf("%04x : ", addr);
ch = XBYTE[addr];
printf("%02x ", (u16)ch);
line[i%16] = ch;
if((i%16) == 15){
printf(" ");
for(j=0;j if(line[j]>=0x20 && line[j] printf("%c", line[j]);
else
printf(".");
}
printf("\n\r");
}
addr++;
}
printf("\n\r");
}
#endif*/
//=============================================================================
//
//=============================================================================
u8 time_equal(u32 big_time, u32 small_time)
{
if(big_time < small_time) return FALSE;
if( (big_time - small_time) > 3 ) return FALSE;
return TRUE;
}
//=============================================================================
//
//=============================================================================
void reboot(void)
{
void (*reboot_1[1])(void) = 0;
(*reboot_1[0])();
}
////////////////////////////////////////////////////////////////////////////////////////
// y - line number
// msg - string to show
// len - the number of characters to show within msg character string (could be even or odd
////////////////////////////////////////////////////////////////////////////////////////
void center_line(u8 y, u8* msg, u8 len)
{
u8 x;
u8 i,j;
u8 ch;
x = 44 - ((len/2)*2); // calculate the first character position aligned to even value
for(i=x,j=0;j {
ch = msg[j];
osd_printf(i,y,1,&ch);
}
}
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
void show_logo(u8* line1, u8 len1, u8* line2, u8 len2, u8* line3, u8 len3, u8* line4, u8 len4)
{
u8 ver_str[20] = "41.10.82.11.15.12.07";
osd_page_clear();
#if USE_ADJ
ver_str[10] = '2';
#endif
#ifdef DRAW_CROSS
ver_str[10] = '3';
#endif
#ifdef FONT_SC
ver_str[7] = '2';
#else
// 123456789012345678901234567890
osd_printf(16, osdgv_menu_base+2,8,"Version ");
#endif
center_line(osdgv_menu_base+2, ver_str, 20);
center_line(osdgv_menu_base+3, line1 ,len1 );
center_line(osdgv_menu_base+4, line2 ,len2 );
center_line(osdgv_menu_base+5, line3 ,len3 );
center_line(osdgv_menu_base+6, line4 ,len4 );
delay_time(50000,10);
osd_page_clear();
}
#ifdef DEBUG_DISPTIME
void disp_time(u8* date_time)
{
xdata u8 i;
for(i=0;i {
printf("%02d", (int)date_time[5-i]);
if(i!=5) printf(":");
}
}
#endif
