main.c

根據bluelab3.5.2實例hid-keyboard做出應用

			}
			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);					
					PioSet(PIO_LED_RED,0);
					PioSet(PIO_LED_BLUE,0);
					MessageCancelAll(&theApp->task,APP_PAIRMODE_LED_UPDATE);
                    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_FIX_PIN_CODE_IND:
			theApp->Dyn_Fix_Pin_Code=TRUE;
		break;
		
		case APP_PAIRMODE_LED_UPDATE:
		
		/*add to 2007/06/21 by liuxiangchuan for pairing status LED*/
		
		MessageCancelAll(&theApp->task,APP_PAIRMODE_LED_UPDATE);
		
		PioSetDir(PIO_LED_BLUE,PIO_LED_BLUE);
		PioSetDir(PIO_LED_RED,PIO_LED_RED);
		
		{
		static bool led_bit = TRUE;

		if (led_bit == TRUE)
		{
			led_bit = FALSE;
			MAIN_PRINT(("Blue Led 0\n"));
			PioSet(PIO_LED_BLUE,0);
			PioSet(PIO_LED_RED,PIO_LED_RED);
		}
		else 
		{
			led_bit = TRUE;
			MAIN_PRINT(("BlueLed 1\n"));
			PioSet(PIO_LED_BLUE,PIO_LED_BLUE);
			PioSet(PIO_LED_RED,0);
		}
		
		MessageSendLater(&theApp->task, APP_PAIRMODE_LED_UPDATE, 0, 500);
		
		}
		break;
		
	    case  APP_NO_1_SHORT:
		if(state == appCabledConnected)
		{
			StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[1][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);
			
			/*StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);*/
			
		}		
		break;
	case APP_NO_1_RELEASE:
		StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
		StreamConnect(StreamHidSource(), theApp->interrupt_sink);
		
		break;
		case  APP_NO_2_SHORT:
		if(state == appCabledConnected)
		{
			StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[2][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);
			
			/*StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);*/
		}
		break;
		
		case  APP_NO_3_SHORT:
		if(state == appCabledConnected)
		{
			StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[3][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);
			
			/*StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);*/
		}
		
		break;
		
		case  APP_NO_4_SHORT:
		if(state == appCabledConnected)
		{
			StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[4][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);
			
			/*StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);*/
		}
		break;
		
		case  APP_NO_5_SHORT:
		if(state == appCabledConnected)
		{
			StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[5][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);
			
			/*StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        	HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
			StreamConnect(StreamHidSource(), theApp->interrupt_sink);*/
		}
		break;
		
	case APP_NO_2_RELEASE:
		StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
		StreamConnect(StreamHidSource(), theApp->interrupt_sink);
	break;
	case APP_NO_3_RELEASE:
		StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
		StreamConnect(StreamHidSource(), theApp->interrupt_sink);
	break;
	case APP_NO_4_RELEASE:
		StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
		StreamConnect(StreamHidSource(), theApp->interrupt_sink);
	break;
	/*case APP_NO_5_RELEASE:
		StreamDisconnect(StreamHidSource(), theApp->interrupt_sink);
        HidInterruptReport(theApp->hid,  hid_report_input, 9, &Button_Data[8][0]);
		StreamConnect(StreamHidSource(), theApp->interrupt_sink);
	break;*/
	case APP_DFU_BUTTON:
		PioSet(PIO_LED_BLUE,PIO_LED_BLUE);
		PioSet(PIO_LED_RED,PIO_LED_RED);
		BootSetMode(0);
	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  pin_code mode*/
		theApp.Dyn_Fix_Pin_Code = FALSE;
		PioSetDir(1<<8,1<<8);
		PioSet(1<<8,1<<8);		

        /* 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;
}