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