void CreateFileCount()
{
BYTE i=0;
//fCreateNew=1;
FileCreated=0; //penanda file create baru, file sebelumnya diabaikan
while(i<10)
{
MyFileName[5]=i+0x30;
if(!FileSearch(MyFileName)) //jika nama file tidak ditemukan,
{
UartSendString("try new file : ");
UartSendString(MyFileName);
UartSendString("\n");
break;
}
i++;
}
if(i>9)return;
if(FileInit(MyFileName)==FIL_OK)
{
FileCreated=1;
}
//fCreateNew=0;
}
void acoral_fs_init(void)
{
DiskInit();
FileInit();
fs_mutex=acoral_mutex_create(0,NULL);
acoral_mount("disk","A:",NULL,0,NULL);
}
void PlatformInit() {
StdioInit();
ERRORassert();
TimerInit();
ERRORassert();
FileInit();
if (IsError) {
ERRORprint();
fprintf(stderr, "Error during FileInit, no File I/O\n");
}
}
//*****************************************************************************
//
// This is the callback from the MSC driver.
//
// \param ui32Instance is the driver instance which is needed when communicating
// with the driver.
// \param ui32Event is one of the events defined by the driver.
// \param pvData is a pointer to data passed into the initial call to register
// the callback.
//
// This function handles callback events from the MSC driver. The only events
// currently handled are the MSC_EVENT_OPEN and MSC_EVENT_CLOSE. This allows
// the main routine to know when an MSC device has been detected and
// enumerated and when an MSC device has been removed from the system.
//
// \return None
//
//*****************************************************************************
static void
MSCCallback(tUSBHMSCInstance *ps32Instance, uint32_t ui32Event, void *pvData)
{
//
// Determine the event.
//
switch(ui32Event)
{
//
// Called when the device driver has successfully enumerated an MSC
// device.
//
case MSC_EVENT_OPEN:
{
//
// Proceed to the enumeration state.
//
g_eState = STATE_DEVICE_ENUM;
break;
}
//
// Called when the device driver has been unloaded due to error or
// the device is no longer present.
//
case MSC_EVENT_CLOSE:
{
//
// Go back to the "no device" state and wait for a new connection.
//
g_eState = STATE_NO_DEVICE;
//
// Re-initialize the file system.
//
FileInit();
break;
}
default:
{
break;
}
}
}
//*****************************************************************************
//
// Initializes the USB stack for mass storage.
//
//*****************************************************************************
void
USBStickInit(void)
{
//
// Enable the uDMA controller and set up the control table base.
// The uDMA controller is used by the USB library.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
MAP_uDMAEnable();
MAP_uDMAControlBaseSet(g_psDMAControlTable);
//
// Initially wait for device connection.
//
g_iState = eSTATE_NO_DEVICE;
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open an instance of the mass storage class driver.
//
g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Run initial pass through USB host stack.
//
USBHCDMain();
//
// Initialize the file system.
//
FileInit();
}
int main() {
Init();
FileInit();
Order = -1;
//work
while (Order != 0) {
ReadInit();
switch (Order) {
case 1 : addstu(); break;
case 2 : addact(); break;
case 3 : qstu(); break;
case 4 : qact(); break;
case 5 : qc(); break;
case 0 : break;
default : printf("Unknown Order\n");break;
}
}
// free the memory
EndFree();
return 0;
}
extern void GUImain( void )
/*************************/
{
int argc = 0;
char **argv = NULL;
char *dir;
char *drive;
char *inf_name;
char *tmp_path;
char *arc_name;
char *new_inf;
char current_dir[_MAX_PATH];
bool ret = FALSE;
dlg_state state;
GUIMemOpen();
GUIGetArgs( &argv, &argc );
#if defined( __NT__ )
if( CheckWin95Uninstall( argc, argv ) ) return;
#endif
#ifdef __WINDOWS__
if( CheckForSetup32( argc, argv ) ) return;
#endif
// initialize paths and env. vbls.
if( !SetupPreInit() ) return;
if( !GetDirParams( argc, argv, &inf_name, &tmp_path, &arc_name ) ) return;
if( !SetupInit() ) return;
GUIDrainEvents(); // push things along
FileInit( arc_name );
InitGlobalVarList();
strcpy( current_dir, tmp_path );
while( InitInfo( inf_name, tmp_path ) ) {
ret = DoMainLoop( &state );
if( state == DLG_DONE ) break;
// if( CancelSetup == TRUE || !ret ) break;
if( CancelSetup == TRUE ) break;
// if( !ret ) break;
// look for another SETUP.INF
if( GetVariableByName( "SetupPath" ) == NO_VAR ) {
if( DirParamStack( &inf_name, &tmp_path, Stack_IsEmpty ) == FALSE ) { // "IsEmpty"?
DirParamStack( &inf_name, &tmp_path, Stack_Pop ); // "Pop"
CloseDownMessage( ret );
CancelSetup = FALSE;
ret = TRUE;
} else {
CloseDownMessage( ret );
break;
}
} else {
if( GetVariableIntVal( "IsMultiInstall" ) ) {
// push current script on stack
DirParamStack( &inf_name, &tmp_path, Stack_Push ); // "Push"
}
new_inf = GUIMemAlloc( _MAX_PATH );
drive = GUIMemAlloc( _MAX_DRIVE );
dir = GUIMemAlloc( _MAX_PATH );
if( new_inf == NULL || drive == NULL || dir == NULL ) {
GUIMemFree( new_inf );
GUIMemFree( drive );
GUIMemFree( dir );
break;
}
// construct new path relative to previous
ReplaceVars( new_inf, GetVariableStrVal( "SetupPath" ) );
_splitpath( current_dir, drive, dir, NULL, NULL );
_makepath( inf_name, drive, dir, new_inf, NULL );
_splitpath( inf_name, drive, dir, NULL, NULL );
_makepath( tmp_path, drive, dir, NULL, NULL );
// strcpy( current_dir, tmp_path );
GUIMemFree( new_inf );
GUIMemFree( drive );
GUIMemFree( dir );
} /* if */
FreeGlobalVarList( FALSE );
FreeDefaultDialogs();
FreeAllStructs();
ConfigModified = FALSE;
} /* while */
FileFini();
FreeGlobalVarList( TRUE );
FreeDefaultDialogs();
FreeAllStructs();
FreeDirParams( &inf_name, &tmp_path, &arc_name );
CloseDownProgram();
}
void main(void)
{
Int16 temp_cnt;
ICR = 0xff2e; /* IDLE Control Register */
/* mem port, io port and cpu idle active */
/* Peripheral_Reset */
CSL_SYSCTRL_REGS->PSRCR = 0x0020;
CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;
CSL_SYSCTRL_REGS->PRCR = 0x00bf;
/* VERY IMPORTANT !!! */
/* PPMODE1 (SPI, GPIO, UART, and I2S2):
7 signals of the SPI module,
6 GPIO signals(GP[17:12]),
4 signals of the UART module,
4 signals of the I2S2 module
SP1MODE2 (GP[11:6]). 6 GPIO signals (GP[11:6])
SP0MODE0 (MMC/SD0). All 6 signals of the MMC/SD0
*/
CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
|(CSL_SYS_EBSR_SP1MODE_MODE2 << 10)
|(CSL_SYS_EBSR_SP0MODE_MODE0 << 8);
asm(" bit(ST1, #ST1_INTM) = #1");
INTR_init();
PLL_init(3658); // system clock set to 120MHz
TIMER_init();
EZDSP5535_GPIO_init();
EZDSP5535_I2C_init(); /* Initialize I2C */
Audio_init(7); /* Initialise to bandwidth=7kHz */
EZDSP5535_LCD_init();
LCD_print("G722.1 Receiver ", 17, 0);
LCD_print("16kbps ", 8, 1);
EZDSP5535_SPI_init();
Si446x_Init();
EZDSP5535_SAR_init();
DiskInit();
FileInit();
AddFileDriver(SDCammand, NULL);
asm(" bit(ST1, #ST1_INTM) = #0");
bApi_Set_Receive();
while(1) {
if(gpioIsrStatus == 1) {
temp_cnt = SPI_recvData(spibuffer);
gpioIsrStatus = 0;
CSL_GPIO_REGS->IOINTFLG1 = 0x0800;
}
if(spiIsrStatus == 1) {
// SpiWriteByte(CMD_FIFO_INFO, 0);
SpiWriteByte(CMD_GET_INT_STATUS, 0);
bApi_Set_Receive();
if(audioProcessing()) continue;
spiIsrStatus = 0;
}
fileProcessing();
asm(" idle");
}
// RemoveFileDriver(SDCammand);
}
//*****************************************************************************
//
// The main application loop.
//
//*****************************************************************************
int
main(void)
{
int32_t i32Status, i32Idx;
uint32_t ui32SysClock, ui32PLLRate;
#ifdef USE_ULPI
uint32_t ui32Setting;
#endif
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Set the part pin out appropriately for this device.
//
PinoutSet();
#ifdef USE_ULPI
//
// Switch the USB ULPI Pins over.
//
USBULPIPinoutSet();
//
// Enable USB ULPI with high speed support.
//
ui32Setting = USBLIB_FEATURE_ULPI_HS;
USBOTGFeatureSet(0, USBLIB_FEATURE_USBULPI, &ui32Setting);
//
// Setting the PLL frequency to zero tells the USB library to use the
// external USB clock.
//
ui32PLLRate = 0;
#else
//
// Save the PLL rate used by this application.
//
ui32PLLRate = 480000000;
#endif
//
// Initialize the hub port status.
//
for(i32Idx = 0; i32Idx < NUM_HUB_STATUS; i32Idx++)
{
g_psHubStatus[i32Idx].bConnected = false;
}
//
// Enable Clocking to the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, eUSBModeHost, 0);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open the Keyboard interface.
//
KeyboardOpen();
MSCOpen(ui32SysClock);
//
// Open a hub instance and provide it with the memory required to hold
// configuration descriptors for each attached device.
//
USBHHubOpen(HubCallback);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Tell the USB library the CPU clock and the PLL frequency.
//
USBOTGFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);
USBOTGFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate);
//
// Initialize the USB controller for Host mode.
//
USBHCDInit(0, g_pui8HCDPool, sizeof(g_pui8HCDPool));
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "usb-host-hub");
//
// Calculate the number of characters that will fit on a line.
// Make sure to leave a small border for the text box.
//
g_ui32CharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 16) /
GrFontMaxWidthGet(g_psFontFixed6x8);
//
// Calculate the number of lines per usable text screen. This requires
// taking off space for the top and bottom banners and adding a small bit
// for a border.
//
g_ui32LinesPerScreen = (GrContextDpyHeightGet(&g_sContext) -
(2*(DISPLAY_BANNER_HEIGHT + 1)))/
GrFontHeightGet(g_psFontFixed6x8);
//
// Initial update of the screen.
//
UpdateStatus(0);
UpdateStatus(1);
UpdateStatus(2);
UpdateStatus(3);
g_ui32CmdIdx = 0;
g_ui32CurrentLine = 0;
//
// Initialize the file system.
//
FileInit();
//
// The main loop for the application.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
WriteString("> ");
//
// Is there a command waiting to be processed?
//
while((g_ui32Flags & FLAG_CMD_READY) == 0)
{
//
// Call the YSB library to let non-interrupt code run.
//
USBHCDMain();
//
// Call the keyboard and mass storage main routines.
//
KeyboardMain();
MSCMain();
}
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
i32Status = CmdLineProcess(g_pcCmdBuf);
//
// Handle the case of bad command.
//
if(i32Status == CMDLINE_BAD_CMD)
{
WriteString("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(i32Status == CMDLINE_TOO_MANY_ARGS)
{
WriteString("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(i32Status != 0)
{
WriteString("Command returned error code\n");
WriteString((char *)StringFromFresult((FRESULT)i32Status));
WriteString("\n");
}
//
// Reset the command flag and the command index.
//
g_ui32Flags &= ~FLAG_CMD_READY;
g_ui32CmdIdx = 0;
}
}
//*****************************************************************************
//
// The program main function. It performs initialization, then runs a loop to
// process USB activities and operate the user interface.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32DriveTimeout;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the system clock to run at 50MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Configure the required pins for USB operation.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Configure SysTick for a 100Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enable the uDMA controller and set up the control table base.
// The uDMA controller is used by the USB library.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the buttons driver.
//
ButtonsInit();
//
// Initialize two offscreen displays and assign the palette. These
// buffers are used by the slide menu widget to allow animation effects.
//
GrOffScreen4BPPInit(&g_sOffscreenDisplayA, g_pui8OffscreenBufA, 96, 64);
GrOffScreen4BPPPaletteSet(&g_sOffscreenDisplayA, g_pui32Palette, 0,
NUM_PALETTE_ENTRIES);
GrOffScreen4BPPInit(&g_sOffscreenDisplayB, g_pui8OffscreenBufB, 96, 64);
GrOffScreen4BPPPaletteSet(&g_sOffscreenDisplayB, g_pui32Palette, 0,
NUM_PALETTE_ENTRIES);
//
// Show an initial status screen
//
g_pcStatusLines[0] = "Waiting";
g_pcStatusLines[1] = "for device";
ShowStatusScreen(g_pcStatusLines, 2);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sFileMenuWidget);
//
// Initially wait for device connection.
//
g_eState = STATE_NO_DEVICE;
//
// Initialize the USB stack for host mode.
//
USBStackModeSet(0, eUSBModeHost, 0);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open an instance of the mass storage class driver.
//
g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the drive timeout.
//
ui32DriveTimeout = USBMSC_DRIVE_RETRY;
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Initialize the USB controller for host operation.
//
USBHCDInit(0, g_pui8HCDPool, HCD_MEMORY_SIZE);
//
// Initialize the file system.
//
FileInit();
//
// Enter an infinite loop to run the user interface and process USB
// events.
//
while(1)
{
uint32_t ui32LastTickCount = 0;
//
// Call the USB stack to keep it running.
//
USBHCDMain();
//
// Process any messages in the widget message queue. This keeps the
// display UI running.
//
WidgetMessageQueueProcess();
//
// Take action based on the application state.
//
switch(g_eState)
{
//
// A device has enumerated.
//
case STATE_DEVICE_ENUM:
{
//
// Check to see if the device is ready. If not then stay
// in this state and we will check it again on the next pass.
//
if(USBHMSCDriveReady(g_psMSCInstance) != 0)
{
//
// Wait about 500ms before attempting to check if the
// device is ready again.
//
ROM_SysCtlDelay(ROM_SysCtlClockGet()/(3));
//
// Decrement the retry count.
//
ui32DriveTimeout--;
//
// If the timeout is hit then go to the
// STATE_TIMEOUT_DEVICE state.
//
if(ui32DriveTimeout == 0)
{
g_eState = STATE_TIMEOUT_DEVICE;
}
break;
}
//
// Getting here means the device is ready.
// Reset the CWD to the root directory.
//
g_pcCwdBuf[0] = '/';
g_pcCwdBuf[1] = 0;
//
// Set the initial directory level to the root
//
g_ui32Level = 0;
//
// We need to reset the indexes of the root menu to 0, so that
// it will start at the top of the file list, and reset the
// slide menu widget to start with the root menu.
//
g_psFileMenus[g_ui32Level].ui32CenterIndex = 0;
g_psFileMenus[g_ui32Level].ui32FocusIndex = 0;
SlideMenuMenuSet(&g_sFileMenuWidget, &g_psFileMenus[g_ui32Level]);
//
// Initiate a directory change to the root. This will
// populate a menu structure representing the root directory.
//
if(ProcessDirChange("/", g_ui32Level))
{
//
// If there were no errors reported, we are ready for
// MSC operation.
//
g_eState = STATE_DEVICE_READY;
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
//
// Request a repaint so the file menu will be shown
//
WidgetPaint(WIDGET_ROOT);
}
break;
}
//
// If there is no device then just wait for one.
//
case STATE_NO_DEVICE:
{
if(g_ui32Flags == FLAGS_DEVICE_PRESENT)
{
//
// Show waiting message on screen
//
g_pcStatusLines[0] = "Waiting";
g_pcStatusLines[1] = "for device";
ShowStatusScreen(g_pcStatusLines, 2);
//
// Clear the Device Present flag.
//
g_ui32Flags &= ~FLAGS_DEVICE_PRESENT;
}
break;
}
//
// An unknown device was connected.
//
case STATE_UNKNOWN_DEVICE:
{
//
// If this is a new device then change the status.
//
if((g_ui32Flags & FLAGS_DEVICE_PRESENT) == 0)
{
//
// Clear the screen and indicate that an unknown device
// is present.
//
g_pcStatusLines[0] = "Unknown";
g_pcStatusLines[1] = "device";
ShowStatusScreen(g_pcStatusLines, 2);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// The connected mass storage device is not reporting ready.
//
case STATE_TIMEOUT_DEVICE:
{
//
// If this is the first time in this state then print a
// message.
//
if((g_ui32Flags & FLAGS_DEVICE_PRESENT) == 0)
{
//
//
// Clear the screen and indicate that an unknown device
// is present.
//
g_pcStatusLines[0] = "Device";
g_pcStatusLines[1] = "Timeout";
ShowStatusScreen(g_pcStatusLines, 2);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// The device is ready and in use.
//
case STATE_DEVICE_READY:
{
//
// Process occurrence of timer tick. Check for user input
// once each tick.
//
if(g_ui32SysTickCount != ui32LastTickCount)
{
uint8_t ui8ButtonState;
uint8_t ui8ButtonChanged;
ui32LastTickCount = g_ui32SysTickCount;
//
// Get the current debounced state of the buttons.
//
ui8ButtonState = ButtonsPoll(&ui8ButtonChanged, 0);
//
// If select button or right button is pressed, then we
// are trying to descend into another directory
//
if(BUTTON_PRESSED(SELECT_BUTTON,
ui8ButtonState, ui8ButtonChanged) ||
BUTTON_PRESSED(RIGHT_BUTTON,
ui8ButtonState, ui8ButtonChanged))
{
uint32_t ui32NewLevel;
uint32_t ui32ItemIdx;
char *pcItemName;
//
// Get a pointer to the current menu for this CWD.
//
tSlideMenu *psMenu = &g_psFileMenus[g_ui32Level];
//
// Get the highlighted index in the current file list.
// This is the currently highlighted file or dir
// on the display. Then get the name of the file at
// this index.
//
ui32ItemIdx = SlideMenuFocusItemGet(psMenu);
pcItemName = psMenu->psSlideMenuItems[ui32ItemIdx].pcText;
//
// Make sure we are not yet past the maximum tree
// depth.
//
if(g_ui32Level < MAX_SUBDIR_DEPTH)
{
//
// Potential new level is one greater than the
// current level.
//
ui32NewLevel = g_ui32Level + 1;
//
// Process the directory change to the new
// directory. This function will populate a menu
// structure with the files and subdirs in the new
// directory.
//
if(ProcessDirChange(pcItemName, ui32NewLevel))
{
//
// If the change was successful, then update
// the level.
//
g_ui32Level = ui32NewLevel;
//
// Now that all the prep is done, send the
// KEY_RIGHT message to the widget and it will
// "slide" from the previous file list to the
// new file list of the CWD.
//
SendWidgetKeyMessage(WIDGET_MSG_KEY_RIGHT);
}
}
}
//
// If the UP button is pressed, just pass it to the widget
// which will handle scrolling the list of files.
//
if(BUTTON_PRESSED(UP_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_UP);
}
//
// If the DOWN button is pressed, just pass it to the widget
// which will handle scrolling the list of files.
//
if(BUTTON_PRESSED(DOWN_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_DOWN);
}
//
// If the LEFT button is pressed, then we are attempting
// to go up a level in the file system.
//
if(BUTTON_PRESSED(LEFT_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
uint32_t ui32NewLevel;
//
// Make sure we are not already at the top of the
// directory tree (at root).
//
if(g_ui32Level)
{
//
// Potential new level is one less than the
// current level.
//
ui32NewLevel = g_ui32Level - 1;
//
// Process the directory change to the new
// directory. This function will populate a menu
// structure with the files and subdirs in the new
// directory.
//
if(ProcessDirChange("..", ui32NewLevel))
{
//
// If the change was successful, then update
// the level.
//
g_ui32Level = ui32NewLevel;
//
// Now that all the prep is done, send the
// KEY_LEFT message to the widget and it will
// "slide" from the previous file list to the
// new file list of the CWD.
//
SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT);
}
}
}
}
break;
}
//
// Something has caused a power fault.
//
case STATE_POWER_FAULT:
{
//
// Clear the screen and show a power fault indication.
//
g_pcStatusLines[0] = "Power";
g_pcStatusLines[1] = "fault";
ShowStatusScreen(g_pcStatusLines, 2);
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
FRESULT FileResult;
tRectangle sRect;
//
// Initially wait for device connection.
//
g_eState = STATE_NO_DEVICE;
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Enable Clocking to the USB controller.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Enable the peripherals used by this example.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
//
// Set the USB pins to be controlled by the USB controller.
//
GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4);
//
// The LM3S3748 board uses a USB mux that must be switched to use the
// host connecter and not the device connecter.
//
GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);
GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST);
//
// Turn on USB Phy clock.
//
SysCtlUSBPLLEnable();
//
// Set the system tick to fire 100 times per second.
//
SysTickPeriodSet(SysCtlClockGet()/100);
SysTickIntEnable();
SysTickEnable();
//
// Enable the uDMA controller and set up the control table base.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
uDMAEnable();
uDMAControlBaseSet(g_sDMAControlTable);
//
// Initialize the display driver.
//
Formike128x128x16Init();
//
// Turn on the backlight.
//
Formike128x128x16BacklightOn();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sFormike128x128x16);
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.sXMin = 0;
sRect.sYMin = 0;
sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.sYMax = SPLASH_HEIGHT - 1;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
GrRectFill(&g_sContext, &sRect);
//
// Put a white box around the banner.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrRectDraw(&g_sContext, &sRect);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb_host_msc", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
//
// Set the color to white and select the 20 point font.
//
GrContextForegroundSet(&g_sContext, FILE_COLOR);
GrStringDraw(&g_sContext, "No Device",
100, 0, TOP_HEIGHT, 1);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers);
//
// Open an instance of the mass storage class driver.
//
g_ulMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USB_HOST_PWREN_HIGH);
//
// Initialize the host controller.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
//
// Initialize the pushbuttons.
//
ButtonsInit();
//
// Set the auto repeat rates for the up and down buttons.
//
ButtonsSetAutoRepeat(UP_BUTTON, 50, 15);
ButtonsSetAutoRepeat(DOWN_BUTTON, 50, 15);
//
// Current directory is "/"
//
g_DirData.szPWD[0] = '/';
g_DirData.szPWD[1] = 0;
//
// Initialize the file system.
//
FileInit();
while(1)
{
USBHCDMain();
switch(g_eState)
{
case STATE_DEVICE_ENUM:
{
//
// Reset the root directory.
//
g_DirData.szPWD[0] = '/';
g_DirData.szPWD[1] = 0;
//
// Open the root directory.
//
FileResult = f_opendir(&g_DirData.DirState, g_DirData.szPWD);
//
// Wait for the root directory to open successfully. The MSC
// device can enumerate before being read to be accessed, so
// there may be some delay before it is ready.
//
if(FileResult == FR_OK)
{
//
// Reset the directory state.
//
g_DirData.ulIndex = 0;
g_DirData.ulSelectIndex = 0;
g_DirData.ulValidValues = 0;
g_eState = STATE_DEVICE_READY;
//
// Ignore buttons pressed before being ready.
//
g_ulButtons = 0;
//
// Update the screen if the root dir opened successfully.
//
DirUpdate();
UpdateWindow();
}
else if(FileResult != FR_NOT_READY)
{
// some kind of error
}
//
// Set the Device Present flag.
//
g_ulFlags = FLAGS_DEVICE_PRESENT;
break;
}
//
// This is the running state where buttons are checked and the
// screen is updated.
//
case STATE_DEVICE_READY:
{
//
// Down button pressed and released.
//
if(g_ulButtons & BUTTON_DOWN_CLICK)
{
//
// Update the screen and directory state.
//
MoveDown();
//
// Clear the button pressed event.
//
g_ulButtons &= ~BUTTON_DOWN_CLICK;
}
//
// Up button pressed and released.
//
if(g_ulButtons & BUTTON_UP_CLICK)
{
//
// Update the screen and directory state.
//
MoveUp();
//
// Clear the button pressed event.
//
g_ulButtons &= ~BUTTON_UP_CLICK;
}
//
// Select button pressed and released.
//
if(g_ulButtons & BUTTON_SELECT_CLICK)
{
//
// If this was a directory go into it.
//
SelectDir();
//
// Clear the button pressed event.
//
g_ulButtons &= ~BUTTON_SELECT_CLICK;
}
break;
}
//
// If there is no device then just wait for one.
//
case STATE_NO_DEVICE:
{
if(g_ulFlags == FLAGS_DEVICE_PRESENT)
{
//
// Clear the screen and indicate that there is no longer
// a device present.
//
ClearTextBox();
GrStringDraw(&g_sContext, "No Device",
100, 0, TOP_HEIGHT, 1);
//
// Clear the Device Present flag.
//
g_ulFlags &= ~FLAGS_DEVICE_PRESENT;
}
break;
}
//
// An unknown device was connected.
//
case STATE_UNKNOWN_DEVICE:
{
//
// If this is a new device then change the status.
//
if((g_ulFlags & FLAGS_DEVICE_PRESENT) == 0)
{
//
// Clear the screen and indicate that an unknown device is
// present.
//
ClearTextBox();
GrStringDraw(&g_sContext, "Unknown Device",
100, 0, TOP_HEIGHT, 1);
}
//
// Set the Device Present flag.
//
g_ulFlags = FLAGS_DEVICE_PRESENT;
break;
}
//
// Something has caused a power fault.
//
case STATE_POWER_FAULT:
{
break;
}
default:
{
break;
}
}
}
}
int main (void)
{
int answer;
CreatorInfo();
while (true)
{
printf("================== MENU ==================\n");
printf("1. Input the database;\n");
printf("2. Supplement to the database;\n");
printf("3. Edit the database;\n");
printf("4. Delete the element in the database;\n");
printf("5. Output the database;\n");
printf("6. Output the worst students list;\n");
printf("7. Output the teachers-docents list;\n");
printf("8. Output the totall budget of faculties;\n");
printf("0. Exit.\n\n");
scanf("%d", &answer);
switch (answer)
{
case INPUT:
{
FileInit();
break;
}
case SUPPLEMENT:
{
FileSupplement();
break;
}
case EDIT:
{
FileEditing();
break;
}
case DELETE:
{
FileDelete();
break;
}
case OUTPUT:
{
FileOutput();
break;
}
case VIEWSTUD:
{
LowestScore();
break;
}
case VIEWTEACH:
{
Docents();
break;
}
case BUDGET:
{
TotallBudget();
break;
}
case EXIT:
{
exit (false);
break;
}
default:
printf("Something went wrong...\n");
}
}
}
//*****************************************************************************
//
// The program main function. It performs initialization, then runs
// a command processing loop to read commands from the console.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32DriveTimeout;
uint32_t ui32SysClock;
tContext sContext;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "usb-host-msc");
//
// Configure SysTick for a 100Hz interrupt.
//
ROM_SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enable the uDMA controller and set up the control table base.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_sDMAControlTable);
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sBackground);
//
// Set some initial strings.
//
ListBoxTextAdd(&g_sDirList, "Waiting for device...");
//
// Issue the initial paint request to the widgets then immediately call
// the widget manager to process the paint message. This ensures that the
// display is drawn as quickly as possible and saves the delay we would
// otherwise experience if we processed the paint message after mounting
// and reading the SD card.
//
WidgetPaint(WIDGET_ROOT);
WidgetMessageQueueProcess();
//
// Initially wait for device connection.
//
g_eState = STATE_NO_DEVICE;
//
// Initialize the USB stack for host mode.
//
USBStackModeSet(0, eUSBModeHost, 0);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open an instance of the mass storage class driver.
//
g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the drive timeout.
//
ui32DriveTimeout = USBMSC_DRIVE_RETRY;
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Initialize the USB controller for host operation.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
//
// Initialize the file system.
//
FileInit();
//
// Enter an (almost) infinite loop for reading and processing commands from
// the user.
//
while(1)
{
//
// Call the USB stack to keep it running.
//
USBHCDMain();
//
// Process any messages in the widget message queue. This keeps the
// display UI running.
//
WidgetMessageQueueProcess();
switch(g_eState)
{
case STATE_DEVICE_ENUM:
{
//
// Take it easy on the Mass storage device if it is slow to
// start up after connecting.
//
if(USBHMSCDriveReady(g_psMSCInstance) != 0)
{
//
// Wait about 500ms before attempting to check if the
// device is ready again.
//
ROM_SysCtlDelay(ui32SysClock / (3 * 2));
//
// Decrement the retry count.
//
ui32DriveTimeout--;
//
// If the timeout is hit then go to the
// STATE_TIMEOUT_DEVICE state.
//
if(ui32DriveTimeout == 0)
{
g_eState = STATE_TIMEOUT_DEVICE;
}
break;
}
//
// Getting here means the device is ready.
// Reset the CWD to the root directory.
//
g_cCwdBuf[0] = '/';
g_cCwdBuf[1] = 0;
//
// Set the initial directory level to the root
//
g_ui32Level = 0;
//
// Fill the list box with the files and directories found.
//
if(!PopulateFileListBox(true))
{
//
// If there were no errors reported, we are ready for
// MSC operation.
//
g_eState = STATE_DEVICE_READY;
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// If there is no device then just wait for one.
//
case STATE_NO_DEVICE:
{
if(g_ui32Flags == FLAGS_DEVICE_PRESENT)
{
//
// Empty the list box on the display.
//
ListBoxClear(&g_sDirList);
ListBoxTextAdd(&g_sDirList, "Waiting for device...");
WidgetPaint((tWidget *)&g_sDirList);
//
// Clear the Device Present flag.
//
g_ui32Flags &= ~FLAGS_DEVICE_PRESENT;
}
break;
}
//
// An unknown device was connected.
//
case STATE_UNKNOWN_DEVICE:
{
//
// If this is a new device then change the status.
//
if((g_ui32Flags & FLAGS_DEVICE_PRESENT) == 0)
{
//
// Clear the screen and indicate that an unknown device
// is present.
//
ListBoxClear(&g_sDirList);
ListBoxTextAdd(&g_sDirList, "Unknown device.");
WidgetPaint((tWidget *)&g_sDirList);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// The connected mass storage device is not reporting ready.
//
case STATE_TIMEOUT_DEVICE:
{
//
// If this is the first time in this state then print a
// message.
//
if((g_ui32Flags & FLAGS_DEVICE_PRESENT) == 0)
{
//
// Clear the screen and indicate that an unknown device
// is present.
//
ListBoxClear(&g_sDirList);
ListBoxTextAdd(&g_sDirList, "Device Timeout.");
WidgetPaint((tWidget *)&g_sDirList);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// Something has caused a power fault.
//
case STATE_POWER_FAULT:
{
break;
}
default:
{
break;
}
}
}
}
//The Main function of program
int main(int argc, char *argv[])
{
#ifdef _DEBUG
//Handle the system signal.
SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE);
#endif
if (argc > 0)
{
std::shared_ptr<wchar_t> wPath(new wchar_t[MAX_PATH]());
//Path initialization and Winsock initialization.
MultiByteToWideChar(CP_ACP, NULL, argv[0], MBSTOWCS_NULLTERMINATE, wPath.get(), MAX_PATH);
if (FileInit(wPath.get()) == EXIT_FAILURE)
return EXIT_FAILURE;
wPath.reset();
//Windows Firewall Test in first start.
if (argc > 1 && strlen(argv[1U]) == strlen("--FirstStart") && memcmp(argv[1], ("--FirstStart"), strlen("--FirstStart")) == 0)
{
if (FirewallTest(AF_INET6) == EXIT_FAILURE && FirewallTest(AF_INET) == EXIT_FAILURE)
{
PrintError(WINSOCK_ERROR, L"Windows Firewall Test error", NULL, nullptr, NULL);
WSACleanup();
return EXIT_FAILURE;
}
else {
return EXIT_SUCCESS;
}
}
}
else {
return EXIT_FAILURE;
}
//Read configuration file and WinPcap initialization.
if (Parameter.ReadParameter() == EXIT_FAILURE)
{
WSACleanup();
return EXIT_FAILURE;
}
std::thread CaptureInitializationThread(CaptureInit);
CaptureInitializationThread.detach();
//Get Localhost DNS PTR Records.
std::thread IPv6LocalAddressThread(LocalAddressToPTR, AF_INET6);
std::thread IPv4LocalAddressThread(LocalAddressToPTR, AF_INET);
IPv6LocalAddressThread.detach();
IPv4LocalAddressThread.detach();
//DNSCurve initialization
if (Parameter.DNSCurve && DNSCurveParameter.Encryption)
{
randombytes_set_implementation(&randombytes_salsa20_implementation);
DNSCurveInit();
}
//Read IPFilter, start DNS Cache monitor(Timer type) and read Hosts.
if (Parameter.FileRefreshTime > 0)
{
if (Parameter.OperationMode == LISTEN_CUSTOMMODE)
{
std::thread IPFilterThread(&Configuration::ReadIPFilter, std::ref(Parameter));
IPFilterThread.detach();
}
if (Parameter.CacheType != 0)
{
std::thread DNSCacheTimerThread(DNSCacheTimerMonitor, Parameter.CacheType);
DNSCacheTimerThread.detach();
}
std::thread HostsThread(&Configuration::ReadHosts, std::ref(Parameter));
HostsThread.detach();
}
//Service initialization and start service.
SERVICE_TABLE_ENTRYW ServiceTable[] = {{LOCAL_SERVICENAME, (LPSERVICE_MAIN_FUNCTIONW)ServiceMain}, {nullptr, NULL}};
if (!StartServiceCtrlDispatcherW(ServiceTable))
{
PrintError(SYSTEM_ERROR, L"Service start error", GetLastError(), nullptr, NULL);
WSACleanup();
return EXIT_FAILURE;
}
WSACleanup();
return EXIT_SUCCESS;
}
void main(void)
{
Int16 *samples;
HANDLE FHandle = Not_Open_FILE;
Int16 *out_words = &rawOutWords[1];
Uint8 *byte16 = &RfByte[2];
Int16 mlt_coefs[DCT_LENGTH];
Int16 mag_shift[2];
Int16 old_mag_shift[2];
Uint16 number_of_bits_per_frame;
Uint16 number_of_bytes_per_frame;
Uint16 number_of_16bit_words_per_frame;
Int16 offset;
Int16 key;
Uint16 chn; // left and right channel, 0 or 1
Int16 sent_buffer_cnt = 0;
Uint8 *sent_buffer;
ICR = 0xff2e; /* IDLE Control Register */
/* mem port, io port and cpu idle active */
DSP_zero(xmt_l, DCT_LENGTH);
DSP_zero(xmt_r, DCT_LENGTH);
/* Peripheral_Reset */
CSL_SYSCTRL_REGS->PSRCR = 0x0020;
CSL_SYSCTRL_REGS->PCGCR1 = 0x0000;
CSL_SYSCTRL_REGS->PCGCR2 = 0x0000;
CSL_SYSCTRL_REGS->PRCR = 0x00bf;
CSL_SYSCTRL_REGS->EBSR = (CSL_SYS_EBSR_PPMODE_MODE1 << 12)
| (0 << 8) | (2 << 10);//GPIO(11-6)
asm(" bit(ST1, #ST1_INTM) = #1");
number_of_bits_per_frame = (Uint16)(BITRATE * 20); // BITRATE in kbps
number_of_bytes_per_frame = (Uint16)(number_of_bits_per_frame>>3);
number_of_16bit_words_per_frame = (Uint16)(number_of_bits_per_frame>>4);
INTR_init();
PLL_init();
TIMER_init();
EZDSP5535_GPIO_init();
DMA_audio_init(DCT_LENGTH);
EZDSP5535_I2C_init(); /* Initialize I2C */
aic3204_init(6); /* Initialize codec */
EZDSP5535_LCD_init();
EZDSP5535_I2S_init(); /* Initialize I2S */
LCD_print("G722.1 Send ", 17, 0);
LCD_print("16kbps ", 8, 1);
EZDSP5535_SPI_init();
Si446x_Init();
EZDSP5535_SAR_init();
DiskInit();
FileInit();
AddFileDriver(SDCammand, NULL);
sam2coef_init();
coef2sam_init();
rawOutWords[0] = 0x6b21;
RfByte[0] = 0x21; RfByte[1] = 0x6b; // little-endian
old_mag_shift[0] = 0;
old_mag_shift[1] = 0;
asm(" bit(ST1, #ST1_INTM) = #0");
SpiWriteByte(CMD_GET_INT_STATUS, 0); // clear interrupt pending
while(1) {
if(pingpong >= 0) {
offset = (pingpong>>1) * DCT_LENGTH;
/*******************************************************************
* LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT LEFT
*******************************************************************/
chn = LEFT;
samples = &rcv_l[offset]; // Read frame of samples from mem.
// Convert input samples to rmlt coefs
mag_shift[chn] = samples_to_rmlt_coefs(samples, mlt_coefs, chn);
// Encode the mlt coefs
encoder(number_of_bits_per_frame, mlt_coefs, mag_shift[chn], out_words);
byte16 = &RfByte[2];
byte16[-2] = 0x6b; byte16[-1] = 0x20;
DSP_word2byte(byte16, out_words, number_of_16bit_words_per_frame);
// process the out_words into decoder_mlt_coefs
decoder(out_words, mlt_coefs, &mag_shift[chn], &old_mag_shift[chn]);
samples = &xmt_l[offset]; // Write frame of output samples
// convert the decoder_mlt_coefs to samples
rmlt_coefs_to_samples(mlt_coefs, samples, mag_shift[chn], chn);
/*******************************************************************
* RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT RIGHT
*******************************************************************/
chn = RIGHT;
samples = &rcv_r[offset]; // Read frame of samples from mem.
// Convert input samples to rmlt coefs
mag_shift[chn] = samples_to_rmlt_coefs(samples, mlt_coefs, chn);
// Encode the mlt coefs
encoder(number_of_bits_per_frame, mlt_coefs, mag_shift[chn], out_words);
byte16 = &RfByte[number_of_bytes_per_frame + 4];
byte16[-2] = 0x6b; byte16[-1] = 0x21;
DSP_word2byte(byte16, out_words, number_of_16bit_words_per_frame);
// process the out_words into decoder_mlt_coefs
decoder(out_words, mlt_coefs, &mag_shift[chn], &old_mag_shift[chn]);
samples = &xmt_r[offset]; // Write frame of output samples
// convert the decoder_mlt_coefs to samples
rmlt_coefs_to_samples(mlt_coefs, samples, mag_shift[chn], chn);
if (FHandle != Not_Open_FILE) // Write output bitstream
FileWrite(RfByte, 2*number_of_bytes_per_frame+4, FHandle);
pingpong = -1;
sent_buffer = RfByte;
sent_buffer_cnt = 0;
}
if(spiIsrStatus == 1) {
bApi_Set_Send(43);
spiIsrStatus = 0;
}
if(sent_buffer_cnt < 2) {
if(gpioIsrStatus == 1) {
SPI_sendData(sent_buffer, number_of_bytes_per_frame+2);
sent_buffer += number_of_bytes_per_frame+2;
sent_buffer_cnt++;
gpioIsrStatus = 0;
CSL_GPIO_REGS->IOINTFLG1 = 0x0800;
}
}
// key = EZDSP5535_SAR_getKey();
key = -1;
if(key == SW1)
if(FHandle == Not_Open_FILE)
{
LCD_print("RECORDING......", 15, 0);
FHandle = FileOpen("A:\\VOICE000.TXT", FILE_FLAGS_WRITE);
}
if(key == SW2)
if(FHandle != Not_Open_FILE)
{
LCD_print("SAVE VOICE000.DAT", 17, 0);
FileClose(FHandle);
AllCacheWriteBack();
FHandle = Not_Open_FILE;
}
asm(" idle");
}