www.pudn.com > headset.rar > main.c

/* 
    Main.c 
 
    This file contains the main function, which kicks off the headset 
    application. 
*/ 
 
#include "demohs.h" 
#include "hal.h" 
 
#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
 
 
 
 
/* 
    This is a global variable used to maintain the state of the 
    headset device itself.  The structure is defined in demohs.h and 
    includes information such as which state the device is in (idle, 
    connecting, etc.), whether or not it is paired, if there is a 
    button press pending, and if there is a slave connection pending. 
    All of these states are explained more in the structure definition 
    of Headset in demohs.h. 
*/ 
 
HeadsetState hsState; 
 
 
int main(void) 
{ 
    /* 
        Initialize the timer subsystem.  Now we can use timers in the 
        application. 
    */ 
	PRINT(("This is headset!/n"));	 
    TimerInit(); 
 
    /* Tell the button library we are interested in these buttons */ 
    ButtonInit(HS_BUTTONS_USED, ButtonDirect); 
 
    /* 
        When the connection manager has indicated it is running, then 
        this function is called to complete powerup procedures.  The 
        openReq() function only sets the duration of the ring 
        indication for incoming calls. 
    */ 
    openReq(); 
 
    /* 
        Start polling the voltage level on TEST_A and deliver the 
        readings to battery.c every 4 * 10sec = 40 seconds. 
    */ 
    BattInit(VM_ADC_TEST_A, BATT_MONITOR_PERIOD); 
 
 
#ifdef DEV_BOARD_HS 
    /* init some flags we will use */ 
    hsState.turnOffHs = 0; 
 
    /* flash some lights */ 
    flashInit(); 
 
    /* use PIO to turn codec on and off initially its turned off */ 
    PioSetDir(PIO_CODEC, ~0); 
    PioSet(PIO_CODEC, CODEC_OFF); 
#endif 
 
    /* 
        Kick off the Virtual Machine scheduler.  This is what calls 
        each of the tasks in the application. 
    */ 
    Sched(); 
 
    return 0; 
} 
 
 
/* 
    This function is used to put a message in the message queue to be 
    delivered to another task.  In this case, the message is always 
    delivered to task #1.  In the scope of the Headset demo, task #1 
    is the Headset Framework Handler (hsf_handler.c). 
*/ 
 
void putMsg(void *msg) 
{ 
    MessagePut(HEADSET_FRAMEWORK_TASK, msg); 
} 
 
 
/* 
    This is the declaration of the headset task. This loop is called 
    by the scheduler to process any incoming messages/events from 
    external tasks.  Many of the events may be the result of an action 
    started by this task (the headset task). 
*/ 
 
DECLARE_TASK(2) 
{ 
    /* Need a void msg pointer for incoming messages */ 
    void * msg; 
 
    /*  Need to know what type of message was sent. This type may be  
        different depending on the library used. 
    */ 
    MessageType type;   
 
    /* 
        Get the message, if any, from the queue so that we can process 
        it.  Notice that only one message is processed at a time. 
    */ 
    msg = MessageGet(HEADSET_TASK, &type); 
 
    if(msg) 
    { 
        switch (type) 
        { 
            /* 
                The actions taken by openReq(), which was called in 
                main() have finished. 
            */ 
            case HS_OPEN_CFM: 
                openCfm((HS_OPEN_CFM_T*) msg); 
                break; 
 
            /* 
                The pairing operation has completed.  Success or failure 
                is not known until you look into the inner workings of 
                pairCfm(). 
            */ 
            case HS_PAIR_CFM: 
                pairCfm((HS_PAIR_CFM_T*) msg); 
                break; 
 
            /* 
                The connect operation has completed.  Success or failure 
                is not known until you look into the inner workings of 
                connectCfm() 
            */ 
            case HS_CONNECT_CFM: 
                connectCfm((HS_CONNECT_CFM_T *) msg); 
                break; 
 
            /* 
                Indication that the RFCOMM connection has been 
                diconnected This can be due to a user action or to a 
                failure resulting in the disconnection. 
            */ 
            case HS_CONNECT_STATUS_IND: 
                connectStatusInd((HS_CONNECT_STATUS_IND_T*) msg); 
                break; 
 
            /* 
                There is an incoming call.  This is the indication that 
                should cause the headset to "ring" or otherwise indicate 
                to the user that there is an incoming call. 
            */ 
            case HS_RING_IND: 
                ringInd((HS_RING_IND_T*) msg); 
                break; 
 
            /* 
                This event indicates news about the SCO connection. 
                Generally the news informs the application of a SCO 
                disconnection. 
            */ 
            case HS_SCO_STATUS_IND: 
                scoStatusInd((HS_SCO_STATUS_IND_T*) msg); 
                break; 
 
            /* 
                This event relays information about volume/microphone 
                gain adjustments. 
            */ 
            case HS_VGS_IND: 
                vgsInd((HS_VGS_IND_T*) msg); 
                break; 
 
            /* 
                This event relays information about an incoming command 
                that is unrecognized. 
            */ 
            case HS_CMD_IND: 
                cmdInd((HS_CMD_IND_T*) msg); 
                break; 
 
            /* 
                This event indicates that an error has occurred and 
                gives an error code to indicate what went wrong. 
            */ 
            case HS_ERROR_IND: 
                errorInd((HS_ERROR_IND_T *) msg); 
                break; 
 
            /*  
                This event informs the headset app that the software reset 
                (i.e. writes to PS) has completed 
            */ 
            case HS_RESET_CFM: 
                resetCfm(); 
                break; 
 
            case HS_MIC_IND: 
                microphoneGainInd((HS_MIC_IND_T*) msg); 
                break; 
 
            default : 
                PRINT(("headset: Unrecognised msg type 0x%x\n",type)); 
                break; 
        } 
        /* Done with the message. Free the memory. */ 
        MessageDestroy(msg); 
    } 
}