lib.c

dvr

/*
********************************************************************************
*
* (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 <stdio.h>
#include <absacc.h>
#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<2; i++) {
		if     ( str[i]>='0' && str[i]<='9' )	num = (num<<4) + str[i] - '0';
		else if( str[i]>='A' && str[i]<='F' )	num = (num<<4) + str[i] - 'A' + 10;
		else if( str[i]>='a' && str[i]<='f' )	num = (num<<4) + str[i] - 'a' + 10;
	}
	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<2;i++)
	{
		if (i == 0) c = ch >> 4;
		else c = ch;
		c &= 0x0f;
		if (c >= 0 && c <= 9 ) hex[i] = '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<8;i++){
		c = ch>>(4*(7-i));
		c &= 0x0f;
		if( c>=0 && c<=9 ) hex[i] = '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<size; i++) {
		if( str[i]>='0' && str[i]<='9' ) num = (num*10) + str[i] - '0';
	}
	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<(len-1);i++) d = d * 10;
	for(i=0;i<len;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<4; i++) {
		if     ( str[i]>='0' && str[i]<='9' )	num = (num<<4) + str[i] - '0';
		else if( str[i]>='A' && str[i]<='F' )	num = (num<<4) + str[i] - 'A' + 10;
		else if( str[i]>='a' && str[i]<='f' )	num = (num<<4) + str[i] - 'a' + 10;
	}
	return num;
}
#endif
//=============================================================================
//
//=============================================================================
void mem_set(u8* ptr, u8 val, u16 len)
{
	u16 i;
	for(i=0;i<len;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<8; i++) {
		if     ( str[i]>='0' && str[i]<='9' )	num = (num<<4) + str[i] - '0';
		else if( str[i]>='A' && str[i]<='F' )	num = (num<<4) + str[i] - 'A' + 10;
		else if( str[i]>='a' && str[i]<='f' )	num = (num<<4) + str[i] - 'a' + 10;
	}
	return num;
}
#endif

//=============================================================================
//
//=============================================================================
u8 mem_cmp(u8* ptr1, u8* ptr2, u16 len)
{
	u16 i;
	for(i=0;i<len;i++){
		if( *ptr1++ != *ptr2++ ){
			return 1;
		}
	}
	return 0;
}

//=============================================================================
//
//=============================================================================
void mem_cpy(u8* pDst, u8* pOrg, u16 len)
{
	u16 i;
	for(i=0;i<len;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<size;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<16;j++){
				if(line[j]>=0x20 && line[j]<=0x80)
					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<len;i+=2,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<6;i++)
	{
		printf("%02d", (int)date_time[5-i]);
		if(i!=5) printf(":");
	}
}
#endif