u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout) { volatile UINT32* semaphore = (volatile UINT32*)sem; if(timeout != 0) { INT64 now = ::HAL_Time_CurrentTime(); INT64 elapsed = now + (timeout * 10000); while(elapsed > ::HAL_Time_CurrentTime()) { if(IsSemaphoreGreen(semaphore)) { AcquireSemaphore(semaphore); break; } if(INTERRUPTS_ENABLED_STATE()) { if(Events_WaitForEvents(SYSTEM_EVENT_FLAG_NETWORK, timeout)) { Events_Clear(SYSTEM_EVENT_FLAG_NETWORK); } } else { break; } } } else { while(1) { // wait and call the continuation for tcpip_thread if(IsSemaphoreGreen(semaphore)) { AcquireSemaphore(semaphore); break; } if(INTERRUPTS_ENABLED_STATE()) { Events_WaitForEvents(SYSTEM_EVENT_FLAG_NETWORK, EVENTS_TIMEOUT_INFINITE); Events_Clear(SYSTEM_EVENT_FLAG_NETWORK); } else { break; } } } return *semaphore; }
//////////////////////////////////////////////////////////////////////////////// // The WaitForTinyBooterUpload method was designed to allow porting kit partners // to define how/when tinybooter mode is entered as well as configure default // timeout values. // // timeout_ms - this parameter determines the time in milliseconds TinyBooter is // supposed to wait for commands from the host. A -1 value will // indicate to wait forever. // return value - the boolean return value indicates whether TinyBooter should enter // upload mode. If false is returned the booter will attempt to // launch the first application in FLASH that it finds. If the return // value is true, TinyBooter will wait for the given timeout value // (parameter timeout_ms) for valid commands before launching the first // application //////////////////////////////////////////////////////////////////////////////// bool WaitForTinyBooterUpload( INT32 &timeout_ms ) { bool enterBooterMode = false; GPIO_BUTTON_CONFIG * ButtonConfig = &g_GPIO_BUTTON_Config; // wait forever when using RAM build #if defined(TARGETLOCATION_RAM) enterBooterMode = true; timeout_ms = -1; #endif // user override (UP+DOWN buttons held) if (ButtonConfig->Mapping[BUTTON_USER_IDX].m_HW != GPIO_PIN_NONE) { Events_WaitForEvents(0,100); // wait for buttons to init if(!CPU_GPIO_GetPinState( ButtonConfig->Mapping[BUTTON_USER_IDX].m_HW )) { // user override, so lets stay forever timeout_ms = -1; enterBooterMode = true; } } return enterBooterMode; }
//////////////////////////////////////////////////////////////////////////////// // The WaitForTinyBooterUpload method was designed to allow porting kit partners // to define how/when tinybooter mode is entered as well as configure default // timeout values. // // timeout_ms - this parameter determines the time in milliseconds TinyBooter is // supposed to wait for commands from the host. A -1 value will // indicate to wait forever. // return value - the boolean return value indicates whether TinyBooter should enter // upload mode. If false is returned the booter will attempt to // launch the first application in FLASH that it finds. If the return // value is true, TinyBooter will wait for the given timeout value // (parameter timeout_ms) for valid commands before launching the first // application //////////////////////////////////////////////////////////////////////////////// bool WaitForTinyBooterUpload( INT32 &timeout_ms ) { bool enterBooterMode = false; GPIO_BUTTON_CONFIG * ButtonConfig = &g_GPIO_BUTTON_Config; // wait forever when using RAM build #if defined(TARGETLOCATION_RAM) enterBooterMode = true; timeout_ms = -1; #endif // user override (UP+DOWN buttons held) if ((ButtonConfig->Mapping[BUTTON_ENTR_IDX].m_HW != GPIO_PIN_NONE)) { Events_WaitForEvents(0,100); // wait for buttons to init if(!CPU_GPIO_GetPinState( ButtonConfig->Mapping[BUTTON_ENTR_IDX].m_HW)) { UINT32 down, up; // user override, so lets stay for 2sec timeout_ms = 2000; enterBooterMode = true; while(Buttons_GetNextStateChange(down, up) && (0 != (down & BUTTON_ENTR))); } } return enterBooterMode; }
void ApplicationEntryPoint() { while(true) { hal_printf("Hello World!\n"); Events_WaitForEvents(0, 3000); } }
UINT32 Events_WaitForEventsInternal( UINT32 sleepLevel, UINT32 WakeupSystemEvents, UINT32 Timeout_Milliseconds ) { NATIVE_PROFILE_PAL_EVENTS(); UINT32 events; // for internal HAL calls, we don't allow continuations SystemState_Set( SYSTEM_STATE_NO_CONTINUATIONS ); events = Events_WaitForEvents( sleepLevel, WakeupSystemEvents, Timeout_Milliseconds ); // no indirection, we already have one here SystemState_Clear( SYSTEM_STATE_NO_CONTINUATIONS ); // nestable return events; }
int DebuggerPort_Write( COM_HANDLE ComPortNum, const char* Data, size_t size ) { NATIVE_PROFILE_PAL_COM(); UINT32 transport = ExtractTransport(ComPortNum); const char* dataTmp = Data; INT32 totWrite = 0; int retries = 100; while(size > 0 && retries--) { int ret = 0; switch(transport) { case USART_TRANSPORT: ret = USART_Write( ConvertCOM_ComPort( ComPortNum ), dataTmp, size ); break; case USB_TRANSPORT: ret = USB_Write( ConvertCOM_UsbStream( ComPortNum ), dataTmp, size ); break; case SOCKET_TRANSPORT: ret = SOCKETS_Write( ConvertCOM_SockPort(ComPortNum), dataTmp, size ); break; } if(ret < 0) { break; } else if(ret == 0) { // if interrupts are off and our buffer is full then there is nothing we can do if(!INTERRUPTS_ENABLED_STATE()) break; Events_WaitForEvents(0, 1); } else { retries = 50; // reset retries size -= ret; dataTmp += ret; totWrite += ret; } } return totWrite; }
BOOL EnterMicroBooter(INT32& timeout) { CPU_GPIO_Initialize(); Events_WaitForEvents(0,100); // wait for buttons to init // check up/down button state if(!CPU_GPIO_GetPinState( MC9328MXL_GPIO::c_Port_B_10 ) && !CPU_GPIO_GetPinState( MC9328MXL_GPIO::c_Port_B_11 )) { // user override, so lets stay forever timeout = -1; return TRUE; } timeout = 0; return FALSE; }
BOOL EnterMicroBooter(INT32& timeout) { CPU_GPIO_Initialize(); Events_WaitForEvents(0,100); // wait for buttons to init // check up/down button state if(!CPU_GPIO_GetPinState( AT91_GPIO_Driver::PA25 ) && !CPU_GPIO_GetPinState( AT91_GPIO_Driver::PA27 )) { // user override, so lets stay forever timeout = -1; return TRUE; } timeout = 0; return FALSE; }
BOOL TEvents::TEvents_1() { UINT32 count = 100; UINT32 signaled; HAL_COMPLETION compObj; compObj.InitializeForISR(CompletionCallback, NULL); while (count--) { compObj.EnqueueDelta(1000*2); signaled = Events_WaitForEvents(s_event,50); if (signaled != s_event) { return false; } } return true; }
void ApplicationEntryPoint() { char Data[1], previousChar = '\0'; int ret = 0, TestItem = 0; BOOL validCommand = TRUE; MEMORY_MAPPED_NOR_BLOCK_CONFIG* config; // BlockStorageDevice *device; // ByteAddress datByteAddress; // BlockStorageList::FindDeviceForPhysicalAddress( &device, 0, datByteAddress ); // const BlockDeviceInfo * deviceInfo=device->GetDeviceInfo(); Data[1] = '\0'; char ip[15]; int length; unsigned long dest_ip=0; UINT32 sleep = 100; // TimedEvents eventsTest; // UART usartTest ( COMTestPort, 9600, USART_PARITY_NONE, 8, USART_STOP_BITS_ONE, USART_FLOW_NONE ); // GPIO gpioTest ( GPIOTestPin ); do { lcd_printf( "\n\n\n\n\n\n\n\n SH7619 EVB\n" ); lcd_printf( " Renesas America Inc." ); //Serial TEST hal_printf( "\r\nSH7619 EVB .NET Micro Framework NativeSample\r\n" ); hal_printf( "Renesas Electronics America Inc.\r\n" ); hal_printf( "61 MHz Clk,Big-endian\r\n" ); hal_printf( ">" ); NATIVE_PROFILE_PAL_EVENTS(); do { UINT32 Events = Events_WaitForEvents( SYSTEM_EVENT_FLAG_COM_IN | SYSTEM_EVENT_FLAG_ETHER, sleep ); // if(Events == 0) // { // hal_printf("Slept %d sec\r\n", sleep / 1000); // sleep += 1000; // continue; // } if(Events & SYSTEM_EVENT_FLAG_ETHER) { //Network_Interface_Process_Packet(); //hal_printf("ETHER event\r\n"); Events_Clear( SYSTEM_EVENT_FLAG_ETHER ); } if(Events & SYSTEM_EVENT_FLAG_COM_IN) { Events_Clear( SYSTEM_EVENT_FLAG_COM_IN ); while((ret = DebuggerPort_Read( HalSystemConfig.DebugTextPort, Data, 1 )) > 0) { switch(TestItem) { case 0: //None if(Data[0] == 0xD) //0xD: ENTER key { hal_printf( "\r\n" ); if(validCommand) { TestItem = 1; //Enter test validCommand = FALSE; previousChar = '\0'; hal_printf( "\r\nTest Menu:\r\n" ); hal_printf( " [L]CD Tests\r\n" ); hal_printf( " [K]eypad Tests\r\n" ); hal_printf( " [N]etwork Tests\r\n" ); hal_printf( " [F]lash memory Tests\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); } else if(previousChar == 'I') { hal_printf("** Invalid Selection\r\n>"); previousChar = '\0'; } else hal_printf( ">" ); } else { hal_printf( Data ); if(Data[0] == 'd' || Data[0] == 'D') { if(previousChar == '\0') previousChar = 'd'; else { validCommand = FALSE; previousChar = 'I'; //Invalid character input } } else if(Data[0] == 't' || Data[0] == 'T') { if(previousChar == 'd') { previousChar = 't'; validCommand = TRUE; } else { validCommand = FALSE; previousChar = 'I'; //Invalid character input } } else { validCommand = FALSE; previousChar = 'I'; //Invalid character input } } break; case 1: //Enter test hal_printf( Data ); switch(Data[0]) { case 'X': case 'x': TestItem = 0; hal_printf( "\r\n\n>" ); break; case 'L': case 'l': TestItem = 5; hal_printf( "\r\n\nLCD Menu:\r\n" ); hal_printf( " 1: Display colorful rectangles\r\n" ); hal_printf( " 2: Colorful wireframe rectangle\r\n" ); hal_printf( " 3: Colorful solid rectangle\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case 'K': case 'k': KeyPad_Test(); break; case 'N': case 'n': TestItem = 7; hal_printf( "\r\n\nEthernet Menu:\r\n" ); hal_printf( " [1]Read IP Address\r\n" ); hal_printf( " [2]Read EtherC Registers\r\n" ); hal_printf( " [3]Read E-DMAC Registers\r\n" ); hal_printf( " [4]Ping Test\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case 'F': case 'f': TestItem = 8; hal_printf( "\r\n\nFlash memory Menu:\r\n" ); hal_printf( " [1]Erase block\r\n" ); hal_printf( " [2]write block\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; default: hal_printf( "\r\n\nTest Menu:\r\n" ); hal_printf( " [L]CD Tests\r\n" ); hal_printf( " [K]eypad Tests\r\n" ); hal_printf( " [N]etwork Tests\r\n" ); hal_printf( " [F]lash memory Tests\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; } break; case 5: //LCD test hal_printf( Data ); switch(Data[0]) { case 'X': case 'x': TestItem = 1; hal_printf( "\r\n\nTest Menu:\r\n" ); hal_printf( " [L]CD Tests\r\n" ); hal_printf( " [K]eypad Tests\r\n" ); hal_printf( " [N]etwork Tests\r\n" ); hal_printf( " [F]lash memory Tests\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '1': LCDTest_Driver::LCD_Sample1(); hal_printf( "\r\n\nLCD Menu:\r\n" ); hal_printf( " 1: Display colorful rectangles\r\n" ); hal_printf( " 2: Colorful wireframe rectangle\r\n" ); hal_printf( " 3: Colorful solid rectangle\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '2': LCDTest_Driver::LCD_Sample2(0); hal_printf( "\r\n\nLCD Menu:\r\n" ); hal_printf( " 1: Display colorful rectangles\r\n" ); hal_printf( " 2: Colorful wireframe rectangle\r\n" ); hal_printf( " 3: Colorful solid rectangle\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '3': LCDTest_Driver::LCD_Sample2(1); hal_printf( "\r\n\nLCD Menu:\r\n" ); hal_printf( " 1: Display colorful rectangles\r\n" ); hal_printf( " 2: Colorful wireframe rectangle\r\n" ); hal_printf( " 3: Colorful solid rectangle\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; default: hal_printf( "\r\n\nLCD Menu:\r\n" ); hal_printf( " 1: Display colorful rectangles\r\n" ); hal_printf( " 2: Colorful wireframe rectangle\r\n" ); hal_printf( " 3: Colorful solid rectangle\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; } break; case 7: //Ethernet test hal_printf( Data ); hal_printf( "\r\n" ); switch(Data[0]) { case 'X': case 'x': TestItem = 1; hal_printf( "\r\n\nTest Menu:\r\n" ); hal_printf( " [L]CD Tests\r\n" ); hal_printf( " [K]eypad Tests\r\n" ); hal_printf( " [N]etwork Tests\r\n" ); hal_printf( " [F]lash memory Tests\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '1': //Network_Interface_IP_Address(); hal_printf( "\r\n\nEthernet Menu:\r\n" ); hal_printf( " [1]Read IP Address\r\n" ); hal_printf( " [2]Read EtherC Registers\r\n" ); hal_printf( " [3]Read E-DMAC Registers\r\n" ); hal_printf( " [4]Ping Test\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '2': //Network_Interface_EtherC_Registers(); hal_printf( "\r\n\nEthernet Menu:\r\n" ); hal_printf( " [1]Read IP Address\r\n" ); hal_printf( " [2]Read EtherC Registers\r\n" ); hal_printf( " [3]Read E-DMAC Registers\r\n" ); hal_printf( " [4]Ping Test\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '3': //Network_Interface_EDMAC_Registers(); hal_printf( "\r\n\nEthernet Menu:\r\n" ); hal_printf( " [1]Read IP Address\r\n" ); hal_printf( " [2]Read EtherC Registers\r\n" ); hal_printf( " [3]Read E-DMAC Registers\r\n" ); hal_printf( " [4]Ping Test\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '4': //do //{ // hal_printf( "\r\nEnter dest IP: " ); // Get_IP_String(ip, &length); // if( (dest_ip = Is_IP_Address(ip, length)) == 0) // hal_printf( "\r\n*** Invalid IP Address!\r\n" ); //}while(dest_ip == 0); //Ether_Ping(dest_ip, 4); hal_printf( "\r\n\nEthernet Menu:\r\n" ); hal_printf( " [1]Read IP Address\r\n" ); hal_printf( " [2]Read EtherC Registers\r\n" ); hal_printf( " [3]Read E-DMAC Registers\r\n" ); hal_printf( " [4]Ping Test\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; default: hal_printf( "\r\n\nEthernet Menu:\r\n" ); hal_printf( " [1]Read IP Address\r\n" ); hal_printf( " [2]Read EtherC Registers\r\n" ); hal_printf( " [3]Read E-DMAC Registers\r\n" ); hal_printf( " [4]Ping Test\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; } break; case 8: //Flash memory test hal_printf( Data ); hal_printf( "\r\n" ); switch(Data[0]) { case 'X': case 'x': TestItem = 1; hal_printf( "\r\n\nTest Menu:\r\n" ); hal_printf( " [L]CD Tests\r\n" ); hal_printf( " [K]eypad Tests\r\n" ); hal_printf( " [N]etwork Tests\r\n" ); hal_printf( " [F]lash memory Tests\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '1': g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG); g_AM29DL_16_BS_DeviceTable.EraseBlock(pBLOCK_CONFIG,0xa0080000); hal_printf( "\r\n\nFlash memory Menu:\r\n" ); hal_printf( " [1]Erase block\r\n" ); hal_printf( " [2]write block\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; case '2': BYTE Buff[0x10]; for(int i=0; i<0x10; i++) Buff[i]=i; g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG); g_AM29DL_16_BS_DeviceTable.Write(pBLOCK_CONFIG,0xa0080000,0x10,Buff,0x0); hal_printf( "\r\n\nFlash memory Menu:\r\n" ); hal_printf( " [1]Erase block\r\n" ); hal_printf( " [2]write block\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; default: hal_printf( "\r\n\nFlash memory Menu:\r\n" ); hal_printf( " [1]Erase block\r\n" ); hal_printf( " [2]write block\r\n" ); hal_printf( " E[x]it\r\n" ); hal_printf( "Your choice: " ); break; } break; } } } } while(TRUE); } while(FALSE); // run only once! }
void ApplicationEntryPoint() { UINT32 ComEvent; g_State.Initialize(); ComEvent = 0; if(COM_IsSerial(g_State.UsartPort) && (g_State.UsartPort != COM_NULL)) { ComEvent = SYSTEM_EVENT_FLAG_COM_IN; } #if !defined(TARGETLOCATION_RAM) g_State.WaitForActivity = (g_State.ProgramCount != 0); // is there a main app? #else g_State.WaitForActivity = FALSE; // forever #endif { UINT32 ButtonsPressed; UINT32 ButtonsReleased; char c; // clear any events present from startup while(Events_Get( SYSTEM_EVENT_FLAG_ALL )); // clear any junk from com port buffers while(DebuggerPort_Read( g_State.UsartPort, &c, sizeof(c) )); // clear any junk from button buffer while(Buttons_GetNextStateChange( ButtonsPressed, ButtonsReleased )); } { BOOL ProcessingSREC = FALSE; BOOL ProcessingXREC = FALSE; INT32 ProcessingZENFLASH = 0; INT32 Mode = 0; INT32 MenuChoice = 1; // main application location when USB not enabled BOOL MenuUpdate = TRUE; UINT32 USBEvent = 0; COM_HANDLE ReadPort = COM_NULL; int MenuOffset = 1; // no USB enabled INT64 WaitTimeout = 0; #if defined(PLATFORM_ARM_MOTE2) CPU_GPIO_SetPinState( LED1_GREEN, LED_ON ); #endif if(g_State.WaitForActivity) { WaitTimeout = HAL_Time_CurrentTime() + (INT64)g_State.WaitInterval * (10 * 1000); hal_printf( "Waiting %d.%03d second(s) for hex upload\r\n", g_State.WaitInterval / 1000, g_State.WaitInterval % 1000 ); } else { hal_printf( "Waiting forever for hex upload\r\n" ); } // checking the existence of Usb Driver, all the default values are set to no USB if( USB_DEVICE_STATE_NO_CONTROLLER != USB_GetStatus( ConvertCOM_UsbController(g_State.UsbPort) ) ) { g_State.UsingUsb = TRUE; MenuChoice = 2; MenuOffset = 2; } while(true) { if(MenuUpdate) { MenuUpdate = FALSE; LCD_Clear(); hal_fprintf( STREAM_LCD, "\f"); switch(Mode) { case 0: hal_fprintf( STREAM_LCD, " Zen Boot\r\n\r\n" ); hal_fprintf( STREAM_LCD, "%c PortBooter\r\n", MenuChoice == 0 ? '*' : ' ' ); if(g_State.UsingUsb) { hal_fprintf( STREAM_LCD, "%c FlashUSB\r\n", MenuChoice == 1 ? '*' : ' ' ); } for(int i = 0; i < g_State.ProgramCount; i++) { hal_fprintf( STREAM_LCD, "%c Prg:%08x\r\n", (i+MenuOffset) == MenuChoice ? '*' : ' ', g_State.Programs[i] ); } break; case 1: hal_printf( "PortBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION); hal_fprintf( STREAM_LCD, "Waiting forever for hex upload\r\n" ); break; case 2: hal_fprintf( STREAM_LCD, "FlashUSB\r\n" ); hal_fprintf( STREAM_LCD, "Waiting forever for hex upload\r\n" ); break; } } UINT32 Events = Events_WaitForEvents( ComEvent | SYSTEM_EVENT_FLAG_BUTTON | SYSTEM_EVENT_FLAG_USB_IN, 2000 ); if(Events & SYSTEM_EVENT_FLAG_BUTTON) { UINT32 ButtonsPressed; UINT32 ButtonsReleased; Events_Clear( SYSTEM_EVENT_FLAG_BUTTON ); while(Buttons_GetNextStateChange( ButtonsPressed, ButtonsReleased )); { if(g_State.SerialPortActive == FALSE) { //printf("%02x %02x\r\n", ButtonsPressed, ButtonsReleased); // up if(ButtonsPressed & BUTTON_UP) { switch(Mode) { case 0: MenuChoice = __max( MenuChoice-1, 0 ); break; } g_State.WaitForActivity = FALSE; MenuUpdate = TRUE; } // down if(ButtonsPressed & BUTTON_DOWN) { switch(Mode) { case 0: MenuChoice = __min( MenuChoice+1, g_State.ProgramCount + MenuOffset-1 ); break; } g_State.WaitForActivity = FALSE; MenuUpdate = TRUE; } // enter button if(ButtonsPressed & BUTTON_ENTR) { switch(Mode) { case 0: if(MenuChoice == 0) { Mode = 1; //UsingUsb = FALSE; } else if(g_State.UsingUsb && MenuChoice == 1) { Mode = 2; USB_Configure( ConvertCOM_UsbController(g_State.UsbPort), &UsbDefaultConfiguration ); USB_Initialize( ConvertCOM_UsbController(g_State.UsbPort) ); USB_OpenStream( ConvertCOM_UsbStream(g_State.UsbPort), USB_DEBUG_EP_WRITE, USB_DEBUG_EP_READ ); //UsingUsb = TRUE; } else { StartApplication( (void (*)())g_State.Programs[MenuChoice-MenuOffset] ); } break; case 1: Mode = 0; break; case 2: // USB_Uninitialize(); Mode = 0; break; } g_State.WaitForActivity = FALSE; MenuUpdate = TRUE; } if(ButtonsReleased) { MenuUpdate = TRUE; } } } } if((Events & ComEvent) || (Events & SYSTEM_EVENT_FLAG_USB_IN)) { char c; if(Events & ComEvent) { Events_Clear( ComEvent ); ReadPort = g_State.UsartPort; g_State.pStreamOutput = ReadPort; } else { USBEvent = USB_GetEvent( ConvertCOM_UsbController(g_State.UsbPort), USB_EVENT_ALL ); if( !(USBEvent & g_State.UsbEventCode) ) continue; g_State.pStreamOutput = g_State.UsbPort; ReadPort = g_State.UsbPort; } while(DebuggerPort_Read( ReadPort, &c, sizeof(c) )) { if(ProcessingSREC) { ProcessingSREC = g_SREC.Process( c ); } else if(ProcessingXREC) { ProcessingXREC = g_XREC.Process( c ); } else if(ProcessingZENFLASH) { const char Signature[] = "ZENFLASH\r"; //printf( "Got %d at %d\r\n", c, ProcessingZENFLASH ); if(Signature[ProcessingZENFLASH++] == c) { if(Signature[ProcessingZENFLASH] == 0) { SignalActivity(); ProcessingZENFLASH = 0; } } else { ProcessingZENFLASH = 0; } } else if('S' == c) { ProcessingSREC = TRUE; } else if('X' == c) { ProcessingXREC = TRUE; } else if('Z' == c) { ProcessingZENFLASH = 1; } } } if(g_State.WaitForActivity && WaitTimeout < HAL_Time_CurrentTime()) { #if defined(PLATFORM_ARM_MOTE2) CPU_GPIO_SetPinState(LED1_GREEN, LED_OFF); // Turn off Green LED for iMOTE2 #endif // we didn't see anything on serial port for wait interval (2 seconds nominally), // continue with code - just run the normal application StartApplication( (void (*)())g_State.Programs[0] ); } } } }
void Initialize() { #if defined(PLATFORM_ARM_MOTE2) if (COM_IsUsb(HalSystemConfig.DebugTextPort)) WaitInterval = 5000; // The USB port must be selected and the Start button pressed all during this time else WaitInterval = 2000; // The USART port may be selected before powering on the Imote2, so it takes less time #else WaitInterval = 2000; #endif SerialPortActive = FALSE; UsartPort = USART_DEFAULT_PORT; UsingUsb = FALSE; UsbPort = USB1; UsbEventCode = USB_DEBUG_EVENT_IN; //--// // wait an extra second for buttons and COM port to stabilize Events_WaitForEvents( 0, 1000 ); // COM init is now delayed for TinyBootloader, so we need to initialize it here CPU_InitializeCommunication(); //--// // set default baud rate if(UsartPort != DEBUG_TEXT_PORT) { DebuggerPort_Initialize( UsartPort ); } // extra time to allow USB setup, so that we can see the printf Events_WaitForEvents( 0, 1000 ); hal_printf( "PortBooter v%d.%d.%d.%d\r\n", VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD, VERSION_REVISION); hal_printf( "Build Date: %s %s\r\n", __DATE__, __TIME__); #if defined(__GNUC__) hal_printf( "GNU Compiler version %d\r\n", __GNUC__); #elif defined(__ADSPBLACKFIN__) hal_printf( "Blackfin Compiler version %d\r\n", __VERSIONNUM__ ); #else hal_printf( "ARM Compiler version %d\r\n", __ARMCC_VERSION); #endif //--// BlockStorageStream stream; FLASH_WORD ProgramWordCheck; if(!stream.Initialize(BlockUsage::CODE)) return; do { do { UINT32 addr = stream.CurrentAddress(); FLASH_WORD *pWord = &ProgramWordCheck; stream.Read( (BYTE**)&pWord, sizeof(FLASH_WORD) ); if(*pWord == PROGRAM_WORD_CHECK) { hal_printf("*** nXIP Program found at 0x%08x\r\n", addr ); Programs[ProgramCount++] = (UINT32)addr; } if(ProgramCount == MAX_PROGRAMS) break; } while( stream.Seek( BlockStorageStream::STREAM_SEEK_NEXT_BLOCK, BlockStorageStream::SeekCurrent ) ); } while(stream.NextStream()); }
RTP_BOOL SH7619_EDMAC_open(PIFACE pi) { PSH7619_EDMAC_SOFTC sc = iface_to_softc(pi); char c[1],Buffer[17]; int i; UINT32 Events; BYTE Buff[6]; if (!sc) { RTP_DEBUG_ERROR("SH7619_EDMAC_open: softc invalid!\r\n", NOVAR, 0, 0); set_errno(ENUMDEVICE); return(RTP_FALSE); } // Set Interface sc->iface = pi; iface = pi; int macLen = __min(g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressLen, sizeof(sc->mac_address)); if(macLen > 0) { int addr = MAC_address_area; for(i=0; i<macLen; i++) g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[i] = *(volatile char *)(addr+i); debug_printf( "MAC Address: %x.%x.%x.%x.%x.%x\r\n", (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[0], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[1], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[2], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[3], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[4], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[5]); debug_printf( "Do you need to change MAC Address? If yes, press 'Enter' key\r\n" ); c[0] = 0x0; for (i=0; i<0xff; i++){ DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1); if (c[0] == 0x0d){ hal_printf( "new MAC Address :" ); while(c[0] == 0x0d) DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1); for(i=0; i<17; ){ Events = Events_WaitForEvents( SYSTEM_EVENT_FLAG_COM_IN, 100 ); if(Events & SYSTEM_EVENT_FLAG_COM_IN){ Events_Clear( SYSTEM_EVENT_FLAG_COM_IN ); DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1); Buffer[i] = c[0]; i++; } } for (i=0; i<17; i++) hal_printf( "%c",Buffer[i] ); hal_printf( "\r\n"); for(i=0; i<macLen; i++) { Buff[i]=SH7619_EDMAC_AtoH(Buffer[i*3])*0x10; Buff[i]+=SH7619_EDMAC_AtoH(Buffer[i*3+1]); } for(i=0; i<macLen; i++) { g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[i]=Buff[i]; } debug_printf( "Updating...\r\n" ); g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG); g_AM29DL_16_BS_DeviceTable.EraseBlock(pBLOCK_CONFIG,MAC_address_area); g_AM29DL_16_BS_DeviceTable.Write(pBLOCK_CONFIG,MAC_address_area,macLen,Buff,0x0); debug_printf( "Done\r\n" ); i=0x100; } } memcpy(&sc->mac_address[0], &g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[0], macLen); } else { RTP_DEBUG_ERROR("Device initialize without MAC address!!!\r\n", NOVAR, 0, 0); } /* Now put in a dummy ethernet address */ rtp_memcpy(&pi->addr.my_hw_addr[0], sc->mac_address, 6); // Get the ethernet address /* clear statistic information */ sc->stats.packets_in = 0L; sc->stats.packets_out = 0L; sc->stats.bytes_in = 0L; sc->stats.bytes_out = 0L; sc->stats.errors_in = 0L; sc->stats.errors_out = 0L; if(RTP_FALSE == SH7619_EDMAC_SetupDevice()) { return RTP_FALSE; } rtp_irq_hook_interrupt( (RTP_PFVOID) pi, (RTP_IRQ_FN_POINTER)SH7619_EDMAC_recv, (RTP_IRQ_FN_POINTER) 0); return(RTP_TRUE); }
void Test_OpenSSL_ClientServerAuth() { LCD_Clear(); lcd_printf("Testing SSL Client/Server negotiations...\n"); int err; int client_numbytes, server_numbytes; int listen_sd; int server_sd; int client_sd; struct TINYCLR_SSL_SOCKADDR_IN sa_serv; struct TINYCLR_SSL_SOCKADDR_IN sa_cli; size_t client_len; SSL_CTX* server_ctx = NULL; SSL* server_ssl = NULL; X509* server_cert = NULL; SSL_CTX* client_ctx = NULL; SSL* client_ssl = NULL; X509* client_cert = NULL; char* str = NULL; char client_buf [256]; char server_buf [256]; SSL_METHOD *server_meth = NULL; SSL_METHOD *client_meth = NULL; BIO *cert = NULL; X509 *x = NULL; EVP_PKEY *pkey = NULL; // SSL preliminaries. // create client ssl client_meth = (SSL_METHOD*)SSLv3_client_method(); client_ctx = SSL_CTX_new (client_meth); if (!client_ctx) goto cleanup; server_meth = (SSL_METHOD*)SSLv3_server_method(); server_ctx = SSL_CTX_new (server_meth); if (!server_ctx) goto cleanup; if ((cert=BIO_new(BIO_s_mem())) == NULL) { TINYCLR_SSL_PRINTF("Unable to create new BIO"); goto cleanup; } BIO_puts(cert,server_pem); x=PEM_read_bio_X509_AUX(cert, NULL, 0, NULL); pkey=PEM_read_bio_PrivateKey(cert,NULL, server_ctx->default_passwd_callback,server_ctx->default_passwd_callback_userdata); //if (SSL_CTX_use_certificate_file(server_ctx, CERTF, SSL_FILETYPE_PEM) <= 0) { if (SSL_CTX_use_certificate(server_ctx, x) <= 0) { TINYCLR_SSL_PRINTF("Use certifcate chain file failed"); goto cleanup; } if (SSL_CTX_use_PrivateKey(server_ctx, pkey) <= 0) { TINYCLR_SSL_PRINTF("Unable to use Private Key"); goto cleanup; } if (!SSL_CTX_check_private_key(server_ctx)) { TINYCLR_SSL_PRINTF("Private key does not match the certificate public key\n"); goto cleanup; } //if (SSL_CTX_set_cipher_list(server_ctx, ); // ----------------------------------------------- // Prepare TCP socket for receiving connections listen_sd = TINYCLR_SSL_SOCKET (AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listen_sd < 0) goto cleanup; // set it to non-blocking int nonblock = 1; err = TINYCLR_SSL_IOCTL(listen_sd,SOCK_FIONBIO,&nonblock); if (err < 0) { int wsa = TINYCLR_SSL_GETLASTSOCKETERROR(); TINYCLR_SSL_PRINTF("Nonblocking call failed for server: %d.\n", wsa); goto cleanup; } TINYCLR_SSL_MEMSET(&sa_serv, '\0', sizeof(sa_serv)); sa_serv.sin_family = AF_INET; sa_serv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); sa_serv.sin_port = TINYCLR_SSL_HTONS (1111); /* Server Port number */ TINYCLR_SSL_PRINTF("Binding to %d...\n", TINYCLR_SSL_NTOHS(sa_serv.sin_port)); err = TINYCLR_SSL_BIND(listen_sd, (struct TINYCLR_SSL_SOCKADDR*) &sa_serv, sizeof (sa_serv)); if (err < 0) { int wsa = TINYCLR_SSL_GETLASTSOCKETERROR(); TINYCLR_SSL_PRINTF("Bind Socket error %d\n", wsa); goto cleanup; } TINYCLR_SSL_PRINTF("Listening...\n"); /* Receive a TCP connection. */ err = TINYCLR_SSL_LISTEN (listen_sd, 5); if (err < 0) { int wsa = TINYCLR_SSL_GETLASTSOCKETERROR(); TINYCLR_SSL_PRINTF("Listen Socket error %d\n", wsa); goto cleanup; } // create a client socket client_sd = TINYCLR_SSL_SOCKET (AF_INET, SOCK_STREAM, IPPROTO_TCP); if (client_sd < 0) goto cleanup; // set it to non-blocking err = TINYCLR_SSL_IOCTL(client_sd,SOCK_FIONBIO,&nonblock); if (err < 0) { int wsa = TINYCLR_SSL_GETLASTSOCKETERROR(); TINYCLR_SSL_PRINTF("Nonblocking call failed for client: %d.\n", wsa); goto cleanup; } // Set up a tcp connection for client: Bind, Connect err == TINYCLR_SSL_CONNECT( client_sd, (const struct TINYCLR_SSL_SOCKADDR*)&sa_serv, sizeof(sa_serv)); if (err < 0) { int wsa = TINYCLR_SSL_GETLASTSOCKETERROR(); TINYCLR_SSL_PRINTF("Client connect failed with: %d.\n", wsa); } client_len = sizeof(sa_cli); char nodename[128] = ""; char servname[128] = ""; SOCK_addrinfo hints; SOCK_addrinfo *res = NULL; TINYCLR_SSL_MEMSET(&hints, '\0', sizeof(hints)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; SOCK_getaddrinfo(nodename,servname,&hints,&res); SOCK_addrinfo *ptr = NULL; for (ptr=res; ptr!=NULL; ptr=ptr->ai_next) { struct sockaddr_in *ip = (struct sockaddr_in*) ptr->ai_addr; TINYCLR_SSL_PRINTF("Accepting connections on...%s:%d\n", inet_ntoa(ip->sin_addr), 1111 ); } int counter=0; do { server_sd = TINYCLR_SSL_ACCEPT (listen_sd, (struct TINYCLR_SSL_SOCKADDR*) &sa_cli, (int*)&client_len); Events_WaitForEvents(0,2000); TINYCLR_SSL_PRINTF("Accept again %d:%d\n", TINYCLR_SSL_GETLASTSOCKETERROR(), counter++); } while (server_sd == -1); TINYCLR_SSL_CLOSESOCKET (listen_sd); TINYCLR_SSL_PRINTF ("Connection from %lx, port %x\n", sa_cli.sin_addr.S_un.S_addr, sa_cli.sin_port); // connections are completed between server & client // now lets do the SSL negotiations // create server ssl server_ssl = SSL_new(server_ctx); if (server_ssl == NULL) goto cleanup; SSL_set_fd (server_ssl, server_sd); //Create server bio and set as non-blocking BIO* server_bio = BIO_new(BIO_s_socket()); if (server_bio == NULL) goto cleanup; //CHK_NULL(bio); BIO_set_nbio(server_bio,1); BIO_set_fd(server_bio, server_sd, BIO_NOCLOSE); SSL_set_bio(server_ssl,server_bio,server_bio); // create client ssl & connect client_ssl = SSL_new(client_ctx); if (client_ssl == NULL) goto cleanup; SSL_set_fd(client_ssl, client_sd); //Create client bio and set as non-blocking BIO* client_bio = BIO_new(BIO_s_socket()); if (client_bio == NULL) goto cleanup; BIO_set_nbio(client_bio,1); BIO_set_fd(client_bio, client_sd, BIO_NOCLOSE); SSL_set_bio(client_ssl,client_bio,client_bio); // loop until server accepts ssl client connect int ssl_err =0; do { err = SSL_connect(client_ssl); if (err <= 0) { ssl_err = SSL_get_error(client_ssl,err); TINYCLR_SSL_PRINTF("SSL_Connect error: %d\n", ssl_err); } Events_WaitForEvents(0,1000); err = SSL_accept (server_ssl); if (err <= 0) { ssl_err = SSL_get_error(server_ssl, err); TINYCLR_SSL_PRINTF("SSL_Accept error: %d\n", ssl_err); } Events_WaitForEvents(0,1000); } while (err != 1); //Get the cipher - opt TINYCLR_SSL_PRINTF("SSL connection using %s\n", SSL_get_cipher (server_ssl)); //Get client's certificate (note: beware of dynamic allocation) - opt client_cert = SSL_get_peer_certificate (server_ssl); if (client_cert != NULL) { TINYCLR_SSL_PRINTF("Client certificate:\n"); str = X509_NAME_oneline (X509_get_subject_name (client_cert), 0, 0); if (str == NULL) goto cleanup; TINYCLR_SSL_PRINTF("subject: %s\n", str); OPENSSL_free (str); str = X509_NAME_oneline (X509_get_issuer_name (client_cert), 0, 0); if (str == NULL) goto cleanup; TINYCLR_SSL_PRINTF("issuer: %s\n", str); OPENSSL_free (str); //We could do all sorts of certificate verification stuff here before // deallocating the certificate. X509_free (client_cert); } else TINYCLR_SSL_PRINTF("Client does not have certificate.\n"); //Get server's certificate (note: beware of dynamic allocation) - opt server_cert = SSL_get_peer_certificate (client_ssl); if (server_cert != NULL) { TINYCLR_SSL_PRINTF("Server certificate:\n"); str = X509_NAME_oneline (X509_get_subject_name (server_cert), 0, 0); if (str == NULL) goto cleanup; TINYCLR_SSL_PRINTF("subject: %s\n", str); OPENSSL_free (str); str = X509_NAME_oneline (X509_get_issuer_name (server_cert), 0, 0); if (str == NULL) goto cleanup; TINYCLR_SSL_PRINTF("issuer: %s\n", str); OPENSSL_free (str); /* We could do all sorts of certificate verification stuff here before deallocating the certificate. */ X509_free (server_cert); } else TINYCLR_SSL_PRINTF("Server with no certificate?!?!?.\n"); do { // DATA EXCHANGE - Receive message and send reply. err = SSL_write(client_ssl,"Hello World!",TINYCLR_SSL_STRLEN("Hello World!")); if (err <= 0) ssl_err = SSL_get_error(client_ssl, err); Events_WaitForEvents(0,1000); server_numbytes= SSL_read (server_ssl, server_buf, sizeof(server_buf) - 1); if (server_numbytes <= 0) ssl_err = SSL_get_error(server_ssl, server_numbytes); else server_buf[server_numbytes] = '\0'; Events_WaitForEvents(0,1000); err = SSL_write (server_ssl, "I hear you.", TINYCLR_SSL_STRLEN("I hear you.")); if (err <= 0) ssl_err = SSL_get_error(server_ssl, err); Events_WaitForEvents(0,1000); client_numbytes= SSL_read(client_ssl, client_buf, sizeof(client_buf) -1); if (client_numbytes <= 0) ssl_err = SSL_get_error(client_ssl, client_numbytes); else client_buf[client_numbytes] = '\0'; Events_WaitForEvents(0,1000); } while (err <= 0); TINYCLR_SSL_PRINTF("Server got %d chars:'%s'\n", server_numbytes, server_buf); TINYCLR_SSL_PRINTF("Client go %d chars:'%s'\n", client_numbytes, client_buf); /* Clean up. */ cleanup: if (pkey) EVP_PKEY_free(pkey); if (cert) BIO_free(cert); if (x) X509_free(x); TINYCLR_SSL_CLOSESOCKET(server_sd); if (server_ssl) SSL_shutdown(server_ssl); if (server_ssl) SSL_free (server_ssl); server_ssl = NULL; if (server_ctx) SSL_CTX_free(server_ctx); server_ctx = NULL; TINYCLR_SSL_CLOSESOCKET(client_sd); if (client_ssl) SSL_shutdown(client_ssl); if (client_ssl) SSL_free (client_ssl); client_ssl = NULL; if (client_ctx) SSL_CTX_free(client_ctx); client_ctx = NULL; }
u32_t sys_arch_mbox_fetch(sys_mbox_t* mbox, void **msg, u32_t timeout) { if(mbox == NULL || *mbox == NULL) { ASSERT(FALSE); return SYS_ARCH_TIMEOUT; } Hal_Queue_UnknownSize<OpaqueQueueNode>* queue = (Hal_Queue_UnknownSize<OpaqueQueueNode>*)*mbox; bool didTimeout = false; if(timeout == 0) { timeout = 0xFFFFFFFF; } INT64 now = ::HAL_Time_CurrentTime(); INT64 elapsed = now + (timeout * 10000); while(elapsed > ::HAL_Time_CurrentTime() || timeout == 1) { OpaqueQueueNode* node = queue->Pop(); if(node) { *msg = node->payload; Events_Set(SYSTEM_EVENT_FLAG_NETWORK); SOCKETS_RestartTcpIpProcessor(0); return 0; } else if(timeout == 1) { break; } if(INTERRUPTS_ENABLED_STATE()) { if(Events_WaitForEvents(SYSTEM_EVENT_FLAG_NETWORK, timeout)) { Events_Clear(SYSTEM_EVENT_FLAG_NETWORK); INT64 curTime = ::HAL_Time_CurrentTime(); if(elapsed > curTime) { timeout -= (elapsed - HAL_Time_CurrentTime()) / 10000; } } else { break; } } else { break; } } if(timeout != 1) { Events_Set(SYSTEM_EVENT_FLAG_NETWORK); } else { didTimeout = true; } *msg = NULL; return didTimeout ? SYS_ARCH_TIMEOUT : SYS_MBOX_EMPTY; }
void ApplicationEntryPoint() { #if defined(TEST_DAC) UINT32 FramesNum = g_LPC24XX_DAC_Driver.GetBufferFrameCapacity(); if (DAC_FRAME_BUFFERS_NUM!=FramesNum) { debug_printf( "Error, BufferFrameCapacity != DAC_FRAME_BUFFERS_NUM: %d != %d.\r\n", FramesNum, DAC_FRAME_BUFFERS_NUM ); } UINT32 nextInFrameOffset=0; UINT16 frameLength = MAX_DECODED_FRAME_SIZE/2; short* frameSignedStart = NULL; LPC24XX_VIC& VIC = LPC24XX::VIC(); /*debug_printf("VIC INTRSEL = 0x%08x\r\n", VIC.INTRSEL); VIC.INTRSEL |= 1 << LPC24XX_TIMER::getIntNo(LPC24XX_DAC::Timer); debug_printf("new VIC INTRSEL = 0x%08x\r\n", VIC.INTRSEL);*/ VIC.VECTPRIORITY[LPC24XX_TIMER::getIntNo(LPC24XX_DAC::Timer)] = 0; for(int i= 0; i< 32; i++) { debug_printf("PRIO INTR%02d = %d \r\n", i,VIC.VECTPRIORITY[i]); } debug_printf( "Init DAC, 8kHz output.\r\n" ); g_LPC24XX_DAC_Driver.Initialize(OUT_FREQ); debug_printf( "BUFFER PRE-FILL TEST.\r\n" ); debug_printf( "Adding frames to the DAC driver buffer: " ); debug_printf("total frames to be added = %d\r\n", TEST_SAMPLES_NUM/MAX_DECODED_FRAME_SIZE-CUTOUT); debug_printf("DAC frame buffers available = %d\r\n", DAC_FRAME_BUFFERS_NUM); if(DAC_FRAME_BUFFERS_NUM<(TEST_SAMPLES_NUM/MAX_DECODED_FRAME_SIZE-CUTOUT)) debug_printf("ONLY THE FIRST %d FRAMES OF THE SAMPLE WILL BE PLAYED.\r\n", DAC_FRAME_BUFFERS_NUM); while(nextInFrameOffset+(MAX_DECODED_FRAME_SIZE*CUTOUT) < TEST_SAMPLES_NUM) { //if(i%(1024*256)) continue; frameSignedStart = (short*)(bin_data+nextInFrameOffset); if(g_LPC24XX_DAC_Driver.AddFrame(frameSignedStart, frameLength)) { debug_printf( " done.\r\n" ); nextInFrameOffset+=MAX_DECODED_FRAME_SIZE; } else { debug_printf( "Buffer full, starting playout.\r\n"); break; } } resetDACISRTiming(); debug_printf( "DAC.On() in 2 seconds\r\n"); Events_WaitForEvents( 0, 2000 ); if(!hijackISRs()) return; if(g_LPC24XX_DAC_Driver.On()) { //debug_printf( "Done. 2sec wait.\r\n" ); don't output to avoid adding serial activity during the test } else { debug_printf( "FAILED.\r\n" ); } while(g_LPC24XX_DAC_Driver.GetBufferLevel()>0) { //debug_printf("Samples left: %d\r\n", g_LPC24XX_DAC_Driver.GetBufferLevel()); //debug_printf("Frames left: %d\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft()); } //stop logging interrupts before starting to output again int finalIrqCount = irq_count; irq_count = 8192; Events_WaitForEvents( 0, 5000 ); if(!restoreISRs()) return; debug_printf("%d frames left.\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft()); debug_printf("Final IRQ count = %u\r\n", finalIrqCount); debug_printf( "BUFFER PRE-FILL TEST OVER.\r\n"); displayRunTestResults(); debug_printf("CSV DATA OUTPUT FOLLOWS\r\n"); //csvRunTestResults(); debug_printf("\r\nPARALLEL BUFFER FILL TEST\r\n" ); Events_WaitForEvents( 0, 3000 ); debug_printf( "DAC.Off()\r\n"); if(g_LPC24XX_DAC_Driver.Off()) { debug_printf( "Done.\r\n" ); } else { debug_printf( "FAILED.\r\n" ); } debug_printf( "Uninit DAC\r\n"); g_LPC24XX_DAC_Driver.Uninitialize(); debug_printf( "Done.\r\n"); debug_printf( "Init DAC, 8kHz output.\r\n" ); g_LPC24XX_DAC_Driver.Initialize(OUT_FREQ); resetDACISRTiming(); debug_printf( "DAC.On() in 2 seconds\r\n"); Events_WaitForEvents( 0, 2000 ); if(g_LPC24XX_DAC_Driver.On()) { //debug_printf( "Done.\r\n" ); } else { debug_printf( "FAILED.\r\n" ); } debug_printf( "Adding frames to the DAC driver buffer: " ); nextInFrameOffset=0; debug_printf("total frames to be added = %d\r\n", TEST_SAMPLES_NUM/MAX_DECODED_FRAME_SIZE-CUTOUT); //FILL JUST ONCE while(nextInFrameOffset+(MAX_DECODED_FRAME_SIZE*CUTOUT) < TEST_SAMPLES_NUM) { //if(i%(1024*256)) continue; frameSignedStart = (short*)(bin_data+nextInFrameOffset); if(g_LPC24XX_DAC_Driver.AddFrame(frameSignedStart, frameLength)) { debug_printf( " done.\r\n" ); nextInFrameOffset+=MAX_DECODED_FRAME_SIZE; } else { //debug_printf( "FAIL.\r\n"); } } while(g_LPC24XX_DAC_Driver.GetBufferLevel()>0) { //debug_printf("Samples left: %d\r\n", g_LPC24XX_DAC_Driver.GetBufferLevel()); //debug_printf("Frames left: %d\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft()); } Events_WaitForEvents( 0, 3000 ); displayRunTestResults(); debug_printf("CSV DATA OUTPUT FOLLOWS\r\n"); csvRunTestResults(); /*CONTINUOUS REFILL with samples while(true) { //if(i%(1024*256)) continue; frameSignedStart = (short*)(bin_data+nextInFrameOffset); if(g_LPC24XX_DAC_Driver.AddFrame(frameSignedStart, frameLength)) { //debug_printf( " done.\r\n" ); nextInFrameOffset+=MAX_DECODED_FRAME_SIZE; if(nextInFrameOffset+(MAX_DECODED_FRAME_SIZE*CUTOUT)>=TEST_SAMPLES_NUM) nextInFrameOffset = 0; } else { //debug_printf( "FAIL.\r\n"); } debug_printf("Samples left: %d\r\n", g_LPC24XX_DAC_Driver.GetBufferLevel()); debug_printf("Frames left: %d\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft()); }*///end continuous refill debug_printf("%d frames left.\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft()); debug_printf( "PARALLEL BUFFER FILL TEST OVER.\r\n\r\n" ); //Events_WaitForEvents( 0, 10000 ); debug_printf( "DAC.Off()\r\n"); if(g_LPC24XX_DAC_Driver.Off()) { debug_printf( "Done.\r\n" ); } else { debug_printf( "FAILED.\r\n" ); } debug_printf( "Uninit DAC()\r\n"); g_LPC24XX_DAC_Driver.Uninitialize(); debug_printf( "Done.\r\n"); #endif #if defined(TEST_JOYSTICK) extern LPC24XX_GPIO_Driver g_LPC24XX_GPIO_Driver; wait_joystick = true; for(UINT32 pin = LPC24XX_GPIO::c_P2_22; pin < LPC24XX_GPIO::c_P2_28; pin++) { if(pin == LPC24XX_GPIO::c_P2_24) continue; if(!g_LPC24XX_GPIO_Driver.EnableInputPin( pin, false, joystickISR, NULL, GPIO_INT_EDGE_HIGH, (GPIO_RESISTOR)2 )) { debug_printf("Cannot enable pin %u as INPUT pin.\r\n", pin); exit(1); } debug_printf("Enabled pin %u as INPUT pin.\r\n", pin); } while(wait_joystick) {}; #endif #if defined(TEST_SST39WF) while(1) { lcd_printf ( "Hello, world from the LCD!\r\n" ); hal_printf ( "Hello, world from the HAL!\r\n" ); debug_printf( "Hello, world from the debug intf!\r\n" ); if(BlockStorageList::GetNumDevices() != 1) { debug_printf( "%d Block Devices present!\r\n", BlockStorageList::GetNumDevices() ); break; } BlockStorageDevice* SST = BlockStorageList::GetFirstDevice(); if(SST == NULL) { debug_printf( "GetFirstDevice failed.\r\n" ); break; } const BlockDeviceInfo* SSTInfo = SST->GetDeviceInfo(); if(SSTInfo == NULL) { debug_printf( "GetDeviceInfo failed.\r\n" ); break; } debug_printf( "NumRegions in BSDevice: %d\r\n", SSTInfo->NumRegions); ByteAddress PhyAddress = (ByteAddress) 0xC0FFEEEE; SectorAddress SectAddress = 0xC0FFEEEE; UINT32 RangeIndex; UINT32 RegionIndex; const BlockRegionInfo *pBlockRegionInfo; SST->FindForBlockUsage( /*UINT32*/ BlockRange::BLOCKTYPE_DEPLOYMENT , PhyAddress , RegionIndex, RangeIndex ); if(PhyAddress == 0xC0FFEEEE) { debug_printf( "FindForBlockUsage failed.\r\n" ); break; } debug_printf( "Sector 0x%08x physical address: 0x%08x\r\n", SectAddress, PhyAddress); BYTE pSectorBuf[] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF}; //ERASE before writing! if(!SST->IsBlockErased(PhyAddress, 0x1000)) { debug_printf( "Erasing block " ); if(!SST->EraseBlock(SectAddress)) { debug_printf( "failed.\r\n" ); break; } debug_printf( "successful.\r\n" ); } if(SST->Write(/*UINT32*/ PhyAddress, /*UINT32 NumOfBytes*/ 16, /*BYTE* */ pSectorBuf, /*SectorMetadata* */ FALSE)) debug_printf( "Correctly written 16 bytes to Sector 0x%08x\r\n", SectAddress); Events_WaitForEvents( 0, 2000 ); } #endif //TEST_SST39WF #if defined(TEST_PWM) PWM_Initialize(PWM_CHANNEL_0); // NOTE: on the EA_LPC2478 board the first pin we will return is the 11th pin on the left side from the top of the J1 connector GPIO_PIN pin = PWM_GetPinForChannel( PWM_CHANNEL_0 ); // from 90% to 2/3, to 50%, to 1/3 to 10% float dc[5] = { 0.9, 0.666, 0.5, 0.333, 0.1 }; UINT32 period1 = 1000; // 1Kxz for(UINT32 idx = 0; idx < 5; ++idx) { UINT32 duration1 = (UINT32)((float)period1 * dc[idx]); PWM_ApplyConfiguration( PWM_CHANNEL_0, pin, period1, duration1, FALSE); PWM_Start ( PWM_CHANNEL_0, pin ); // 2 secs, then change HAL_Time_Sleep_MicroSeconds_InterruptEnabled(1 * 1000 * 1000); //Events_WaitForEvents( 0, 2 * 1000); PWM_Stop ( PWM_CHANNEL_0, pin ); } // from 10Khz to 1Khz, 50% duty cycle for(UINT32 period = 10000; period >= 1000; period -= 1000) { UINT32 duration = period / 2; PWM_ApplyConfiguration( PWM_CHANNEL_0, pin, period, duration, FALSE); PWM_Start ( PWM_CHANNEL_0, pin ); // 2 secs, then change HAL_Time_Sleep_MicroSeconds_InterruptEnabled(1 * 1000 * 1000); //Events_WaitForEvents( 0, 2 * 1000); PWM_Stop ( PWM_CHANNEL_0, pin ); } PWM_Uninitialize(PWM_CHANNEL_0); #endif // TEST_PWM while(1) { lcd_printf ( "Hello, world!\r\n" ); hal_printf ( "Hello, world!\r\n" ); debug_printf( "Hello, world!\r\n" ); Events_WaitForEvents( 0, 1000 ); } }