main.c

CSR 的键盘模块

            }
        }
        break;
        
        case CL_SM_AUTHENTICATE_CFM:
        {
			switch (state)
			{
				case appDiscoverable:
				case appDiscoverableConnecting:
				case appCabledConnecting:
				case appCabledConnected:
		            appHandleClSmAuthenticateConfirm(theApp, (CL_SM_AUTHENTICATE_CFM_T *)message);
					break;
				case appDiscoverableConnected:
					appHandleClSmAuthenticateConfirmDiscoverableConnected(theApp, (CL_SM_AUTHENTICATE_CFM_T *)message);
					break;
				default:
                	appHandleUnexpected(theApp, id);
                	break;
			}
        }
        break;
        
        case CL_SM_AUTHORISE_IND:
        {
            switch (state)
            {
                case appDiscoverable:
                case appDiscoverableConnecting:
                    appHandleClSmAuthoriseInd(theApp, (CL_SM_AUTHORISE_IND_T *)message);
                    break;
                default:
                    appRejectClSmAuthoriseInd(theApp, (CL_SM_AUTHORISE_IND_T *)message);
                    break;
            }
        }
        break;

        case CL_DM_CLOCK_OFFSET_CFM:
        {   
            switch (state)
            {
                case appCabledConnected:
                    appHandleClDmClockOffsetCfm(theApp, (CL_DM_CLOCK_OFFSET_CFM_T *)message);
                    break;
                default:
                    break;
            }
        }
        break;

        case CL_DM_MODE_CHANGE_EVENT:
        {   
            switch (state)
            {
                case appCabledConnected:
                    appHandleClDmModeChangeEvent(theApp, (CL_DM_MODE_CHANGE_EVENT_T *)message);
                    break;
                default:
                    break;
            }
        }
        break;

        case CL_SM_SECURITY_LEVEL_CFM:
        case CL_DM_WRITE_INQUIRY_ACCESS_CODE_CFM:
        break;        
        
        case MESSAGE_MORE_DATA:
        {
			Source source = ((MessageMoreData *)message)->source;

#ifdef HW_DEV_1163A
			/* Check if Aux stream */
			if (StreamHidAuxSource() == source)	
			{
				switch (state)
				{
					case appCabledDisconnected:
						/* Move to connecting state */
						appSetState(theApp, appCabledConnecting);
					default:
						/* Handle aux keys */
						appHandleDataAux(theApp, source);
						break;
				}
			}
			else
#endif
			{
	        	switch (state)
	            {	
					case appDiscoverable:
					case appDiscoverableConnecting:
					case appDiscoverableConnected:
    		    		/* Check if we are currently entering pin code */
						if (appIsPinCodeEntry(theApp))
	   		         	{
							/* Handle report for pin code entry */
       			        	appHandleDataPinCode(theApp, source);
		    	        }
						else
						{
	    	                /* Throw away data */
    	    	            appHandleDataDispose(theApp, source);
						}
						break;
	                case appCabledDisconnected:
    	                /* Move to connecting state */
        	            appSetState(theApp, appCabledConnecting);
            	        break;                
					case appCabledConnecting:
                    	/* Ignore, buffer up reports until we are connected */
                    	break;
	                default:
    	                /* Throw away data */
        	            appHandleDataDispose(theApp, source);
            	        break;
				}
            }
        }
        break;
        
		/* HID library messages */            
    	case HID_INIT_CFM:
        {
        	switch (state)
            {
            	case appInitialising:
                	appHandleHidInitConfirm(theApp, (HID_INIT_CFM_T *)message);
                    break;
                default:
                	appHandleUnexpected(theApp, id);
                	break;
            }
        }
        break;
                    
        case HID_CONNECT_IND:
        {
			switch (state)
			{
				case appDiscoverable:
					appHandleHidConnectIndDiscoverable(theApp, (HID_CONNECT_IND_T *)message);
					break;
                default:
					appHandleHidConnectIndReject(theApp, (HID_CONNECT_IND_T *)message);
					break;
			}
        }
        break;
			       
        case HID_CONNECT_CFM:
        {
            switch (state)
            {
                case appDiscoverableConnecting:
                    appHandleHidConnectCfmDiscoverable(theApp, (HID_CONNECT_CFM_T *)message);
                    break;
                case appCabledConnecting:
    				appHandleHidConnectCfmCabled(theApp, (HID_CONNECT_CFM_T *)message);
                    break;
                default:
					appHandleUnexpected(theApp, id);
					break;
            }
        }
        break;
        
	    case HID_DISCONNECT_IND:
        {
            switch (state)
            {
	            case appCabledConnected:
                case appCabledDisconnecting:
    				appHandleHidDisconnectInd(theApp, (HID_DISCONNECT_IND_T *)message);
                    break;
                case appDiscoverableConnected:
					appHandleHidDisconnectIndDiscoverable(theApp, (HID_DISCONNECT_IND_T *)message);
					break;
                default:
					appHandleUnexpected(theApp, id);
					break;
            }
        }
        break;
        
        case HID_SET_PROTOCOL_IND:
        {
           	switch (state)
            {
                case appCabledConnected:
                case appDiscoverableConnected:
                    appHandleHidSetProtocolInd(theApp, (HID_SET_PROTOCOL_IND_T *)message);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }
        }
        break;
        
        case HID_GET_PROTOCOL_IND:
        {
           	switch (state)
            {
                case appCabledConnected:
                case appDiscoverableConnected:
                    appHandleHidGetProtocolInd(theApp, (HID_GET_PROTOCOL_IND_T *)message);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }
        }
        break;
        
        case HID_SET_IDLE_IND:
        {
        	switch (state)
            {
                case appCabledConnected:
                case appDiscoverableConnected:
                    appHandleHidSetIdleInd(theApp, (HID_SET_IDLE_IND_T *)message);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }
        }
        break;
        
        case HID_GET_IDLE_IND:
        {
        	switch (state)
            {
                case appCabledConnected:
                case appDiscoverableConnected:
                    appHandleHidGetIdleInd(theApp, (HID_GET_IDLE_IND_T *)message);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }
        }
        break;
        
        case HID_SET_REPORT_IND:
        case HID_DATA_IND:
        {
            switch (state)
            {
                case appCabledConnected:
                case appDiscoverableConnected:
                    appHandleHidSetReportInd(theApp, (HID_SET_REPORT_IND_T *)message, (id == HID_SET_REPORT_IND));
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break; 
            }
        }
        break;

        case HID_GET_REPORT_IND:
        {
            switch (state)
            {
                case appCabledConnected:
                    appHandleHidGetReportInd(theApp, (HID_GET_REPORT_IND_T *)message);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break; 
            }
        }
        break;

        case HID_CONTROL_IND:
        {
            switch (state)
            {
                case appCabledConnected:
                    appHandleHidControlInd(theApp, (HID_CONTROL_IND_T *)message);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break; 
            }
        }
        break;

        case APP_INTERNAL_PIN_CODE_TIMEOUT_IND:
        {
            appHandleInternalPinCodeTimeoutInd(theApp);
        }
        break;
 
        case APP_INTERNAL_IDLE_TIMEOUT_IND:
        {
            switch (state)
            {
                case appCabledConnected:
                    appHandleInternalIdleTimeoutInd(theApp);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }
        }
        break;

        case APP_INTERNAL_DISCOVERABLE_TIMEOUT_IND:
        {
           switch (state)
            {
                case appDiscoverable:
                    appHandleInternalDiscoverableTimeoutInd(theApp);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }        }
        break;

        case APP_INTERNAL_UNPLUG_IND:
        {
            switch (state)
            {
                case appDiscoverableConnecting:
                case appDiscoverableConnected:
                case appCabledConnecting:
                case appCabledDisconnecting:
                    appHandleInternalUnplugIndDefer(theApp);
                    break;
                case appCabledConnected:
                    appHandleInternalUnplugIndConnected(theApp);
                    break;
                case appCabledDisconnected:
                    appHandleInternalUnplugIndDisconnected(theApp);                    
                    break;
                case appDiscoverable:
                case appIdle:
                    appHandleInternalUnplugIndDiscoverable(theApp);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;
            }
        }
        break;

        case APP_INTERNAL_UNPLUG_TIMEOUT_IND:
        {
            switch (state)
            {
                case appCabledConnected:
                    appHandleInternalUnplugTimeoutInd(theApp);
                    break;
                default:
                    appHandleUnexpected(theApp, id);
                    break;  
            }
        }
        break;

		default:
		{
			/* An unexpected message has arrived - must handle it */
            appHandleUnexpected(theApp, id);
		}
		break;
    }
}
        
