dvb_log.c

DVB软件,基于CT216软件的开发源程序.

#include "stdio.h"
#include "string.h"

#include "ct_type.h"
#include "ct_os.h"
#include "ct_uart.h"
#include "task_cfg.h"
#include "ct_irq.h"
#include "sys_debug.h"

#include "dvb_log.h"

/************************************************************************
 * Log macro.
 ************************************************************************/
#if 0
#define	LOG_PRINT(p)
#else
#define	LOG_PRINT(p)	printf p
#endif

//Log
//message queue
#define LOG_QUEUE_SIZE		(1024)
typedef enum
{
	EN_LOGCMD_NULL,
	EN_LOGCMD_BUFF_1_FULL,
	EN_LOGCMD_BUFF_2_FULL,
	EN_LOGCMD_LOG_TIMEOUT,
	EN_LOGCMD_NUM
}EN_LOGQUEUE_CMD;
//task
#define DVB_LOG_TASK_STACK_SIZE		(1024 * 4)
#define DVB_LOG_TASK_PRIORITY		EN_CTOS_PRIORITY_15
#define DVB_LOG_TASK_TIMESLICE		0
//buffer
#define BUFF_SIZE	(32*1024)
#define LOG_FILE_NAME_LENGTH	(30)
#define LOG_FILE_NAME	"AUTO_CMD.txt"
//task
#define DVB_LOGDEBUG_TASK_STACK_SIZE		(1024 * 4)
#define DVB_LOGDEBUG_TASK_PRIORITY		EN_CTOS_PRIORITY_15
#define DVB_LOGDEBUG_TASK_TIMESLICE		0
#define LOGMEMSIZE	127


/************************************************************************
 * Structure.
 ************************************************************************/
typedef struct
{
	// bit 0: LUN0, bit 1: LUN1, ..., bit 31: LUN31
	u32 u32LUNs;
	u8 u8MaxLUN;
	bool8 b8Connect;
	s8 s8CurrentLUN;
}ST_LOG_LUN_INFO;

/************************************************************************
 * Enumeration.
 ************************************************************************/

typedef enum
{
	EN_STATE_INT,
	EN_STATE_CMDSTR,
	EN_STATE_CMDOVR,
	EN_STATE_OTHER,
	EN_STATE_NUM
}EN_PARSER_STATE;
EN_PARSER_STATE enParserState=EN_STATE_CMDOVR;

extern bool8 DVB_DEVCTRL_HoldFs(bool8 b8Hold, EN_MEDIA_TYPE enMediaType);

//Log
//message queue
static CTOS_QUEUE LOG_Request_MsgQueue;
static u32 u32LOGRequestQueueMsg[LOG_QUEUE_SIZE];
static bool8 b8LogTaskCreated = FALSE;
//Task
static CTOS_TASK stLogTaskCtrlBlk;
static u8 au8LogTaskStack[DVB_LOG_TASK_STACK_SIZE];
static bool8 b8SetDevice = FALSE;
//buffer
static u32 u32Buff1Idx = 0;
static u32 u32Buff2Idx = 0;
static u8 au8Buff1[BUFF_SIZE];
static u8 au8Buff2[BUFF_SIZE];
//set device
static EN_DEVICE_TYPE _enDeviceType = EN_NO_DEVICE;
static u8 _au8DirName[13];
static bool8 b8OpenFile = FALSE;
static u32 _u32LogFileHandle = 0;
static bool8 _b8Log_Suspend = FALSE;
static u8 _au8RecordFileName[LOG_FILE_NAME_LENGTH];

EN_MEDIA_TYPE _enLogMediaType;
//timer
static struct _tm _stLocalTm;
static bool8 b8ChangeToBuff2 = FALSE;
//FS
static bool8 b8FileExist = FALSE;
static u16	u16FileIndex = 0;

//Task
static CTOS_SEMAPHORE      LogDebugSemore;
CTOS_TASK stLogDebugTaskCtrlBlk;
static u8 au8LogDebugTaskStack[DVB_LOGDEBUG_TASK_STACK_SIZE];
static bool8 b8LogDebugTaskCreated = FALSE;
void DVB_LogDebugInitialStart(void);
void DVB_LogDebugSuspend(void);
void DVB_LogDebugTask (u32 u32Argc, void * pArgv);

static u32 _u32CmdFileHandle = 0;
static u8  au8size[LOGMEMSIZE+1];
static u8  u8Index;
static u8  u8StartIndex;
static u32  u32LoopIndex;
static u8  u8LoopTimes;
static u8  GetCommand=FALSE;
static u32  u32waittime;
static u8  au8command[20];
static u8			u8ArgcLOG = 0;
static u8			au8ArgvLOG[8][DEBUG_MAX_ARGV_LENGTH];
static u32 u32size=0;

