int ubertooth_usb_init(VendorRequestHandler *vendor_req_handler) { // initialise stack USBInit(); // register device descriptors USBRegisterDescriptors(abDescriptors); // Request handler v_req_handler = vendor_req_handler; // override standard request handler USBRegisterRequestHandler(REQTYPE_TYPE_VENDOR, usb_vendor_request_handler, abVendorReqData); // register endpoints //USBHwRegisterEPIntHandler(BULK_IN_EP, usb_bulk_in_handler); //USBHwRegisterEPIntHandler(BULK_OUT_EP, usb_bulk_out_handler); // enable USB interrupts //ISER0 = ISER0_ISE_USB; // connect to bus USBHwConnect(TRUE); return 0; }
void init_usb_msc_device(void) { DBG("Initialising USB stack\n"); // initialise stack USBInit(); // enable bulk-in interrupts on NAKs // these are required to get the BOT protocol going again after a STALL USBHwNakIntEnable(INACK_BI); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn); USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut); DBG("Starting USB communication\n"); // connect to bus USBHwConnect(TRUE); }
/* * Application entry point. */ int main(void) { // thread representing the shell Thread *shelltp = NULL; /* * System initializations. * - HAL initialization, this also initializes the configured device drivers * and performs the board-specific initializations. * - Kernel initialization, the main() function becomes a thread and the * RTOS is active. */ halInit(); chSysInit(); USBInit(); // main activity - shell respawn upon its termination. while (TRUE) { if (!shelltp && isUSBActive()) { // Checks if shell doesnt exist and USB is active /* Spawns a new shell.*/ shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO); } else { /* If the previous shell exited.*/ if (chThdTerminated(shelltp)) { /* Recovers memory of the previous shell.*/ chThdRelease(shelltp); shelltp = NULL; } } chThdSleepMilliseconds(500); } }
bool AndroidAccessory::switchDevice(int device) { if (1<=getProtocol(device)) { log("device supports protocol 1\r\n"); } else { log("could not read device protocol version\r\n"); return false; } sendString(device,ACCESSORY_STRING_MANUFACTURER,manufacturer); sendString(device,ACCESSORY_STRING_MODEL,model); sendString(device,ACCESSORY_STRING_DESCRIPTION,description); sendString(device,ACCESSORY_STRING_VERSION,version); sendString(device,ACCESSORY_STRING_URI,uri); sendString(device,ACCESSORY_STRING_SERIAL,serial); USBControlTransfer(device, HOST_TO_DEVICE |REQUEST_TYPE_VENDOR|RECIPIENT_DEVICE, ACCESSORY_START, 0,//value 0, //index 0, 0, 0, 0 ); wait_ms(4); //reset usb host USBInit(); return true; }
void USBSerial_Init(void) { // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // enable bulk-in interrupts on NAKs USBHwNakIntEnable(INACK_BI); // initialise VCOM serial_init(); NVIC_EnableIRQ(USB_IRQn); // connect to bus USBHwConnect(TRUE); }
void usb_msc_start (void) { debug("Initialising USB stack"); // initialise stack USBInit(); // enable bulk-in interrupts on NAKs // these are required to get the BOT protocol going again after a STALL USBHwNakIntEnable(INACK_BI); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn); USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut); debug("Starting USB communication"); // connect to bus USBHwConnect(true); // call USB interrupt handler continuously while (1) { USBHwISR(); } }
void USBSerial_Init(void) { char serialnumber[10] = {0}; char *pmem117; pmem117 = SECTOR_14_START; int serialnumber_present = 0; for (int i = 0; i < 10; i++) { serialnumber[9 - i] = *pmem117; pmem117++; if(*pmem117 != 0xFF) serialnumber_present = 1; } if(serialnumber_present == 1){ /* * abDescriptors[112+i] -> 112 is the position where the Serial Number string is located in the USB Descriptor */ abDescriptors[SERIAL_ADD] = serialnumber[0]; abDescriptors[SERIAL_ADD+2] = serialnumber[1]; abDescriptors[SERIAL_ADD+4] = serialnumber[2]; abDescriptors[SERIAL_ADD+6] = serialnumber[3]; abDescriptors[SERIAL_ADD+8] = serialnumber[4]; abDescriptors[SERIAL_ADD+10] = serialnumber[5]; abDescriptors[SERIAL_ADD+12] = serialnumber[6]; abDescriptors[SERIAL_ADD+14] = serialnumber[7]; abDescriptors[SERIAL_ADD+16] = serialnumber[8]; abDescriptors[SERIAL_ADD+18] = serialnumber[9]; } // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register endpoint handlers USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // enable bulk-in interrupts on NAKs USBHwNakIntEnable(INACK_BI); // é gerada uma interrupção sempre que o host tenta ler do EP IN mas este está vazio. // initialise VCOM fifo_init(&rxfifo, rxbuf); fifo_init(&txfifo, txbuf); NVIC_EnableIRQ(USB_IRQn); // connect to bus USBHwConnect(TRUE); }
int main() { // Setup and initialize the connection AdkTerm.setupDevice(); USBInit(); // Find the standard start value value = interpolate(5.0); // Begin the ticker that calls the servochanger flipper.attach(&servoChanger, 0.1); // continuously call the USB connection while(1) { USBLoop(); } }
/* * main */ int main(void) { FIO_ENABLE; pllstart_seventytwomhz() ; mam_enable(); uart0_init_115200() ; DBG(UART0,"Initialising USB stack\n"); // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); inputIsocDataBuffer[0] = 0; DBG(UART0,"Starting USB isoc datatpath test\n"); VICVectPriority22 = 0x01; VICVectAddr22 = (int) USBIntHandler; // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); vic_enableIRQ(); // connect to bus USBHwConnect(TRUE); stream_task(); return 0; }
/************************************************************************* main ==== **************************************************************************/ int main(void) { // PLL and MAM Initialize(); // init DBG ConsoleInit(60000000 / (16 * BAUD_RATE)); // initialise the SD card BlockDevInit(); DBG("Initialising USB stack\n"); // initialise stack USBInit(); // enable bulk-in interrupts on NAKs // these are required to get the BOT protocol going again after a STALL USBHwNakIntEnable(INACK_BI); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn); USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut); DBG("Starting USB communication\n"); // connect to bus USBHwConnect(TRUE); // call USB interrupt handler continuously while (1) { USBHwISR(); } return 0; }
void Hardware_::Init() { BOARD_INIT(); // Resetting because of a brownout power goes down. // Stay down buddy if (MCUSR == 4) PowerOff(); // now in bootloader Backlight_Init(); Timer_Init(); Accelerometer_Init(); ADC_Init(); USBInit(); Touch_Init(); sei(); // Attach stdout to usb serial StdOutInit(); }
/************************************************************************* main ==== **************************************************************************/ int main_mass_storage(void) { unsigned cpsr; // disable global interrupts, do it polling cpsr = disableIRQ(); // initialise the SD card BlockDevInit(); // initialise stack USBInit(); // enable bulk-in interrupts on NAKs // these are required to get the BOT protocol going again after a STALL USBHwNakIntEnable(INACK_BI); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(MSC_BULK_IN_EP, MSCBotBulkIn); USBHwRegisterEPIntHandler(MSC_BULK_OUT_EP, MSCBotBulkOut); // connect to bus USBHwConnect(TRUE); // call USB interrupt handler continuously while (1) { USBHwISR(); } // possibly restore global interrupts (never happens) restoreIRQ(cpsr); return 0; }
void AdkreadCallback(int device, int endpoint, int status, u8* buf, int len, void* userData) { log("AdkreadCallback(int device=%d, int endpoint=%x, int status=%d, u8* buf=%p, int len=%d, void* userData=%p)\r\n", device,endpoint,status,buf,len,userData); // __disable_irq(); AndroidAccessory* t = (AndroidAccessory*)userData; if (status!=0 && status!=8) { log("adk end.\r\n"); t->adkEnd(); // __enable_irq(); USBInit(); return; } //virtual method run t->callbackRead(buf,len); USBBulkTransfer(device, endpoint , buf, len, AdkreadCallback, userData); // wait_ms(4); // __enable_irq(); }
void platform_setup_usb_cdc(void) { int c; printf("Initialising USB stack\n"); // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // enable bulk-in interrupts on NAKs USBHwNakIntEnable(INACK_BI); // initialise VCOM VCOM_init(); printf("Starting USB communication\n"); // enable IRQ NVIC_EnableIRQ(USB_IRQn); // connect to bus printf("Connecting to USB bus\n"); USBHwConnect(TRUE); }
USBSerialStream::USBSerialStream(Stream *echoStream) : m_infifo(512), m_outfifo(512), m_bTransferInProgress(false), m_bDontStartNew(false), m_bConnected(false) { // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); USBHwRegisterDevIntHandler(DevIntHandler); USBHwRegisterFrameHandler(FrameHandler); // enable bulk-in interrupts on NAKs //USBHwNakIntEnable(INACK_BI); // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); (*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBHandlerSerial; UART_puts("Connecting USB\n\r"); // connect to bus USBHwConnect(TRUE); }
void MSInit() { //turn off A lot of crap CM1CON0bits.C1ON=0; CM1CON0=0; CM2CON0=0; SRCON0bits.SRLEN=0; //disable analog ANSEL=0; ANSELH=0; ADCON0bits.ADON=0; UARTInit(); RTCInit(); EPInit(); USBInit(); I2CInit(); LED_LATCH=0; LED_TRIS=0; SetLED(0); EnableOperation(); }
void vUSBTask( void *pvParameters ) { int c; /* Just to prevent compiler warnings about the unused parameter. */ ( void ) pvParameters; DBG("Initialising USB stack\n"); xRxedChars = xQueueCreate( usbBUFFER_LEN, sizeof( char ) ); xCharsForTx = xQueueCreate( usbBUFFER_LEN, sizeof( char ) ); if( ( xRxedChars == NULL ) || ( xCharsForTx == NULL ) ) { /* Not enough heap available to create the buffer queues, can't do anything so just delete ourselves. */ vTaskDelete( NULL ); } // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // enable bulk-in interrupts on NAKs USBHwNakIntEnable(INACK_BI); DBG("Starting USB communication\n"); NVIC_SetPriority( USB_IRQn, configUSB_INTERRUPT_PRIORITY ); NVIC_EnableIRQ( USB_IRQn ); // connect to bus DBG("Connecting to USB bus\n"); USBHwConnect(TRUE); // echo any character received (do USB stuff in interrupt) for( ;; ) { c = VCOM_getchar(); if (c != EOF) { // Echo character back with INCREMENT_ECHO_BY offset, so for example if // INCREMENT_ECHO_BY is 1 and 'A' is received, 'B' will be echoed back. VCOM_putchar(c + INCREMENT_ECHO_BY ); } } }
/************************************************************************* main ==== **************************************************************************/ int main(void) { int c, i; IODIR0 |= (1<<10); // PLL and MAM HalSysInit(); #ifdef LPC214x // init DBG ConsoleInit(60000000 / (16 * BAUD_RATE)); #else // init DBG ConsoleInit(72000000 / (16 * BAUD_RATE)); #endif DBG("Initialising USB stack\n"); // initialise stack USBInit(); configureADCPort(AD0_3); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); char ch = 'a'; for (i = 0; i < BYTES_PER_ISOC_FRAME; i++) { inputIsocDataBuffer[i] = ch; ch = (ch == 'z' ? 'a' : (ch + 1)); } DBG("Starting USB communication\n"); #ifdef LPC214x (*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler; #else VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler; #endif // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); enableIRQ(); // connect to bus USBHwConnect(TRUE); int x = 0; const int interval = 100000; // echo any character received (do USB stuff in interrupt) for(;;) { x++; U32 temp = cADC_Result(AD0_3); if( temp >= 0 && temp <= 1024 ) inputIsocDataBuffer[ADC_INPUT_INDEX] = temp; inputIsocDataBuffer[BUTTON1_INPUT_INDEX] = ((IOPIN0 & (1<<15)) ? 1 : 0); inputIsocDataBuffer[BUTTON2_INPUT_INDEX] = ((IOPIN0 & (1<<16)) ? 1 : 0); if (x == interval) { IOSET0 = (1<<11); //turn on led } else if (x >= (interval*2)) { IOCLR0 = (1<<11); //turn off led x = 0; } } return 0; }
int main() { __disable_irq(); // ------------------------------------------------------------------ // Desc: System Clk Config // // HCLK = PCLK2 = SYSCLK = 72M // PCLK1 = 36M // ------------------------------------------------------------------ SystemInit(); // SysTick_Config(SystemCoreClock / 1000); #if 0 // ------------------------------------------------------------------ // Desc: CLK OUTPUT for measure // ------------------------------------------------------------------ //PA8 alternate mode GPIO_InitTypeDef GPIO_InitStructure; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_PinAFConfig(GPIOA, GPIO_PinSource8, GPIO_AF_0); RCC_MCOConfig(RCC_MCOSource_PLLCLK,RCC_MCOPrescaler_1); // while(1); #endif // ------------------------------------------------------------------ // Desc: Debug // ------------------------------------------------------------------ DebugInit(); // d_printf("UART debug Init OK\r\n"); // ------------------------------------------------------------------ // Desc: ILX511 CLK ON // ------------------------------------------------------------------ #if 1 { GPIO_InitTypeDef GPIO_InitStructure; RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOB, &GPIO_InitStructure); } #endif #if 0 ILX_Init(); __enable_irq(); ILX_CLKOn(); delay_nms(50);//CCD power up ConvertOn(); #endif #if 0 d_printf("\r\n-------------------\r\n"); { uint32_t i; for(i=32;i<2048+32;i++) d_printf("0x%04X ",data[i]); } #endif #if 0 USBInit(); #endif #if 0 while (1) { if (bDeviceState == CONFIGURED) { CDC_Receive_DATA(); if (Receive_length != 0) { if (packet_sent == 1) CDC_Send_DATA ((unsigned char*)Receive_Buffer,Receive_length); Receive_length = 0; } } } #endif while(1); return 0; }
/************************************************************************* main ==== **************************************************************************/ int main(void) { int x = 0; const int interval = 200000; FIO_ENABLE; vic_disableIRQ(); pllstart_seventytwomhz() ; // pllstart_sixtymhz() ; // pllstart_fourtyeightmhz() ; mam_enable(); info_init(); uart0_init_115200() ; uart0_putstring("\n***Starting gfe color led test***\n\n"); uart0_putstring("\n***Board is defined as: "); uart0_putstring( infoquery_gfe_boardtag() ); uart0_putstring(" ***\n"); init_color_led(); RED_LED_OFF; BLUE_LED_OFF; GREEN_LED_OFF; printf_lpc(UART0,"5 FAST flashes...red, blue then green\n"); color_led_flash(5, RED_LED, FLASH_FAST ) ; RED_LED_OFF; color_led_flash(5, BLUE_LED, FLASH_FAST ) ; BLUE_LED_OFF; color_led_flash(5, GREEN_LED, FLASH_FAST ) ; GREEN_LED_OFF; uart0_putstring(" ** END OF TEST ""\n"); printf_lpc(UART0, "Initialising USB stack\n"); // initialize stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); inputIsocDataBuffer[0] = 0; printf_lpc(UART0, "Starting USB communication\n"); VICVectPriority22 = 0x01; // 0x0 is highest priority, 0xF is lowest VICVectAddr22 = (unsigned int)USBIntHandler; VICAddress = 0x0; printf_lpc(UART0, "addresses entered\n"); ENABLE_USB_IRQ; printf_lpc(UART0, "USB IRQ Enabled\n"); vic_enableIRQ(); printf_lpc(UART0, "vic_enable\n"); ENABLE_USB_INT; printf_lpc(UART0, "USB INT Enabled\n"); //printf_lpc(UART0, "connect to bus\n"); // // // connect to bus USBHwConnect(TRUE); // for(;;) { x++; if (x == interval) { RED_LED_ON; } else if (x >= (interval*2)) { x = 0; RED_LED_OFF; } } return 0; }
/************************************************************************* main ==== **************************************************************************/ int main(void) { // USB: Init // CAS -> Initialization of KbdInputReport to initial values (0,0,0,0,..) HIDDKbdInputReport_Initialize (&KbdInputReport); // CAS -> Variable used to simulate the pressing of Letter A (0x04) int i; DBG("Initialising USB stack\n"); // CAS -> Variable used to simulate the pressing of Letter A (0x04) // USBInit() // USBHwInit() HW Init // -> Set Pins for USB, AHBClock, ACK generate interrupts // USBHwRegisterDevIntHandler(HandleUsbReset) // -> Define un handler (HandleUsbReset). // // initialize stack USBInit(); // register device descriptors USBRegisterDescriptors(abDescriptors); // register HID standard request handler USBRegisterCustomReqHandler(HIDHandleStdReq); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint (2?). Interrupt In Endpoint USBHwRegisterEPIntHandler(INTR_IN_EP, NULL); // register frame handler USBHwRegisterFrameHandler(HandleFrame); DBG("Starting USB communication\n"); // connect to bus USBHwConnect(TRUE); //RC5: Init GPIO_SetDir(0,1<<4,1); GPIO_SetDir(0,1<<5,1); GPIO_SetValue(0,1<<5); GPIO_SetValue(0,1<<4); RC5_Init(); // main() Loop: // call USB interrupt handler continuously // CodeRed - either read mouse, or provide "fake mouse readings" while (1) { for (i=0; i<10; i++) { // RC5 if (RC5_flag) // wait for RC5 code { if((RC5_System==0)&&(RC5_Command==1)){ GPIO_ClearValue(0,1<<4); for(i=0;i<1000000;i++); GPIO_SetValue(0,1<<4); for(i=0;i<1000000;i++); } if((RC5_System==0)&&(RC5_Command==5)){ GPIO_ClearValue(0,1<<5); for(i=0;i<1000000;i++); GPIO_SetValue(0,1<<5); for(i=0;i<1000000;i++); } RC5_flag = 0; printf( "RC5 = %d %d\n", RC5_System, RC5_Command); } // RC5 USBHwISR(); if (i < 5) { KbdInputReport.Key_1 = 0x04; } else { KbdInputReport.Key_1 = 0x00; } } } return 0; }
/************************************************************************* main ==== **************************************************************************/ int main(void) { int c, i; // PLL and MAM HalSysInit(); #ifdef LPC214x // init DBG ConsoleInit(60000000 / (16 * BAUD_RATE)); #else // init DBG ConsoleInit(72000000 / (16 * BAUD_RATE)); #endif configureADCPort(AD0_3); DBG("Initialising USB stack\n"); // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); USBInitializeUSBDMA(udcaHeadArray); USBEnableDMAForEndpoint(ISOC_IN_EP); DBG("Starting USB communication\n"); #ifdef LPC214x (*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler; #else VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler; #endif // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); enableIRQ(); // connect to bus USBHwConnect(TRUE); int x = 0; c = EOF; //populate source data with all 'B's for(i = 0; i < ISOC_INPUT_DATA_BUFFER_SIZE; i++ ) { inputIsocDataBuffer[i] = 'B'; } int cnt = 0; const int interval = 100000; // echo any character received (do USB stuff in interrupt) for(;;) { x++; U32 temp = cADC_Result(AD0_3); if( temp >= 0 && temp <= 1024 ) currentADCReadValue = temp; if (x == interval) { qq++; IOSET0 = (1<<11); //turn on led } else if (x >= (interval*2)) { IOCLR0 = (1<<11); //turn off led x = 0; } } return 0; }
int main (void) { OS_ERR os_err; #if (CPU_CFG_NAME_EN == DEF_ENABLED) CPU_ERR cpu_err; #endif BSP_PreInit(); /* initialize basic board support routines */ #if (CPU_CFG_NAME_EN == DEF_ENABLED) CPU_NameSet((CPU_CHAR *)CSP_DEV_NAME, (CPU_ERR *)&cpu_err); #endif Mem_Init(); /* Initialize memory management module */ OSInit(&os_err); /* Init uC/OS-III */ // Debug_printf(Debug_Level_1, "Starting init"); #if 0 /* Enable Timer0 Interrupt.*/ CSP_IntVectReg((CSP_DEV_NBR )CSP_INT_CTRL_NBR_MAIN, (CSP_DEV_NBR )CSP_INT_SRC_NBR_TMR_00, (CPU_FNCT_PTR )App_TMR0_IntHandler, (void *)0); CSP_IntEn(CSP_INT_CTRL_NBR_MAIN, CSP_INT_SRC_NBR_TMR_00); /* Enable Timer1 Interrupt.*/ CSP_IntVectReg((CSP_DEV_NBR )CSP_INT_CTRL_NBR_MAIN, (CSP_DEV_NBR )CSP_INT_SRC_NBR_TMR_01, (CPU_FNCT_PTR )App_TMR1_IntHandler, (void *)0); CSP_IntEn(CSP_INT_CTRL_NBR_MAIN, CSP_INT_SRC_NBR_TMR_01); /* Enable Timer2 Interrupt.*/ CSP_IntVectReg((CSP_DEV_NBR )CSP_INT_CTRL_NBR_MAIN, (CSP_DEV_NBR )CSP_INT_SRC_NBR_TMR_02, (CPU_FNCT_PTR )App_TMR2_IntHandler, (void *)0); CSP_IntEn(CSP_INT_CTRL_NBR_MAIN, CSP_INT_SRC_NBR_TMR_02); CSP_TmrInit(); CSP_TmrCfg (CSP_TMR_NBR_00,TIMER_FREQ); CSP_TmrCfg (CSP_TMR_NBR_01,TIMER_FREQ); CSP_TmrCfg (CSP_TMR_NBR_02,TIMER_FREQ); #endif #if 0 // Init the Ethernet PHY EMAC_PinCfg(); emacConfigStruct.Mode = EMAC_MODE_100M_FULL; emacConfigStruct.pbEMAC_Addr = EthernetLinkLayer_macAddress(); OS_EMAC_Init(EthernetLinkLayer_rxSemaphore()); EMAC_Init(&emacConfigStruct); EMAC_SetFilterMode(EMAC_RFC_UCAST_EN, ENABLE); EMAC_SetFilterMode(EMAC_RFC_BCAST_EN, ENABLE); EMAC_SetFilterMode(EMAC_RFC_MCAST_EN, ENABLE); EMAC_SetFilterMode(EMAC_RFC_PERFECT_EN, ENABLE); EMAC_SetFilterMode(EMAC_RFC_MAGP_WOL_EN, DISABLE); EMAC_SetFilterMode(EMAC_RFC_PFILT_WOL_EN, DISABLE); // Init the Ethernt interrupt vecotrs CSP_IntVectReg((CSP_DEV_NBR )CSP_INT_CTRL_NBR_MAIN, (CSP_DEV_NBR )CSP_INT_SRC_NBR_ETHER_00, (CPU_FNCT_PTR )CSP_IntETH_Handler, (void *)0); CSP_IntEn(CSP_INT_CTRL_NBR_MAIN, CSP_INT_SRC_NBR_ETHER_00); EthernetLinkLayer_setMacAddress(macAddress); Ip_initialize(); Ip_setIPv4Address(ipv4Address); #endif #if 0 USBInit(); /* USB Initialization */ /* register descriptors */ USBRegisterDescriptors(abDescriptors); /* USB Descriptor Initialization */ /* register endpoint handlers */ USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); /* register BulkIn Handler for EP */ USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); /* register BulkOut Handler for EP */ USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwEPConfig(BULK_IN_EP, MAX_PACKET_SIZE); /* Configure Packet Size for outgoing Transfer */ USBHwEPConfig(BULK_OUT_EP, MAX_PACKET_SIZE); /* Configure Packet Size for incoming Transfer */ /* enable bulk-in interrupts on NAKs */ USBHwNakIntEnable(INACK_BI); #endif //Cb_initialize(&cncQueueBuffer, CNC_QUEUE_BUFFER_SIZE, sizeof(QueueItem), (void*)&cncQueueBufferData); // Debug_printf(Debug_Level_1, "Init finished"); if(os_err != OS_ERR_NONE) for(;;); OSTaskCreate((OS_TCB *)&App_TaskStartTCB, /* Create the Start Task */ (CPU_CHAR *)"Start", (OS_TASK_PTR )App_TaskStart, (void *)0, (OS_PRIO )4, (CPU_STK *)App_TaskStartStk, (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE_LIMIT, (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE, (OS_MSG_QTY )0u, (OS_TICK )0u, (void *)0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&os_err); OSStart(&os_err); /* Start Multitasking */ if(os_err != OS_ERR_NONE) /* shall never get here */ for(;;); return (0); }
/************************************************************************* main ==== **************************************************************************/ int main(void) { GO go_entry; // PLL and MAM Initialize(); // init DBG ConsoleInit(CCLK / (16 * BAUD_RATE)); DBG("Initialising USB stack\n"); write_ram_len=0; read_mem_len=0; unlocked=0; bEcho=1; // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register vendor request handler USBRegisterRequestHandler(REQTYPE_TYPE_VENDOR, HandleVendorRequest); // register pre request handler USBRegisterPreRequestHandler(PreHandleRequest); DBG("Starting USB communication\n"); // connect to bus USBHwConnect(TRUE); start_app = 0; // call USB interrupt handler continuously while (1) { USBHwISR(); if (start_app == 1) { volatile unsigned int count; // wait some time until response is sent for (count=0;count<10000;count++) USBHwISR(); // disconnect from bus USBHwConnect(FALSE); // wait some ms so that called app might safely re-connect usb for (count=0;count<300000;count++) count=count; go_entry = (GO) (start_adr); go_entry(); } } return 0; }
/************************************************************************* main ==== **************************************************************************/ bool USBStart(void) { int c; // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); // initialise VCOM VCOM_init(); VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler; // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); // connect to bus USBHwConnect(TRUE); #if TCM // echo any character received (do USB stuff in interrupt) while (1) { c = VCOM_getchar(); if (c != EOF) { // show on console if ((c == 9) || (c == 10) || (c == 13) || ((c >= 32) && (c <= 126))) { DBG("%c", c); } else { DBG("."); } VCOM_putchar(c); } } return 0; #endif return true; }
int main() { BOOT_INIT; #ifdef LED_PORT LED_PORT->FIODIR |= 1<<LED_PIN; #endif //init_printf(NULL, vcom_putc); //printf("a\n"); // #ifdef LED_PORT // LED_PORT->FIOCLR |= 1<<LED_PIN; // #endif int rstsrc = LPC_SC->RSID & 0xF; uint8_t wdreset = (rstsrc & (1<<2)) /*|| rstsrc == 0*/; LPC_SC->RSID = 0xF; #ifdef P2_10_RESET if(!(LPC_GPIO2->FIOPIN & 1<<10)) { LPC_SC->RSID = 0xF; NVIC_SystemReset(); } #endif if(!BOOT_ENTRY_CONDITION) { if(!wdreset && user_code_present() #ifdef P2_10_RESET && !(LPC_GPIO2->FIODIR & (1<<10)) #endif ) { //delay_busy(1000); execute_user_code(); } } SystemInit(); _segs_init(); //uart_init(); //init_printf(NULL, vcom_putc); SYSTICK_InternalInit(1); SYSTICK_IntCmd(ENABLE); SYSTICK_Cmd(ENABLE); #ifdef USB_CONNECT_PORT USB_CONNECT_PORT->FIODIR |= 1<<USB_CONNECT_PIN; #ifdef USB_CONNECT_INVERT USB_CONNECT_PORT->FIOSET |= 1<<USB_CONNECT_PIN; #endif #endif USBInit(); USBRegisterDescriptors(abDescriptors); //USBHwRegisterDevIntHandler(on_usb_device_status); usb_boot_init(); usbConnect(TRUE); NVIC_EnableIRQ(USB_IRQn); //printf("labas\n"); uint8_t timeout = 50; while(1) { //LED_PORT->FIOSET |= 1<<LED_PIN; #ifdef LED_PORT delay_busy(80); LED_PORT->FIOSET |= 1<<LED_PIN; delay_busy(80); LED_PORT->FIOCLR |= 1<<LED_PIN; #else delay_busy(160); #endif timeout--; if(timeout == 0 && wdreset && dfu_state == DFU_STATE_dfuIDLE) { //LPC_SC->RSID |= 1<<2; //clear wd reset bit usbConnect(FALSE); NVIC_SystemReset(); } #ifdef P2_10_RESET // if P2.10 is low, reset the system to enter ISP if(!(LPC_GPIO2->FIOPIN & 1<<10)) { NVIC_SystemReset(); } #endif } }
/************************************************************************* main ==== **************************************************************************/ int main(void) { /////////////////////////////////////////////////// // PRELUDE /////////////////////////////////////////////////// // PLL and MAM HalSysInit(); #ifdef LPC214x // init DBG ConsoleInit(60000000 / (16 * BAUD_RATE)); #else // init DBG ConsoleInit(72000000 / (16 * BAUD_RATE)); #endif DBG("Initialising USB stack\n"); // initialise stack USBInit(); // enable bulk-in interrupts on NAKs USBHwNakIntEnable(INACK_BI); // register descriptors USBRegisterDescriptors(isoDescriptors); //USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); USBHwRegisterEPIntHandler(BULK_IN_EP, BulkIn); USBHwRegisterEPIntHandler(BULK_OUT_EP, BulkOut); // USBHwRegisterEPIntHandler(ISOC_OUT_EP, IsocOut); // register frame handler //USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); bulk_init(); DBG("Starting USB communication\n"); #ifdef LPC214x (*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler; #else VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler; #endif // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); enableIRQ(); // connect to bus USBHwConnect(TRUE); ///////////////////////////////////////////// // FUNCTION ///////////////////////////////////////////// // int // bulk - echo // isoc A - regular - Broadcast numbers // isoc B - dma -echo // isoc C - dma ////////////////////////////////////////// // DEBUG LIGHTS ////////////////////////////////////////// int c; int x = 0; int ch ='a'; c = EOF; // echo any character received (do USB stuff in interrupt) while (1) { // Turn light on and off. x++; if (x == 400000) { IOSET0 = (1<<11); //turn on led if( ch > 'z' ) { ch = 'a'; } ch++; } else if (x >= 800000) { IOCLR0 = (1<<11); //turn off led x = 0; } } return 0; }
int main(void) { MainInit(); I2C1init(); RtcInit(); LcdInit(); DataLogInit(); StringInit(); Mct485Init(); FieldInit(); Ads1115Init(); Ads1244Init(); USBInit(); RtuInit(); AdcInit(); TC74Init(); // enable multi-vector interrupts INTEnableSystemMultiVectoredInt(); MainDelay(50); DataLogDateTime(DLOG_SFC_POWERUP); // init param after interrupts are enabled ParamInit(); // wait to init desiccant until after ParamInit DesiccantInit(); string[0].mct[0].chan[4] = 0x7FFF; // // Begin Main Loop // for (;;) { if (test == 1) { test = 0; FieldNewState((FIELD_STATE_m)t1); } USBUpdate(); // called as often as possible //sysTickEvent every ms if (sysTickEvent) { sysTickEvent = 0; sysTicks++; UsbTimeoutUpdate(); LcdUpdate(); // fill time before dropping LCD_E if (sysTicks >= 1000) { sysSec++; sysTicks = 0; mPORTDToggleBits(PD_LED_HEARTBEAT); // These Updates are // called once a second //TODO if any of these are long, we could split them on separate milliseconds. DesiccantUpdate(); AdcUpdate(); TC74Update(); }// end 1 Hz else if (sysTicks == 250) { mPORTDToggleBits(PD_LED_HEARTBEAT); } else if (sysTicks == 500) { mPORTDToggleBits(PD_LED_HEARTBEAT); } else if (sysTicks == 750) { mPORTDToggleBits(PD_LED_HEARTBEAT); } // Complete LcdUpdate() by dropping LCD_E) PORTClearBits(IOPORT_G, PG_LCD_E); // These Updates called once each millisecond RtcUpdate(); I2C1update(); StringUpdate(); Mct485Update(); FieldUpdate(); RtuUpdate(); DessicantFanPWMupdate(); } // if (sysTickEvent) } // for (;;) } // main()
/************************************************************************* main ==== **************************************************************************/ int main(void) { IODIR0 |= (1<<10);//Debug LED on the olimex 2148 dev board set to output mode IODIR0 |= (1<<11);//Debug LED on the olimex 2148 dev board set to output mode // PLL and MAM HalSysInit(); #ifdef LPC214x // init DBG ConsoleInit(60000000 / (16 * BAUD_RATE)); #else // init DBG ConsoleInit(72000000 / (16 * BAUD_RATE)); #endif DBG("Initialising USB stack\n"); // initialise stack USBInit(); // register descriptors USBRegisterDescriptors(abDescriptors); // register class request handler USBRegisterRequestHandler(REQTYPE_TYPE_CLASS, HandleClassRequest, abClassReqData); // register endpoint handlers USBHwRegisterEPIntHandler(INT_IN_EP, NULL); // register frame handler USBHwRegisterFrameHandler(USBFrameHandler); // register device event handler USBHwRegisterDevIntHandler(USBDevIntHandler); inputIsocDataBuffer[0] = 0; USBInitializeUSBDMA(udcaHeadArray); USBEnableDMAForEndpoint(ISOC_IN_EP); DBG("Starting USB communication\n"); #ifdef LPC214x (*(&VICVectCntl0+INT_VECT_NUM)) = 0x20 | 22; // choose highest priority ISR slot (*(&VICVectAddr0+INT_VECT_NUM)) = (int)USBIntHandler; #else VICVectCntl22 = 0x01; VICVectAddr22 = (int)USBIntHandler; #endif // set up USB interrupt VICIntSelect &= ~(1<<22); // select IRQ for USB VICIntEnable |= (1<<22); enableIRQ(); // connect to bus USBHwConnect(TRUE); int x = 0; const int interval = 200000; // echo any character received (do USB stuff in interrupt) for(;;) { x++; if (x == interval) { IOSET0 = (1<<11);//turn on led on olimex dev board } else if (x >= (interval*2)) { IOCLR0 = (1<<11);//turn off led on olimex dev board x = 0; } } return 0; }