/*---------------------------------------------------------------------------- Initialises the VCOM port. Call this function before using VCOM_putchar or VCOM_getchar *---------------------------------------------------------------------------*/ void VCOM_Init(void) { #if PORT_NUM CDC_Init (1); #else CDC_Init (0); #endif }
void USB_Device_CDC() { int numBytesToRead, numBytesRead, numAvailByte; static char serBuf [USB_CDC_BUFSIZE]; static unsigned char b[1]; b[0] = 'h'; #if PORT_NUM CDC_Init (1); #else CDC_Init (0); #endif Timer_Init(); LED_Init(); USB_Init(); USB_Connect(TRUE); // USB Connect while (!USB_Configuration) ; // wait until USB is configured uint8_t buffer[10]; uint32_t idx, len; while(1) { len = 0; while(len == 0) { len = UARTReceive((LPC_UART_TypeDef *)LPC_UART0, buffer, sizeof(buffer)); } idx = 0; while (idx < len) { UARTSend((LPC_UART_TypeDef *)LPC_UART0, &buffer[idx], 1); idx++; } USB_WriteEP (CDC_DEP_IN, buffer, len); /* CDC_OutBufAvailChar (&numAvailByte); if (numAvailByte > 0) { numBytesToRead = numAvailByte > 32 ? 32 : numAvailByte; numBytesRead = CDC_RdOutBuf (&serBuf[0], &numBytesToRead); USB_WriteEP (CDC_DEP_IN, (unsigned char *)&serBuf[0], numBytesRead); }*/ /* else { Timer_Delay(100); USB_WriteEP (CDC_DEP_IN, b, 1); }*/ } }
void systemInit() { cpuInit(); // Configure the CPU systickInit(CFG_SYSTICK_DELAY_IN_MS); // Start systick timer gpioInit(); // Enable GPIO pmuInit(); // Configure power management step_timer_init(); // Initialise USB CDC #ifdef CFG_USBCDC lastTick = systickGetTicks(); // Used to control output/printf timing CDC_Init(); // Initialise VCOM USB_Init(); // USB Initialization USB_Connect(TRUE); // USB Connect // Wait until USB is configured or timeout occurs uint32_t usbTimeout = 0; while (usbTimeout < CFG_USBCDC_INITTIMEOUT / 10) { if (USB_Configuration) break; systickDelay(10); // Wait 10ms usbTimeout++; } #endif // Printf can now be used with UART or USBCDC }
void main_cdc(void) { int dx = 0; //lastTick = systickGetTicks(); // Used to control output/printf timing lcdPrintln("Init USB"); lcdRefresh(); CDC_Init(); // Initialise VCOM USB_Init(); // USB Initialization USB_Connect(TRUE); // USB Connect // Wait until USB is configured or timeout occurs uint32_t usbTimeout = 0; while ( usbTimeout < CFG_USBCDC_INITTIMEOUT / 10 ) { if (USB_Configuration) break; delayms(10); // Wait 10ms usbTimeout++; } lcdPrintln("Done"); lcdRefresh(); uint8_t buf[2] = {0,0}; int l; while(1){ CDC_OutBufAvailChar(&l); if( l ){ l = 1; CDC_RdOutBuf (buf, &l); puts(buf); dx=DoString(dx,0,buf); lcdDisplay(); } //puts("hello world\r\n"); //delayms(1); } }
void slip_arch_init(unsigned long ubr) { (void)ubr; #if (SLIP_COMM == SLIP_USB) #if BRTOS_CPU == COLDFIRE_V1 (void)CDC_Init(); /* Initialize the USB CDC Application */ #elif BRTOS_CPU == ARM_Cortex_M0 USB_Init(); (void)cdc_Init(); /* Initialize the USB CDC Application */ #endif #endif #if (SLIP_COMM == SLIP_UART) #if BRTOS_CPU == COLDFIRE_V1 // Passado tamanho 0 de fila para não gerar fila do sistema // Passado prioridade 0 para não criar mutex uart_init(UART_NUMBER, 115200, 0, 0); #elif BRTOS_CPU == ARM_Cortex_M0 // Passado tamanho 0 de fila para não gerar fila do sistema Init_UART0(115200, 0); #endif #endif }
/**************************************************************************//** * @brief main - the entrypoint after reset. *****************************************************************************/ int main( void ) { BSP_Init(BSP_INIT_DEFAULT); /* Initialize DK board register access */ /* If first word of user data page is non-zero, enable eA Profiler trace */ BSP_TraceProfilerSetup(); CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO ); CMU_OscillatorEnable(cmuOsc_LFXO, true, false); if ( !MSDDMEDIA_Init() ) /* Initialize the media layer of the MSD. */ { EFM_ASSERT( false ); for( ;; ){} } VUD_Init(); /* Initialize the vendor unique device. */ CDC_Init(); /* Initialize the communication class device. */ MSDD_Init(gpioPortE, 1); /* Initialize the Mass Storage Device. */ USBD_Init(&initstruct); /* Start USB. */ /* * When using a debugger it is practical to uncomment the following three * lines to force host to re-enumerate the device. */ /* USBD_Disconnect(); */ /* USBTIMER_DelayMs( 1000 ); */ /* USBD_Connect(); */ for (;;) { MSDD_Handler(); /* Serve the MSD device. */ } }
void usb_init(void) { //printf("\n********** USB XCVR Module Testing **********\n"); USB_REG_SET_ENABLE; CDC_Init(); // Pull up enable FLAG_SET(USB_CONTROL_DPPULLUPNONOTG_SHIFT,USB0_CONTROL); }
void SerialCDC::setup(PinName tx, PinName rx, const char *name) { _tx = tx; _rx = rx; _available = false; USBIOClkConfig(); CDC_Init (); // CDC Initialization USB_Init(); // USB Initialization USB_Connect(1); // USB Connect while (!USB_Configuration) continue; // wait until USB is configured }
void Terminal_Task(void) { /* task setup */ (void) CDC_Init(); /* Initialize the USB CDC Application */ usb_terminal_init(cdc_putch); #if TERM_UART1 #define UART1_BUFSIZE 128 #if UART1_MUTEX uart_init(1,9600,UART1_BUFSIZE,TERM1_PINS,TRUE,UART1_MUTEX_PRIO); #else uart_init(1,9600,UART1_BUFSIZE,TERM1_PINS,FALSE,0); #endif #endif #if TERM_UART2 #define UART2_BUFSIZE 128 #if UART2_MUTEX uart_init(2,9600,UART2_BUFSIZE,TERM2_PINS,TRUE,UART2_MUTEX_PRIO); #else uart_init(2,9600,UART2_BUFSIZE,TERM2_PINS,FALSE,0); #endif #endif (void) usb_terminal_add_cmd((command_t*) &usb_ver_cmd); (void) usb_terminal_add_cmd((command_t*) &usb_top_cmd); (void) usb_terminal_add_cmd((command_t*) &usb_rst_cmd); (void) usb_terminal_add_cmd((command_t*) &usb_temp_cmd); (void) usb_terminal_add_cmd((command_t*) &setget_time_cmd); (void) usb_terminal_add_cmd((command_t*) &cat_cmd); (void) usb_terminal_add_cmd((command_t*) &ls_cmd); (void) usb_terminal_add_cmd((command_t*) &cd_cmd); (void) usb_terminal_add_cmd((command_t*) &mount_cmd); (void) usb_terminal_add_cmd((command_t*) &sr_cmd); (void) usb_terminal_add_cmd((command_t*) &rm_cmd); (void) usb_terminal_add_cmd((command_t*) &rn_cmd); (void) usb_terminal_add_cmd((command_t*) &cr_cmd); (void) usb_terminal_add_cmd((command_t*) &mkdir_cmd); (void) usb_terminal_add_cmd((command_t*) &cp_cmd); (void) usb_terminal_add_cmd((command_t*) &wt_cmd); (void) usb_terminal_add_cmd((command_t*) &echo_cmd); (void) usb_terminal_add_cmd((command_t*) &echo_stdout_cmd); (void) usb_terminal_add_cmd((command_t*) &esp_cmd); while (1) { /* Call the application task */ usb_terminal_process(); } }
void init_usbserial (void) { #ifdef ENABLE_BLUETOOTH bluetooth_suppress = TRUE; #endif /*ENABLE_BLUETOOTH */ fifo_out_count = fifo_in_count = 0; CDC_DepInEmpty = TRUE; CDC_Init (); /* USB Initialization */ USB_Init (); /* Connect to USB port */ USB_Connect (TRUE); }
void init () { cpuInit (); systickInit (1); gpioInit (); pmuInit (); CDC_Init (); USB_Init (); USB_Connect (TRUE); gpioSetDir (3, 0, 1); gpioSetValue (3, 0, 1); while (!USB_Configuration) { systickDelay (10); } gpioSetValue (3, 0, 0); }
void init_usbserial (void) { fifo_out_count = fifo_in_count = 0; CDC_DepInEmpty = TRUE; CDC_Init (); /* USB Initialization */ USB_Init (); /* Connect to USB port */ USB_Connect (TRUE); /* wait until USB is initialized */ while (!USB_Configuration) { pmu_wait_ms (90); GPIOSetValue (LED_PORT, LED_BIT, LED_ON); pmu_wait_ms (10); GPIOSetValue (LED_PORT, LED_BIT, LED_OFF); } }
void __usb_init_cdc() { //BSP_Init(BSP_INIT_DEFAULT); /* Initialize DK board register access */ //CMU_ClockSelectSet(cmuClock_HF, cmuSelect_HFRCO); /* Initialize the communication class device. */ CDC_Init(); /* Initialize and start USB device stack. */ USBD_Init(&usbInitStruct); /* * When using a debugger it is practical to uncomment the following three * lines to force host to re-enumerate the device. */ //USBD_Disconnect(); //USBTIMER_DelayMs(1000); //USBD_Connect(); }
int main(void) { /* Enable CT32B1 Timer, IOCON, and USB */ LPC_SYSCON->SYSAHBCLKCTRL |= (EN_CT32B1 | EN_USB_REG | EN_IOCON); /* Initialize GPIO */ GPIOInit(); /* Set LED port pin to output */ GPIOSetDir(LED_PORT, LED_BIT, 1); GPIOSetValue(LED_PORT, LED_BIT, 0); /* CDC Initialization */ CDC_Init(); /* USB Initialization */ USB_Init(); /* Connect to USB port */ USB_Connect(1); /* Update System Core Clock Value */ SystemCoreClockUpdate(); /* NVIC is installed inside UARTInit file. */ UARTInit(115200, 0); /* the following text is printed on the serial port as vTasksRunning * is not yet set to TRUE in serial_task - which will redirect * debug output to the CDC ACM USB serial device. */ debug_printf("Hello World!\n"); /* Create CDC ACM task */ xTaskCreate(serial_task, (const signed char*) "Serial", TASK_SERIAL_STACK_SIZE, NULL, TASK_SERIAL_PRIORITY, NULL); /* Start the tasks running. */ vTaskStartScheduler(); return 0; }
/*---------------------------------------------------------------------------- Initializes the VCOM port. Call this function before using VCOM_putchar or VCOM_getchar *---------------------------------------------------------------------------*/ void VCOM_Init (void) { CDC_Init (); }
void USB_ISR(void) { if(FLAG_CHK(USB_ISTAT_USBRST_SHIFT,USB0_ISTAT)) { // Clear Reset Flag //USB0_ISTAT = USB_ISTAT_USBRST_MASK; // Handle RESET Interrupt USB_Reset_Handler(); // Clearing this bit allows the SIE to continue token processing // and clear suspend condition //CTL_TXSUSPEND_TOKENBUSY = 0; //FLAG_CLR(USB_CTL_TXSUSPENDTOKENBUSY_SHIFT,USB0_CTL); // No need to process other interrupts return; } if(FLAG_CHK(USB_ISTAT_SOFTOK_SHIFT,USB0_ISTAT)) { USB0_ISTAT = USB_ISTAT_SOFTOK_MASK; } if(FLAG_CHK(USB_ISTAT_STALL_SHIFT,USB0_ISTAT)) //if(INT_STAT_STALL && INT_ENB_STALL_EN ) { USB_Stall_Handler(); } if(FLAG_CHK(USB_ISTAT_TOKDNE_SHIFT,USB0_ISTAT)) { FLAG_SET(USB_CTL_ODDRST_SHIFT,USB0_CTL); USB_Handler(); FLAG_SET(USB_ISTAT_TOKDNE_SHIFT,USB0_ISTAT); } if(FLAG_CHK(USB_ISTAT_SLEEP_SHIFT,USB0_ISTAT)) //if(INT_STAT_SLEEP && INT_ENB_SLEEP_EN_MASK) { // Clear RESUME Interrupt if Pending //INT_STAT = INT_STAT_RESUME_MASK; //u8ISRCounter++; //FLAG_SET(USB_ISTAT_RESUME_SHIFT,USB0_ISTAT); // Clear SLEEP Interrupt FLAG_SET(USB_ISTAT_SLEEP_SHIFT,USB0_ISTAT); //INT_STAT = INT_STAT_SLEEP_MASK; //FLAG_SET(USB0_INTEN_RESUME_SHIFT,USB0_ISTAT); //INT_ENB_RESUME_EN = 1; } if(FLAG_CHK(USB_ISTAT_ERROR_SHIFT,USB0_ISTAT)) //if(INT_STAT_ERROR && INT_ENB_ERROR_EN ) { FLAG_CHK(USB_ISTAT_ERROR_SHIFT,USB0_ISTAT); printf("\nUSB Error\n"); CDC_Init(); //INT_STAT_ERROR=1; } }
void main_kerosin(void) { uint8_t enterCnt = 0; uint8_t buffer[64]; // cpuInit(); // Configure the CPU systickInit(CFG_SYSTICK_DELAY_IN_MS); // Start systick timer gpioInit(); // Enable GPIO pmuInit(); // Configure power management adcInit(); // Config adc pins to save power lcdInit(); DoString(10,5,"USB plug"); // Initialise USB CDC #ifdef CFG_USBCDC DoString(10, 15, "USBCDC"); lastTick = systickGetTicks(); // Used to control output/printf timing CDC_Init(); // Initialise VCOM USB_Init(); // USB Initialization USB_Connect(TRUE); // USB Connect // Wait until USB is configured or timeout occurs uint32_t usbTimeout = 0; while ( usbTimeout < CFG_USBCDC_INITTIMEOUT / 10 ) { if (USB_Configuration) break; systickDelay(10); // Wait 10ms usbTimeout++; } #endif // Printf can now be used with UART or USBCDC puts("Hello World"); DoString(10, 25, "Enter:"); lcdDisplay(); int readData; while (1) { switch (getInput()) { case BTN_ENTER: enterCnt++; puts("ENTER\t"); buffer[0] = '0' + enterCnt; buffer[1] = 0; puts(buffer); puts("\r\n"); DoInt(50, 25, (int) (enterCnt)); lcdDisplay(); break; case BTN_LEFT: readData = CDC_GetInputBuffer(buffer, sizeof(buffer)); DoString(5, 40, buffer); DoString(1, 50, "Received: "); DoInt(57, 50, readData); lcdDisplay(); break; default: break; } } }
void CDC_Engine(void) { //uint16 u8RecData; /** re-init CDC class if a VBUS HIGH event was detected */ if (FLAG_CHK(VBUS_HIGH_EVENT,gu8ISR_Flags)) { FLAG_SET(USB_CTL_USBENSOFEN_MASK,USB0_CTL); u8CDCState = WAITING_FOR_ENUMERATION; enum_msg = TRUE; CDC_Init(); FLAG_CLR(VBUS_HIGH_EVENT,gu8ISR_Flags); } /* control Stage */ switch(u8CDCState) { case WAITING_FOR_ENUMERATION: /* Wait for USB Enumeration */ while(gu8USB_State!=uENUMERATED) { (void)u8CDCState; }; if (enum_msg) { printf ("\nUSB Enumerated, check your COM ports "); enum_msg = FALSE; } u8CDCState=0; break; case SET_LINE_CODING: if(FLAG_CHK(EP0,gu8USB_Flags)) { FLAG_CLR(EP0,gu8USB_Flags); (void)EP_OUT_Transfer(EP0,(uint8*)&LineCoding); EP_IN_Transfer(EP0,0,0); //vfnSCI1Init(); } break; case SET_CONTROL_LINE_STATE: EP_IN_Transfer(EP0,0,0); break; } /* Data stage */ /* if(FLAG_CHK(EP_OUT,gu8USB_Flags)) { u8RecData=USB_EP_OUT_SizeCheck(EP_OUT); // Check how many bytes from the PC usbEP_Reset(EP_OUT); usbSIE_CONTROL(EP_OUT); FLAG_CLR(EP_OUT,gu8USB_Flags); EP_IN_Transfer(EP2,CDC_OUTPointer,2); u8RecData=0; } */ }
// --------------------------------------------------------------------------- HRESULT CPU_USB_Initialize(int core) { if (core >= MAX_USB_CORE || USB_ENABLED(core)) return S_FALSE; USB_CONTROLLER_STATE *State = CPU_USB_GetState(core); const USB_ENDPOINT_DESCRIPTOR *pEpDesc; const USB_INTERFACE_DESCRIPTOR *pIfDesc; int epNum, ret; UINT32 queueId = 0; GLOBAL_LOCK(irq); // Initialize physical layer if (!USB_ENABLED(1 - core)) // No other USB controllers enabled? { LPC_CGU->PLL[CGU_USB_PLL].PLL_CTRL &= ~1; // Enable USB PLL while (!(LPC_CGU->PLL[CGU_USB_PLL].PLL_STAT & 1)); // Wait for USB PLL to lock } LPC_CGU->BASE_CLK[USB_CLK[core]] &= ~1; // Enable USBx base clock LPC_CREG->CREG0 &= ~(1 << 5); // Enable USB0 PHY if (core == 1) // Special init for USB1 { // Enable USB1_DP and USB1_DN on chip FS phy LPC_SCU->SFSUSB = 0x12; // USB device mode (0x16 for host mode) LPC_USB1->PORTSC1_D |= (1 << 24); } // Set USB state USB_STATE(core) = State; USB_FLAGS(core) = 0; ep_out_count[core] = 0; ep_in_count[core] = 0; State->EndpointStatus = USB_EPSTATUS(core); State->EndpointCount = USB_MAX_EP_NUM; State->PacketSize = MAX_EP0_SIZE; // Initialize USB stack ret = USB_InitStack(core); if (ret != RET_OK) return S_FALSE; // Exit if not succesful // Set defaults for unused endpoints for (epNum = 1; epNum < State->EndpointCount; epNum++) { State->IsTxQueue[epNum] = FALSE; State->MaxPacketSize[epNum] = MAX_EP_SIZE; } // Get endpoint configuration while (USB_NextEndpoint(State, pEpDesc, pIfDesc)) { // Figure out which endpoint we are initializing epNum = pEpDesc->bEndpointAddress & 0x7F; // Check interface and endpoint numbers against hardware capability if (epNum >= State->EndpointCount || pIfDesc->bInterfaceNumber > 3) return S_FALSE; if (pEpDesc->bEndpointAddress & 0x80) State->IsTxQueue[epNum] = TRUE; // Set the maximum size of the endpoint hardware FIFO int endpointSize = pEpDesc->wMaxPacketSize; // Exit if the endpoint maximum size in the configuration list is bogus // or greater than USB_MAX_DATA_PACKET_SIZE (default=64) if ((endpointSize != 8 && endpointSize != 16 && endpointSize != 32 && endpointSize != 64 && endpointSize != 128 && endpointSize != 256 && endpointSize != 512) || endpointSize > USB_MAX_DATA_PACKET_SIZE) return S_FALSE; State->MaxPacketSize[epNum] = endpointSize; // Assign queues QueueBuffers[queueId].Initialize(); // Clear queue before use State->Queues[epNum] = &QueueBuffers[queueId]; // Attach queue to endpoint queueId++; // Isochronous endpoints are currently not supported if ((pEpDesc->bmAttributes & 3) == USB_ENDPOINT_ATTRIBUTE_ISOCHRONOUS) return FALSE; } // Configure CDC driver ret = CDC_Init(core); if (ret != RET_OK) return S_FALSE; // Exit if not succesful // Connect and enable interrupts CPU_USB_ProtectPins(core, FALSE); CPU_INTC_ActivateInterrupt(USB_IRQ[core], USB_ISR[core], 0); USB_ENABLED(core) = TRUE; State->DeviceState = USB_DEVICE_STATE_CONFIGURED; // Config done by ROM stack USB_StateCallback(State); return S_OK; }
int main(void) { SystemCoreClockUpdate(); // Read IAP before any interrupts are enabled UPER_PART_NUMBER = IAP_GetPartNumber(); UPER_BOOT_CODE_VERSION = IAP_GetBootCodeVersion(); IAP_GetSerialNumber(GUID); // Init the rest of the system Time_init(); while (CDC_Init(&stream, GUID) != LPC_OK); // Load SFPPacketStream LPC_SYSCON->SYSAHBCLKCTRL |= BIT6 | BIT16 | BIT19; // Enable clock for GPIO, IOConfig and Pin Interrupts #ifndef DEBUG // Disabled for debugging (JTAG) lpc_config_gpioInit(); #endif // PIO0_4 and PIO0_5 forced to I2C LPC_IOCON->PIO0_4 |= 1; // I2C SCL LPC_IOCON->PIO0_5 |= 1; // I2C SDA /* SFP initialization, configuration and launch */ SFPServer *server = SFPServer_new(&stream); SFPServer_setDataTimeout(server, 30000); // 300k is about a second (30k ~100ms) /* GPIO/Pin functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_SETPRIMARY, UPER_FID_SETPRIMARY, lpc_config_setPrimary); SFPServer_addFunctionHandler(server, UPER_FNAME_SETSECONDARY, UPER_FID_SETSECONDARY, lpc_config_setSecondary); SFPServer_addFunctionHandler(server, UPER_FNAME_PINMODE, UPER_FID_PINMODE, lpc_pinMode); SFPServer_addFunctionHandler(server, UPER_FNAME_DIGITALWRITE, UPER_FID_DIGITALWRITE, lpc_digitalWrite); SFPServer_addFunctionHandler(server, UPER_FNAME_DIGITALREAD, UPER_FID_DIGITALREAD, lpc_digitalRead); SFPServer_addFunctionHandler(server, UPER_FNAME_ATTACHINTERRUPT, UPER_FID_ATTACHINTERRUPT, lpc_attachInterrupt); SFPServer_addFunctionHandler(server, UPER_FNAME_DETACHINTERRUPT, UPER_FID_DETACHINTERRUPT, lpc_detachInterrupt); SFPServer_addFunctionHandler(server, UPER_FNAME_PULSEIN, UPER_FID_PULSEIN, lpc_pulseIn); /* ADC functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_ANALOGREAD, UPER_FID_ANALOGREAD, lpc_analogRead); /* SPI functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_SPI0BEGIN, UPER_FID_SPI0BEGIN, lpc_spi0_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI0TRANS, UPER_FID_SPI0TRANS, lpc_spi0_trans); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI0END, UPER_FID_SPI0END, lpc_spi0_end); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI1BEGIN, UPER_FID_SPI1BEGIN, lpc_spi1_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI1TRANS, UPER_FID_SPI1TRANS, lpc_spi1_trans); SFPServer_addFunctionHandler(server, UPER_FNAME_SPI1END, UPER_FID_SPI1END, lpc_spi1_end); /* I2C functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_I2CBEGIN, UPER_FID_I2CBEGIN, lpc_i2c_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_I2CTRANS, UPER_FID_I2CTRANS, lpc_i2c_trans); SFPServer_addFunctionHandler(server, UPER_FNAME_I2CEND, UPER_FID_I2CEND, lpc_i2c_end); /* PWM functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_PWM0BEGIN, UPER_FID_PWM0BEGIN, lpc_pwm0_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM0SET, UPER_FID_PWM0SET, lpc_pwm0_set); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM0END, UPER_FID_PWM0END, lpc_pwm0_end); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM1BEGIN, UPER_FID_PWM1BEGIN, lpc_pwm1_begin); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM1SET, UPER_FID_PWM1SET, lpc_pwm1_set); SFPServer_addFunctionHandler(server, UPER_FNAME_PWM1END, UPER_FID_PWM1END, lpc_pwm1_end); /* Other functions */ SFPServer_addFunctionHandler(server, UPER_FNAME_RESTART, UPER_FID_RESTART, lpc_system_restart); SFPServer_addFunctionHandler(server, UPER_FNAME_GETDEVICEINFO, UPER_FID_GETDEVICEINFO, lpc_system_getDeviceInfo); SFPServer_loop(server); SFPServer_delete(server); while (1); }