void main() { TD_Init(); while (1) // Begin infinite loop { const long int DELAY = 10000; OUTA = 0x00; //OUTB = 0x00; //OUTC = 0x00; delay(DELAY); OUTA = 0xff; // Set all portA to on //OUTB = 0xff; //OUTC = 0xff; delay(DELAY); SBUF0 = 'a'; }// END }
void main() { TD_Init(); while (1) { const long int DELAY = 10000; OUTA = 0x00; //OUTB = 0x00; //OUTC = 0x00; delay(DELAY); OUTA = 0xff; //OUTB = 0xff; //OUTC = 0xff; delay(DELAY); } }
// Task dispatcher void main(void) { // Initialize Global States // Sleep = FALSE; // Disable sleep mode Rwuen = FALSE; // Disable remote wakeup Selfpwr = FALSE; // Disable self powered GotSUD = FALSE; // Clear "Got setup data" flag // Initialize user device TD_Init(); EA=0; pDeviceDscr = (WORD)&DeviceDscr; pDeviceQualDscr = (WORD)&DeviceQualDscr; pHighSpeedConfigDscr = (WORD)&HighSpeedConfigDscr; pFullSpeedConfigDscr = (WORD)&FullSpeedConfigDscr; pStringDscr = (WORD)&StringDscr; EZUSB_IRQ_ENABLE(); // Enable USB interrupt (INT2) // EZUSB_ENABLE_RSMIRQ(); // Wake-up interrupt INTSETUP |= (bmAV2EN | bmAV4EN); // Enable INT 2 & 4 autovectoring //USBIE |= bmSUDAV | bmSUTOK | bmSUSP | bmURES | bmHSGRANT; // Enable selected interrupts USBIE |= bmSUDAV | bmSUTOK | bmURES | bmHSGRANT; // Enable selected interrupts EA = 1; // Enable 8051 interrupts #ifndef NO_RENUM // Renumerate if necessary. Do this by checking the renum bit. If it // is already set, there is no need to renumerate. The renum bit will // already be set if this firmware was loaded from an eeprom. if(!(USBCS & bmRENUM)) { EZUSB_Discon(TRUE); // renumerate } #endif // unconditionally re-connect. If we loaded from eeprom we are // disconnected and need to connect. If we just renumerated this // is not necessary but doesn't hurt anything USBCS &=~bmDISCON; CKCON = (CKCON&(~bmSTRETCH)) | FW_STRETCH_VALUE; // Set stretch // clear the Sleep flag. // Sleep = FALSE; //download the serial number from the EEPROM //EZUSB_InitI2C(); // already done in TD_init which was called above downloadSerialNumberFromEEPROM(); // Task Dispatcher while(TRUE) // Main Loop { // Poll User Device TD_Poll(); // Check for pending SETUP if(GotSUD) { SetupCommand(); // Implement setup command GotSUD = FALSE; // Clear SETUP flag } // check for and handle suspend. // NOTE: Idle mode stops the processor clock. There are only two // ways out of idle mode, the WAKEUP pin, and detection of the USB // resume state on the USB bus. The timers will stop and the // processor will not wake up on any other interrupts. if (Sleep) // the device doesn't start if this is checked { if(TD_Suspend()) { Sleep = FALSE; // Clear the "go to sleep" flag. Do it here to prevent any race condition between wakeup and the next sleep. do { EZUSB_Susp(); // Place processor in idle mode. } while(!Rwuen && EZUSB_EXTWAKEUP()); // above. Must continue to go back into suspend if the host has disabled remote wakeup // *and* the wakeup was caused by the external wakeup pin. // 8051 activity will resume here due to USB bus or Wakeup# pin activity. EZUSB_Resume(); // If source is the Wakeup# pin, signal the host to Resume. TD_Resume(); } } } }
// Task dispatcher void main(void) { DWORD i; WORD offset; DWORD DevDescrLen; DWORD j=0; WORD IntDescrAddr; WORD ExtDescrAddr; DWORD tCount=0; // Initialize Global States Sleep = FALSE; // Disable sleep mode Rwuen = FALSE; // Disable remote wakeup Selfpwr = FALSE; // Disable self powered GotSUD = FALSE; // Clear "Got setup data" flag // Initialize user device TD_Init(); //JTAG Enable and SYNC signals for ZTEX Spartan 6 module 1.1 (FGPA+FX2LP setup) OEA|=0x02; //Declare PA.1 as output SYNCDELAY; IOA|=0x02; //output 1 on PA.1 SYNCDELAY; OEC|=0x01; //PC.0 as output (SYNC signal) SYNCDELAY; IOC|=0x00; //output 0 on PC.0...SYNC signal is LOW SYNCDELAY; OEC&=0xFD; //PC.1 as input (Clock changing signal) SYNCDELAY; // The following section of code is used to relocate the descriptor table. // Since the SUDPTRH and SUDPTRL are assigned the address of the descriptor // table, the descriptor table must be located in on-part memory. // The 4K demo tools locate all code sections in external memory. // The descriptor table is relocated by the frameworks ONLY if it is found // to be located in external memory. pDeviceDscr = (WORD)&DeviceDscr; pDeviceQualDscr = (WORD)&DeviceQualDscr; pHighSpeedConfigDscr = (WORD)&HighSpeedConfigDscr; pFullSpeedConfigDscr = (WORD)&FullSpeedConfigDscr; pStringDscr = (WORD)&StringDscr; if (EZUSB_HIGHSPEED()) { pConfigDscr = pHighSpeedConfigDscr; pOtherConfigDscr = pFullSpeedConfigDscr; } else { pConfigDscr = pFullSpeedConfigDscr; pOtherConfigDscr = pHighSpeedConfigDscr; } if ((WORD)&DeviceDscr & 0xe000) { IntDescrAddr = INTERNAL_DSCR_ADDR; ExtDescrAddr = (WORD)&DeviceDscr; DevDescrLen = (WORD)&UserDscr - (WORD)&DeviceDscr + 2; for (i = 0; i < DevDescrLen; i++) *((BYTE xdata *)IntDescrAddr+i) = 0xCD; for (i = 0; i < DevDescrLen; i++) *((BYTE xdata *)IntDescrAddr+i) = *((BYTE xdata *)ExtDescrAddr+i); pDeviceDscr = IntDescrAddr; offset = (WORD)&DeviceDscr - INTERNAL_DSCR_ADDR; pDeviceQualDscr -= offset; pConfigDscr -= offset; pOtherConfigDscr -= offset; pHighSpeedConfigDscr -= offset; pFullSpeedConfigDscr -= offset; pStringDscr -= offset; } EZUSB_IRQ_ENABLE(); // Enable USB interrupt (INT2) EZUSB_ENABLE_RSMIRQ(); // Wake-up interrupt INTSETUP |= (bmAV2EN | bmAV4EN); // Enable INT 2 & 4 autovectoring USBIE |= bmSUDAV | bmSUTOK | bmSUSP | bmURES | bmHSGRANT; // Enable selected interrupts EA = 1; // Enable 8051 interrupts #ifndef NO_RENUM // Renumerate if necessary. Do this by checking the renum bit. If it // is already set, there is no need to renumerate. The renum bit will // already be set if this firmware was loaded from an eeprom. if(!(USBCS & bmRENUM)) { EZUSB_Discon(TRUE); // renumerate } #endif // unconditionally re-connect. If we loaded from eeprom we are // disconnected and need to connect. If we just renumerated this // is not necessary but doesn't hurt anything USBCS &=~bmDISCON; CKCON = (CKCON&(~bmSTRETCH)) | FW_STRETCH_VALUE; // Set stretch to 0 (after renumeration) // clear the Sleep flag. Sleep = FALSE; // Task Dispatcher while(TRUE) // Main Loop { if(GotSUD) // Wait for SUDAV { SetupCommand(); // Implement setup command GotSUD = FALSE; // Clear SUDAV flag } // Poll User Device // NOTE: Idle mode stops the processor clock. There are only two // ways out of idle mode, the WAKEUP pin, and detection of the USB // resume state on the USB bus. The timers will stop and the // processor will not wake up on any other interrupts. if (Sleep) { if(TD_Suspend()) { Sleep = FALSE; // Clear the "go to sleep" flag. Do it here to prevent any race condition between wakeup and the next sleep. do { EZUSB_Susp(); // Place processor in idle mode. } while(!Rwuen && EZUSB_EXTWAKEUP()); // Must continue to go back into suspend if the host has disabled remote wakeup // *and* the wakeup was caused by the external wakeup pin. // 8051 activity will resume here due to USB bus or Wakeup# pin activity. EZUSB_Resume(); // If source is the Wakeup# pin, signal the host to Resume. TD_Resume(); } } TD_Poll(); } }
// Task dispatcher void main(void) { DWORD i; WORD offset; DWORD DevDescrLen; DWORD j=0; WORD IntDescrAddr; WORD ExtDescrAddr; // Initialize Global States Sleep = FALSE; // Disable sleep mode Rwuen = FALSE; // Disable remote wakeup Selfpwr = FALSE; // Disable self powered GotSUD = FALSE; // Clear "Got setup data" flag // Initialize user device TD_Init(); // The following section of code is used to relocate the descriptor table. // The frameworks uses SUDPTRH and SUDPTRL to automate the SETUP requests // for descriptors. These registers only work with memory locations // in the EZ-USB internal RAM. Therefore, if the descriptors are located // in external RAM, they must be copied to in internal RAM. // The descriptor table is relocated by the frameworks ONLY if it is found // to be located in external memory. pDeviceDscr = (WORD)&DeviceDscr; pDeviceQualDscr = (WORD)&DeviceQualDscr; pHighSpeedConfigDscr = (WORD)&HighSpeedConfigDscr; pFullSpeedConfigDscr = (WORD)&FullSpeedConfigDscr; pStringDscr = (WORD)&StringDscr; // Is the descriptor table in external RAM (> 16Kbytes)? If yes, // then relocate. // Note that this code only checks if the descriptors START in // external RAM. It will not work if the descriptor table spans // internal and external RAM. if ((WORD)&DeviceDscr & 0xC000) { // first, relocate the descriptors IntDescrAddr = INTERNAL_DSCR_ADDR; ExtDescrAddr = (WORD)&DeviceDscr; DevDescrLen = (WORD)&UserDscr - (WORD)&DeviceDscr + 2; for (i = 0; i < DevDescrLen; i++) *((BYTE xdata *)IntDescrAddr+i) = *((BYTE xdata *)ExtDescrAddr+i); // update all of the descriptor pointers pDeviceDscr = IntDescrAddr; offset = (WORD)&DeviceDscr - INTERNAL_DSCR_ADDR; pDeviceQualDscr -= offset; pConfigDscr -= offset; pOtherConfigDscr -= offset; pHighSpeedConfigDscr -= offset; pFullSpeedConfigDscr -= offset; pStringDscr -= offset; } EZUSB_IRQ_ENABLE(); // Enable USB interrupt (INT2) EZUSB_ENABLE_RSMIRQ(); // Wake-up interrupt INTSETUP |= (bmAV2EN | bmAV4EN); // Enable INT 2 & 4 autovectoring USBIE |= bmSUDAV | bmSUTOK | bmSUSP | bmURES | bmHSGRANT; // Enable selected interrupts EA = 1; // Enable 8051 interrupts #ifndef NO_RENUM // Renumerate if necessary. Do this by checking the renum bit. If it // is already set, there is no need to renumerate. The renum bit will // already be set if this firmware was loaded from an eeprom. if(!(USBCS & bmRENUM)) { EZUSB_Discon(TRUE); // renumerate } #endif // unconditionally re-connect. If we loaded from eeprom we are // disconnected and need to connect. If we just renumerated this // is not necessary but doesn't hurt anything USBCS &=~bmDISCON; CKCON = (CKCON&(~bmSTRETCH)) | FW_STRETCH_VALUE; // Set stretch // clear the Sleep flag. Sleep = FALSE; // Task Dispatcher while(TRUE) // Main Loop { // Poll User Device TD_Poll(); // Check for pending SETUP if(GotSUD) { SetupCommand(); // Implement setup command GotSUD = FALSE; // Clear SETUP flag } // check for and handle suspend. // NOTE: Idle mode stops the processor clock. There are only two // ways out of idle mode, the WAKEUP pin, and detection of the USB // resume state on the USB bus. The timers will stop and the // processor will not wake up on any other interrupts. if (Sleep) { if(TD_Suspend()) { Sleep = FALSE; // Clear the "go to sleep" flag. Do it here to prevent any race condition between wakeup and the next sleep. do { EZUSB_Susp(); // Place processor in idle mode. } while(!Rwuen && EZUSB_EXTWAKEUP()); // above. Must continue to go back into suspend if the host has disabled remote wakeup // *and* the wakeup was caused by the external wakeup pin. // 8051 activity will resume here due to USB bus or Wakeup# pin activity. EZUSB_Resume(); // If source is the Wakeup# pin, signal the host to Resume. TD_Resume(); } } } }
// Task dispatcher void main(void) { DWORD i; WORD offset; DWORD DevDescrLen; DWORD j=0; WORD IntDescrAddr; WORD ExtDescrAddr; // Initialize Global States Sleep = FALSE; // Disable sleep mode Rwuen = FALSE; // Disable remote wakeup Selfpwr = FALSE; // Disable self powered GotSUD = FALSE; // Clear "Got setup data" flag // The following section of code is used to relocate the descriptor table. // Since the SUDPTRH and SUDPTRL are assigned the address of the descriptor // table, the descriptor table must be located in on-part memory. // The 4K demo tools locate all code sections in external memory. // The descriptor table is relocated by the frameworks ONLY if it is found // to be located in external memory. pDeviceDscr = (WORD)&DeviceDscr; pDeviceQualDscr = (WORD)&DeviceQualDscr; pHighSpeedConfigDscr = (WORD)&HighSpeedConfigDscr; pFullSpeedConfigDscr = (WORD)&FullSpeedConfigDscr; pStringDscr = (WORD)&StringDscr; if (EZUSB_HIGHSPEED()) { pConfigDscr = pHighSpeedConfigDscr; pOtherConfigDscr = pFullSpeedConfigDscr; } else { pConfigDscr = pFullSpeedConfigDscr; pOtherConfigDscr = pHighSpeedConfigDscr; } if ((WORD)&DeviceDscr & 0xe000) { IntDescrAddr = INTERNAL_DSCR_ADDR; ExtDescrAddr = (WORD)&DeviceDscr; DevDescrLen = (WORD)&UserDscr - (WORD)&DeviceDscr + 2; for (i = 0; i < DevDescrLen; i++) *((BYTE xdata *)IntDescrAddr+i) = 0xCD; for (i = 0; i < DevDescrLen; i++) *((BYTE xdata *)IntDescrAddr+i) = *((BYTE xdata *)ExtDescrAddr+i); pDeviceDscr = IntDescrAddr; offset = (WORD)&DeviceDscr - INTERNAL_DSCR_ADDR; pDeviceQualDscr -= offset; pConfigDscr -= offset; pOtherConfigDscr -= offset; pHighSpeedConfigDscr -= offset; pFullSpeedConfigDscr -= offset; pStringDscr -= offset; } EZUSB_IRQ_ENABLE(); // Enable USB interrupt (INT2) EZUSB_ENABLE_RSMIRQ(); // Wake-up interrupt INTSETUP |= (bmAV2EN | bmAV4EN); // Enable INT 2 & 4 autovectoring USBIE |= bmSUDAV | bmSUTOK | bmSUSP | bmURES | bmHSGRANT; // Enable selected interrupts EA = 1; // Enable 8051 interrupts #ifndef NO_RENUM // Note: at full speed, high speed hosts may take 5 sec to detect device EZUSB_Discon(TRUE); // Renumerate #endif CKCON = (CKCON&(~bmSTRETCH)) | FW_STRETCH_VALUE; // Set stretch to 0 (after renumeration) // clear the Sleep flag. Sleep = FALSE; // Initialize user device TD_Init(); // Task Dispatcher while(TRUE) // Main Loop { if(GotSUD) // Wait for SUDAV { SetupCommand(); // Implement setup command GotSUD = FALSE; // Clear SUDAV flag } else { TD_Poll(); } // Poll User Device // NOTE: Idle mode stops the processor clock. There are only two // ways out of idle mode, the WAKEUP pin, and detection of the USB // resume state on the USB bus. The timers will stop and the // processor will not wake up on any other interrupts. if (Sleep) { if(TD_Suspend()) { Sleep = FALSE; // Clear the "go to sleep" flag. Do it here to prevent any race condition between wakeup and the next sleep. do { EZUSB_Susp(); // Place processor in idle mode. } while(!Rwuen && EZUSB_EXTWAKEUP()); // Must continue to go back into suspend if the host has disabled remote wakeup // *and* the wakeup was caused by the external wakeup pin. // 8051 activity will resume here due to USB bus or Wakeup# pin activity. EZUSB_Resume(); // If source is the Wakeup# pin, signal the host to Resume. TD_Resume(); } } } }
/* ******************************************************************** */ void Check_Bootloader(void) { // reinit all chip TD_Init(); // just to allow send/receive from midi and usb inputs z8_board_fully_updated_from_ez0_bit = 1; // Init i2c bus for eeprom ez upgrade //EZUSB_InitI2C(); // update bootloading flags and state bootloader_state = SEND_IDENTITY_SYSEX; // First send the Bootloader identity sysex acknoledge to midi & usb out SendIdentityBootLoader(); must_program_z8 = FALSE; // The data firmware upgrade starts here bootloader_state = WAIT_EZ_FW_DATA; // Now Wait for the ez firmware data sysexs WaitNextBootLoaderState(bootloader_state); if(must_program_z8) { // Release Z8 board reset line Z8_RESET_PORT_OUT |= Z8_RESET_PIN; // wait por EZUSB_Delay(200); // disable rx1 SCON1 = 0x40; /* SCON1: mode 1, 8-bit UART, disable rcvr */ // tx1 is now dedicated to z8 dbg pin OCD_EN_PORT_OUT |= OCD_EN_PIN; // set z8 dbg pin low TX1_TO_Z8_DBG_PORT_OUT &= ~TX1_TO_Z8_DBG_PIN; // wait 2sec EZUSB_Delay(2000); // set z8 dbg pin high TX1_TO_Z8_DBG_PORT_OUT |= TX1_TO_Z8_DBG_PIN; // turn on tx1 and rx1 (serial to/from z8) PORTBCFG |= 0x0C; // send ocd first byte so the z8 autobaudrate the serial line Send_To_Serial_Z8(OCD_FIRST_BYTE); EZUSB_Delay1ms(); // place the z8 chip in ocd mode Send_To_Serial_Z8(OCD_WRITE_CTR_REG_CMD); Send_To_Serial_Z8(OCD_CTR_REG_DBGMODE); EZUSB_Delay(100); InitFlashFrqAndUnlock(); // selet flash page 0 WriteSingleRegOCD(OCD_FLASH_SELECT_PAGE, 0x00); // launch a mass erase WriteSingleRegOCD(OCD_FLASH_CTR_REG_ADD, OCD_FLASH_MASS_ERASE); EZUSB_Delay(Z8_ERASING_TIME); InitFlashFrqAndUnlock(); // Now Wait for the z8 firmware data sysexs WaitNextBootLoaderState(bootloader_state); EZUSB_Delay(50); // relock the flash controller WriteSingleRegOCD(OCD_FLASH_CTR_REG_ADD, OCD_FLASH_CTR_REG_RESET); /* ///////////////////// Z8 CRC CHECKS ///////////////////////////////// // V1.4 it is now time to verify Z8 programmed flash bootloader_state = VERIFY_Z8_CRC; // V1.4 Read the Z8 memory CRC and compare to calculated CRC Send_To_Serial_Z8(OCD_READ_FLASH_CRC); // V1.4 required time is 65536 * 1/(20MHz) EZUSB_Delay(50); // V1.4 the serial port should now have received the z8 internal CRC in buffer 0 to 3 // Send this CRC to host Serial_In_From_Z8.buffer[7] = Serial_In_From_Z8.buffer[0]; Serial_In_From_Z8.buffer[8] = Serial_In_From_Z8.buffer[1]; Serial_In_From_Z8.end_index = WID_SYX_HEADER_SIZE + 3 + 1; AssignWidSysexHeader(); // send ack firmware Serial_In_From_Z8.buffer[6] = FRAME_IS_FIRMWARE_OR_PURE_MIDI | sysex_direction_sysxid0 | prog_upload_sysxid0; // send eox Serial_In_From_Z8.buffer[9] = MIDI_EOX; SendDispatchFwSysex(); ///////////////////// END Z8 CRC CHECKS ///////////////////////////////// */ // exit z8 ocd mode OCD_EN_PORT_OUT &= ~OCD_EN_PIN; // exit z8 ocd mode Z8_RESET_PORT_OUT &= ~Z8_RESET_PIN; } // Now finish with a soft reset // SoftReset(); while(1) { Check_Usb(); Ep2out_Function(); } }
// Called once at startup // void mainInit(void) { __xdata uint8 thisByte = 0xFF; __xdata uint16 blockSize; // This is only necessary for cases where you want to load firmware into the RAM of an FX2 that // has already loaded firmware from an EEPROM. It should definitely be removed for firmwares // which are themselves to be loaded from EEPROM. #ifndef EEPROM RENUMERATE_UNCOND(); #endif // Needs to be matched to stuff in HDMI2USB/cypress/hdmi2usb.c TD_Init // void TD_Init(void) // Called once at startup // Clear wakeup (see AN15813: http://www.cypress.com/?docID=4633) WAKEUPCS = bmWU | bmDPEN | bmWUEN; WAKEUPCS = bmWU | bmDPEN | bmWUEN; // Disable alternate functions for PORTA 0,1,3 & 7. PORTACFG = 0x00; /* // Return FIFO settings back to default just in case previous firmware messed with them. SYNCDELAY; PINFLAGSAB = 0x00; SYNCDELAY; PINFLAGSCD = 0x00; SYNCDELAY; FIFOPINPOLAR = 0x00; // Global settings SYNCDELAY; REVCTL = (bmDYN_OUT | bmENH_PKT); // 0x03 SYNCDELAY; CPUCS = bmCLKSPD1; // 48MHz 0x10 // Drive IFCLK at 48MHz, enable slave FIFOs //SYNCDELAY; IFCONFIG = (bmIFCLKSRC | bm3048MHZ | bmIFCLKOE | bmFIFOS); SYNCDELAY; IFCONFIG = (bmIFCLKSRC | bm3048MHZ | bmIFCLKOE | bmPORTS); // 0xe0 // EP1OUT & EP1IN SYNCDELAY; EP1OUTCFG = (bmVALID | bmBULK); // 0xa0 SYNCDELAY; EP1INCFG = (bmVALID | bmBULK); // 0xa0 // EP2OUT & EP6IN are quad-buffered bulk endpoints SYNCDELAY; EP2CFG = (bmVALID | bmBULK); // 0xa0 SYNCDELAY; EP4CFG = 0x00; SYNCDELAY; EP6CFG = (bmVALID | bmBULK | bmDIR); // 0xe0 SYNCDELAY; EP8CFG = 0x00; // EP2OUT & EP6IN automatically commit packets SYNCDELAY; EP2FIFOCFG = bmAUTOOUT; // 0x10 SYNCDELAY; EP4FIFOCFG = 0x00; SYNCDELAY; EP6FIFOCFG = bmAUTOIN; // 0x08 SYNCDELAY; EP8FIFOCFG = 0x00; // Reset FIFOs for EP2OUT & EP6IN SYNCDELAY; FIFORESET = bmNAKALL; // 0x80 SYNCDELAY; FIFORESET = 2; // reset EP2OUT SYNCDELAY; FIFORESET = 6; // reset EP6IN SYNCDELAY; FIFORESET = 0x00; // Arm EP1OUT EP1OUTBC = 0x00; // Arm the EP2OUT buffers. Done four times because it's quad-buffered SYNCDELAY; OUTPKTEND = bmSKIP | 2; // EP2OUT 0x82 SYNCDELAY; OUTPKTEND = bmSKIP | 2; SYNCDELAY; OUTPKTEND = bmSKIP | 2; SYNCDELAY; OUTPKTEND = bmSKIP | 2; // Auto-commit 512-byte packets from EP6IN (master may commit early by asserting PKTEND) SYNCDELAY; EP6AUTOINLENH = 0x02; SYNCDELAY; EP6AUTOINLENL = 0x00; // Turbo I2C I2CTL |= bm400KHZ; // Auto-pointers AUTOPTRSETUP = bmAPTREN | bmAPTR1INC | bmAPTR2INC; // 0x07 // Port lines all inputs... IOA = 0xFF; OEA = 0x00; IOB = 0xFF; OEB = 0x00; IOC = 0xFF; OEC = 0x00; IOD = 0xFF; OED = 0x00; IOE = 0xFF; OEE = 0x00; #ifdef EEPROM #ifdef BSP #include STR(boards/BSP.c) #endif #endif */ I2CTL |= bm400KHZ; TD_Init(); #ifdef DEBUG usartInit(); { const uint8 *s = dev_strings; uint8 len; s = s + *s; len = (*s)/2 - 1; s += 2; while ( len ) { usartSendByte(*s); s += 2; len--; } usartSendByte(' '); len = (*s)/2 - 1; s += 2; while ( len ) { usartSendByte(*s); s += 2; len--; } usartSendByte('\r'); } #endif }
kal_bool BT_PcmLoopbackTest(void) { kal_int16 i, count = 0; kal_uint16 *buf; kal_uint32 len = 0, acmLen = 0; kal_int32 magDB = 0; TD_Handle hdl; kal_uint16 *rb_base; AM_BluetoothOn(2);//2:open earphone mode, 1: open cordless mode AM_FlushQFunction(); kal_prompt_trace(MOD_L1SP, "after set,DP_VOL_OUT_PCM= %d",*DP_VOL_OUT_PCM); /*initialize*/ rb_base = (kal_uint16 *)get_ctrl_buffer(BTLB_BUF_LEN << 1); Media_SetBuffer( rb_base, BTLB_BUF_LEN ); TD_Init( &hdl, TARGET_TONE, BLOCK_SIZE); #ifdef BTLB_DEBUG pcmDebugCnt = 0; pcmDebugPtr = btlbPcmDebugBuf; #endif /*start tone_play and record*/ KT_Play(TARGET_TONE, 0, 0); /*play single tone , continuous play*/ Media_Record(MEDIA_FORMAT_PCM_8K, BTLB_Handler, (void *)0); for (i = 0 ; i < 100 ; i++)/*if delay is large, we should enlarge this waiting*/ { Media_GetReadBuffer(&buf ,&len); if ( len==0 ) kal_sleep_task(1); else{ if ( (len + acmLen) >= BLOCK_SIZE ){/*acumulated length >= BLOCK_SIZE*/ len = BLOCK_SIZE - acmLen;/*recount samples to fit block*/ } TD_ProcessBlock(&hdl, (kal_int16 *)buf, len); #ifdef BTLB_DEBUG { int j; for(j = 0 ; j < len ; j++ ) if( pcmDebugCnt < 80000 ) { *pcmDebugPtr++ = buf[j]; pcmDebugCnt ++; } } #endif Media_ReadDataDone( len ); acmLen += len; if ( acmLen >= BLOCK_SIZE){ magDB = TD_GetMagnitudeDB( &hdl ); kal_prompt_trace( MOD_L1SP, "magDB = %d", magDB); if( magDB > BTLB_TONE_MAG_DB_THRESHOLD ) count ++; TD_Reset( &hdl ); acmLen=0;//reset if ( count > 2) break; } } } #ifdef BTLB_DEBUG { int file_handle; kal_prompt_trace(MOD_L1SP, "prepare to dump pcm file"); kal_wsprintf(debugFile, "d:\\BTLBdebug.pcm"); file_handle = FS_Open(debugFile, FS_CREATE); if(file_handle > 0) { FS_Write( file_handle, (void *)btlbPcmDebugBuf, pcmDebugCnt << 1, NULL ); FS_Close(file_handle); kal_prompt_trace(MOD_L1SP, "finish dump pcm file BTLBdebug.pcm"); } else{ kal_prompt_trace(MOD_L1SP, "unable to dump file"); } } #endif KT_StopAndWait(); Media_Stop(); AM_BluetoothOff();//close earphone mode /*close loopback path, should be removed in the future*/ //*AFE_VAC_CON1 &= ~0x02; free_ctrl_buffer( rb_base ); if ( count > 2){ return true; }else return false; }