diskloop.c

嵌入式程序

//file name: Diskloop.c
//file description: responsible for writing data to disk
#include	"recordloop.h"
#include	"memorypool.h"
#include	"stdio.h"
#include	"kernel.h"
#include	"cleanup.h"
#include    "base.h"

#define DISK_STATE_NORMAL        0   //normal state
#define DISK_STATE_FULL          1  //disk full
#define DISK_STATE_CHANGE        2   //disk switch

#define DISK_PROCESS_CMD_DATA    1
#define DISK_PROCESS_CMD_CONTROL 2

#define DISK_PROCESS_STATE_IDLE                   0
#define DISK_PROCESS_STATE_STOPREC                1
#define DISK_PROCESS_STATE_REC                    2
#define DISK_PROCESS_STATE_STARTREC               3

#define NO_UNSAVED_FRAME -9999
#define UNSAVED_FRAME_LOST -1

static U32 newFrameTime; // the latest frame time
static S32 diskState; //disk state
static FILE *FileHandle[16];
static S32 OldestInfoFrame[16] = -1;
static S32 newInfoFrame[16] = -1;
extern CHANNEL_STATE ChState[16];
extern SYSTEM_PARA_SET   system_parameter ;
MSG_Q_ID DiskQueue;
typedef struct _DSKPRCS_MSG_STRUCT
{
	U16 sender;
    U16 cmd;                         //command
    U16 ch;                          //channel
    U16 framehead;                   //number of data piece
} DSKPRCS_MSG_STRUCT;

//function: getNewFrameTime();
//description: when data frame reach,frame time be noted by newFrameTime 
//argument: the frame head
U32 getNewFrameTime(S32 head)
{
    newFrameTime = mpGetTime(head)
    return newFrameTime;
}


//function:  getDiskstate()
//description: take note disk state when disk state switches
//argument: disk state
S32 getDiskstate(S32 dskState)
{
    diskState = dskState;
    ruturn diskState;
}

//function: diskProcess()
//description: the entry function of diskloop task
//no arguments
void diskProcess(void)
{
    S32 status;
//  int ch;
//  int framehead;
    queueInit();
    while(1)
    {

        if( receive_message( recorder_queque , sizeof( KERNEL_MESSAGE ) , ( U8 *) &msg ) < sizeof( CMD_MESSAGE ) )
            continue ;
        if(msg->cmd == DISK_PROCESS_CMD_DATA)
            putFrameIntoQueue(msg->ch, msg->framehead);
        if(mpGetType(msg->framehead) == INFO_FRAME)
            newInfoFrame[msg->ch] = msg->framehead;
        status = getDiskProcessState(msg->ch);

        switch(status)
        {
            case DISK_PROCESS_STATE_IDLE:
                DPIdleState(msg);
                break;
            case DISK_PROCESS_STATE_STOPREC:                
                DPStopRecState(msg);
                break;
            case DISK_PROCESS_STATE_REC:                    
                DPRecState(msg);
                break;
            case DISK_PROCESS_STATE_STARTREC:               
                DPStartRecState(msg);
                break;
            default:
                break;
        }
      }
}

//function: getDiskProcessState()
//description: return state of diskloop
//argument: channel
static S32 getDiskProcessState(S32 ch)
{
    S32 status;
    status  = getStatus(ch);
    if((status & 0x01 == 0) && (FileHandle[ch] == NULL))
        return DISK_PROCESS_STATE_IDLE;
    else if((status & 0x01 == 0) && (FileHandle[ch] != NULL))
        return DISK_PROCESS_STATE_STOPREC;
    else if((status & 0x01 != 0) && (FileHandle[ch] != NULL))
        return DISK_PROCESS_STATE_REC;
    else if((status & 0x01 != 0) && (FileHandle[ch] == NULL))
        return DISK_PROCESS_STATE_STARTREC;
    else 
        return DISK_PROCESS_STATE_IDLE;
}

//function: DPIdleState(DPMESSAGE msg)
//desciption: process in idle state
//argument: msg
static void DPIdleState(DPMESSAGE msg)
{

}