u32 _atoi (u8 *pu8Char)
{
	u32 u32Num = 0;
	u8 u8ount;
	
	for (u8ount = 0; u8ount < 10; u8ount++)
	{
		if (*(pu8Char + u8ount) == 0)
		{
			break;
		}
		u32Num = (u32)((u32Num * 10) + (*(pu8Char + u8ount) - 0x30));
	}
	
	return u32Num;
}
/************************************************************************
 * UserLog callback function.
 ************************************************************************/
void fnDeviceLogCallback(u8 u8Data)
{
	MSG_PARAMETER	stSendMsg;	
	stSendMsg.u8Cmd = 0;
	
	if(b8ChangeToBuff2 == FALSE)
	{	
		if(u8Data != '\r')
		{
			au8Buff1[u32Buff1Idx] = u8Data;
			u32Buff1Idx ++;
		}
	}
	else// if(b8ChangeToBuff2 == FALSE)
	{
		if(u8Data != '\r')
		{
			au8Buff2[u32Buff2Idx] = u8Data;
			u32Buff2Idx ++;
		}
	}	
		
	if(u32Buff1Idx == BUFF_SIZE)
	{
		u32Buff1Idx = 0;
		
		if(b8ChangeToBuff2 == FALSE)
		{	
			b8ChangeToBuff2 = TRUE;
			stSendMsg.u8Cmd = EN_LOGCMD_BUFF_1_FULL;		
			CT_OS_PutMsg(&LOG_Request_MsgQueue, &stSendMsg, CTOS_NO_WAIT);			
		}
	}
	else if(u32Buff2Idx == BUFF_SIZE)
	{
		u32Buff2Idx = 0;
		
		if(b8ChangeToBuff2 == TRUE)
		{
			b8ChangeToBuff2 = FALSE;
			stSendMsg.u8Cmd = EN_LOGCMD_BUFF_2_FULL;
			CT_OS_PutMsg(&LOG_Request_MsgQueue, &stSendMsg, CTOS_NO_WAIT);			
		}
	}
}


/************************************************************************
 * Log Folder Open function.
 ************************************************************************/
bool8 LogFolderOpen(void)
{
	//u16	u16Random = 0;
	bool8 b8MkDir = FALSE;
	bool8 b8CtrlCd = FALSE;

	u16FileIndex = 0;
	
	// Set My Log Directory
	sprintf (_au8DirName, "MYLOG");

	DVB_DEVCTRL_HoldFs(TRUE, _enLogMediaType);
	b8MkDir = DVB_FILECTRL_MkDir (_enDeviceType, _au8DirName);
	
	if (b8MkDir == TRUE)
	{
		DVB_LocalTimeGet(&_stLocalTm);
		
		DVB_FILECTRL_SetFileTime(_enDeviceType, _au8DirName, EN_FS_TIME_TYPE_CREATE, &_stLocalTm);
	}
	
	b8CtrlCd = DVB_FILECTRL_Cd (_enDeviceType, _au8DirName);
	
	if (b8CtrlCd == FALSE)
	{
		LOG_PRINT(("CD mylog fail\n"));
		DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);
		return FALSE;
	}

	do
	{
		sprintf(_au8RecordFileName, "%04d.txt",u16FileIndex); 
		u16FileIndex ++;
	}while(DVB_FILECTRL_FileExist(_enDeviceType, _au8RecordFileName) == TRUE && u16FileIndex!=10000);

	DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);
	return TRUE;	
}

/************************************************************************
 * Log notify device plug out function.
 ************************************************************************/