int main(void)
{
#ifdef HW_CASIRA_UART
	/* Make sure Uart has been successfully initialised before running */
	if (StreamUartSource())
#endif
	{
        static appTaskData theApp;
        
        /* Set up task 1 handler */
	    theApp.task.handler = app_handler;
        
        /* Set initial state */
        theApp.state = appInitialising;

        /* Initialise status PIOs & sync PIO */
        PioSetDir(LED_MASK_NUM_LOCK | LED_MASK_CAPS_LOCK | LED_MASK_SCROLL_LOCK | HID_MASK_IDLE_MODE,
                  LED_MASK_NUM_LOCK | LED_MASK_CAPS_LOCK | LED_MASK_SCROLL_LOCK | HID_MASK_IDLE_MODE);
        
        /* Initialise buttons */
        pioInit(&theApp.pioState, &theApp.task);

        /* Initialise Led */    
        appLedInit(&theApp.led);
        appLedUpdate(&theApp.led, 0, -1, 0);
        appLedSetPriority(&theApp.led, 0);   
        
        /* Init the Connection Manager */
      	ConnectionInitEx(&theApp.task, &app_msg_filter);

	    /* Start the message scheduler loop */
     	MessageLoop();
    }
#ifdef HW_CASIRA_UART
    else
    {
        MAIN_PRINT(("Failed to initialise UART\n"));
        Panic();
    }   
#endif	

    return 0;
}