//function: DPStopRecState()
//description: stop recorder and close file
//argument: msg
static void DPStopRecState(DPMESSAGE *msg);
{
    S32 command;
    command = msg->command;
    switch(command)
    {
        case DISK_LOOP_CMD_DATA:
            DPCloseFile(msg);
            break;
        case DISK_LOOP_CMD_control;
            DPCloseFile(msg);
            break;
        default:
            break;
    }
}

//function: DPRecState()
//description: write data into file
//argument:   msg
static void DPRecState(DPMESSAGE *msg)
{
    S32 command;
    command = msg->command;
    switch(command)
    {
        case DISK_LOOP_CMD_DATA:
            DPWriteFile(msg);
            break;
        case DISK_LOOP_CMD_control:
            DPWriteFile(msg);
            break;
        default:
            break;
    }
}

//function: DPStartRecState()
//description: start record, open file
//argument: msg
static void DPStartRecState(DPMESSAGE *msg)
{
    int command;
    command= msg->cmd;
    switch(command)
    {
        case DISK_LOOP_CMD_DATA:
            if(DPOpenFile(msg))
            {
                if(status & 0x2 != 0)
                    savePreRec(msg->ch);
                if(newInfoFrame[msg->ch] >= 0)
                    DPWriteFile(newInfoFrame[msg->ch],msg->framehead);
                DPWriteFile(msg->ch,msg->framehead);
            }
            break;
         default:
            break;
    }
}

//function:   DPOpenFile(int ch, int framehead);
//description: open a file in which data save
//arguments:  chanel, framehead
static S32 DPOpenFile(S32 ch, S32 framehead)
{
    S32 left;
    left = getHDDLeftSpace();
    if(left <= DISK_THRESHOLD)
    {
        diskState = DISK_STATE_FULL;
        //ADD function which inform recordloop open file is error


        
        return;
    }

    //add a function     create filename




    

    
    
}

//function:  DPWriteFile(int ch, int framehead)
//description: write data to file
//arguments: chanel, framehead
static S32 DPWriteFile(S32 ch, S32 framehead)
{
    S32 left;
    left = getHDDLeftSpace();
    if(left <= DISK_THRESHOLD)
    {
        diskState = DISK_STATE_FULL;
        return 0;
    }

    ret = mpFWrite(msg->datano,FileHandle[ch]);
    if(ret < 0)
    {    
        fclose(FileHandle(ch)) ;
        FileHandle(ch) = NULL;
        DiskState = DISK_STATE_ERROR;
        return 0;
    }

    return 1;
}

//function: static int DPCloseFile(int ch)
//description: close file
//argument: chanel
static S32 DPCloseFile(S32 ch)
{
    if(fclose(FileHandle[ch]));
    {
        diskState = DISK_STATE_ERROR;
        //ADD A FUNCTION TO INFORM RECORDLOOP TO CLOSE FILE ERROR


        return 0;
    }
    //ADD A FUNCTION TO INFORM RECORDLOOP TO CLOSE FILE OK



    return 1;
    
    
}

//function:	 putFrameIntoQueue(int ch, int framehead)
//description: put frame data to prerecorder queue
//argument: chanel, framehead
static void putFrameIntoQueue(S32 ch, S32 framehead)
{
    if(queueIsFull(ch))
    {
        S32 rear;
        queueGetOut(ch, &rear);
        if(mpGetType(framehead) == INFO_FRAME)
        {
            if(OldestInfoFrame[ch] >=0)
                mpRelease(newInfoFrame[ch], MEMORY_POOL_SAVE_OK);
            newInfoFrame[ch] = rear;
        }
        else
            mpRelease(newInfoFrame[ch], MEMORY_POOL_SAVE_OK);
    }
    queuePutIn(ch,framehead);
}

//function:	static int savePreRec(int ch);
//description: save data in prerecord queue to disk
//argument:chanel
static S32 savePreRec(S32 ch)
{
    if(OldestInfoFrame[ch] >= 0)
        ret = mpFWrite(datano, FileHandle[ch]);
    while(!queueIsEmpty(ch))
    {
        S32 datano = -1;
        queueGetOut(ch,&datano);
        ret = mpFWrite(datano, FileHandle[ch]);
        mpRelease(datano, MEMORY_POOL_SAVE_OK);
        if(ret < 0)
            return ERROR;
    }
    return OK;
}