void DVB_LOG_Device_Set(EN_DEVICE_TYPE enDeviceType, EN_MEDIA_TYPE enMediaType)
{
    b8SetDevice = TRUE;

	if(b8OpenFile == FALSE)
	{
		/*Open File Mechanism*/
		/*If there is MYLOG.TXT in root, open Log file system.*/
		_enDeviceType = enDeviceType;
		_enLogMediaType = enMediaType;

		DVB_DEVCTRL_HoldFs(TRUE, _enLogMediaType);
		DVB_FILECTRL_CdRoot(_enDeviceType);
		b8FileExist = DVB_FILECTRL_FileExist(_enDeviceType, LOG_FILE_NAME);
		DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);

		if(b8FileExist == TRUE)
		{
			u32Buff1Idx = 0;
			u32Buff2Idx = 0;

			memset(au8Buff1, 0, (sizeof(au8Buff1)));
			memset(au8Buff2, 0, (sizeof(au8Buff2)));

			LOG_PRINT(("\n>>Log File Exist <<\n"));

			DVB_DEVCTRL_HoldFs(TRUE, _enLogMediaType);
			_u32CmdFileHandle = DVB_FILECTRL_FileOpen(_enDeviceType, LOG_FILE_NAME, 'r');
			DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);
			LOG_PRINT(("\n>> DVB_FILECTRL_FileOpen: %ld <<\n", _u32CmdFileHandle));

			if(LogFolderOpen() == TRUE)
			{
				// Set log file name
				DVB_DEVCTRL_HoldFs(TRUE, _enLogMediaType);
				//_u32LogFileHandle = DVB_FILECTRL_FileOpen(_enDeviceType, "MYLOG.TXT", 'w');
				_u32LogFileHandle = DVB_FILECTRL_FileOpen(_enDeviceType, _au8RecordFileName, 'w');
				DVB_LocalTimeGet(&_stLocalTm);
				DVB_FILECTRL_SetFileTimeWithFileHandle(_enDeviceType, _u32LogFileHandle, EN_FS_TIME_TYPE_CREATE, &_stLocalTm);

				DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);
				LOG_PRINT(("\n>> DVB_FILECTRL_FileOpen: %ld <<\n", _u32LogFileHandle));

				if(_u32LogFileHandle == 0)
				{
					LOG_PRINT(("\n>> [USRDLOG] can't open file to write <<\n"));
				}
				else
				{
					b8OpenFile = TRUE;
				}
			}
			else
			{
				LOG_PRINT(("\n>> [USRDLOG] Log Folder Open fail <<\n"));
			}

			if(_u32CmdFileHandle == 0)
			{
				LOG_PRINT(("\n>> [USRDLOG] No Cmd File <<\n"));
			}
			else
			{
				LOG_PRINT(("\n>> [USRDLOG] open file to read cmd <<\n"));
				DVB_LogDebugInitialStart();
				//start MemDebugLog Task
				if(EN_CTOS_SUCCESS!=CT_OS_FreeSemaphore(&LogDebugSemore))
				{
					LOG_PRINT(("\n Resume Task fail"));
				}
			}
		} /* if(b8FileExist == TRUE) */				
	}
}
void DVB_LOG_Device_PlugOff_Notify(void)
{
    b8SetDevice = FALSE;
	b8OpenFile = FALSE;

	u32Buff1Idx = 0;
	u32Buff2Idx = 0;
	memset(au8Buff1, 0, (sizeof(au8Buff1)));
	memset(au8Buff2, 0, (sizeof(au8Buff2)));
}
/************************************************************************
 * Log task function.
 ************************************************************************/
void DVB_LogTask (u32 u32Argc, void * pArgv)
{
	EN_CTOS_STATUS  enStatus;
	MSG_PARAMETER	stRecvMsg;
	u32				u32RecvMsgLen = 0;
	u8              u8CmdID = 0;
	
	while (TRUE)
	{
		
		enStatus = CT_OS_GetMsg(&LOG_Request_MsgQueue, &stRecvMsg, &u32RecvMsgLen, CTOS_WAIT);			
		if(b8SetDevice == TRUE)
		{	
			if(b8OpenFile == TRUE)
			{
				/*Check Buffer Mechanism*/
				/*Check buffer if full or not. If buffer is full, write the data of buffer to file system.*/
				if(enStatus == EN_CTOS_SUCCESS)
				{
					u8CmdID = stRecvMsg.u8Cmd;
					switch(u8CmdID)
					{
						case EN_LOGCMD_BUFF_1_FULL:
							//LOG_PRINT(("\n-- BUFF_1_FULL --\n"));
							LOG_PRINT(("\n#1\n"));
							DVB_DEVCTRL_HoldFs(TRUE, _enLogMediaType);
							DVB_FILECTRL_FileWrite(_enDeviceType, _u32LogFileHandle, BUFF_SIZE, au8Buff1);
							DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);
							memset(au8Buff1, 0, (sizeof(au8Buff1)));
							break;	
						case EN_LOGCMD_BUFF_2_FULL:
							//LOG_PRINT(("\n-- BUFF_2_FULL --\n"));
							LOG_PRINT(("\n#2\n"));
							DVB_DEVCTRL_HoldFs(TRUE, _enLogMediaType);
							DVB_FILECTRL_FileWrite(_enDeviceType, _u32LogFileHandle, BUFF_SIZE, au8Buff2);
							DVB_DEVCTRL_HoldFs(FALSE, _enLogMediaType);
							memset(au8Buff2, 0, (sizeof(au8Buff2)));
							break;
						default:
							break;