void SYS_Initialize ( void * data )
{
/* Configure the cache and flash wait
* states for 80MHz. */
SYSTEMConfigPerformance(80000000);
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* Initialize the global interrupts */
SYS_INT_Enable();
SYS_INT_VectorPrioritySet(INT_VECTOR_USB, INT_PRIORITY_LEVEL4);
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL0);
SYS_INT_VectorPrioritySet(INT_VECTOR_CT, INT_PRIORITY_LEVEL3);
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL0);
BSP_Initialize();
/* Initialize the USB device layer */
deviceLayerObject = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 ,
( SYS_MODULE_INIT* ) & usbDevInitData);
/* check if the object returned by the device layer is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != deviceLayerObject), "Invalid USB DEVICE object");
/* Initialize the Application */
APP_Initialize ( );
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
/* Initialize Drivers */
/*Initialize TMR0 */
DRV_TMR0_Initialize();
/*Initialize TMR1 */
DRV_TMR1_Initialize();
/*Initialize TMR2 */
DRV_TMR2_Initialize();
/*Initialize TMR3 */
DRV_TMR3_Initialize();
DRV_USART0_Initialize();
DRV_USART1_Initialize();
/*Initialize OC0 */
DRV_OC0_Initialize();
/*Initialize OC1 */
DRV_OC1_Initialize();
/* Initialize System Services */
SYS_INT_Initialize();
/*Setup the INT_SOURCE_EXTERNAL_1 and Enable it*/
SYS_INT_VectorPrioritySet(INT_VECTOR_INT1, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_INT1, INT_SUBPRIORITY_LEVEL0);
SYS_INT_ExternalInterruptTriggerSet(INT_EXTERNAL_INT_SOURCE1,INT_EDGE_TRIGGER_RISING);
SYS_INT_SourceEnable(INT_SOURCE_EXTERNAL_1);
/*Setup the INT_SOURCE_EXTERNAL_2 and Enable it*/
SYS_INT_VectorPrioritySet(INT_VECTOR_INT2, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_INT2, INT_SUBPRIORITY_LEVEL0);
SYS_INT_ExternalInterruptTriggerSet(INT_EXTERNAL_INT_SOURCE2,INT_EDGE_TRIGGER_RISING);
SYS_INT_SourceEnable(INT_SOURCE_EXTERNAL_2);
/* Initialize Middleware */
initDebugU();
/* Initialize the Application */
COMMUNICATION_Initialize();
MOTOR_Initialize();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
/* Board Support Package Initialization */
BSP_Initialize();
/* System Services Initialization */
SYS_INT_Initialize();
SYS_PORTS_Initialize();
/* Initialize Drivers */
sysObj.drvTmr0 = DRV_TMR_Initialize(DRV_TMR_INDEX_0, (SYS_MODULE_INIT *)&drvTmr0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_T2, INT_PRIORITY_LEVEL4);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T2, INT_SUBPRIORITY_LEVEL0);
/* Initialize System Services */
/*** TMR Service Initialization Code ***/
sysObj.sysTmr = SYS_TMR_Initialize(SYS_TMR_INDEX_0, (const SYS_MODULE_INIT * const)&sysTmrInitData);
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL4);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Set the priority of the USB DMA Interrupt */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1_DMA, INT_PRIORITY_LEVEL4);
/* Set Sub-priority of the USB DMA Interrupt */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1_DMA, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
APP_Initialize();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGEnable();
SYS_PORTS_Initialize();
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
sysObj.drvTmr0 = DRV_TMR_Initialize(DRV_TMR_INDEX_0, (SYS_MODULE_INIT *)&drvTmr0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_T1, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T1, INT_SUBPRIORITY_LEVEL0);
/* Initialize System Services */
SYS_INT_Initialize();
/*** TMR Service Initialization Code ***/
sysObj.sysTmr = SYS_TMR_Initialize(SYS_TMR_INDEX_0, (const SYS_MODULE_INIT * const)&sysTmrInitData);
SYS_RANDOM_Initialize(0, 0);
/* Initialize Middleware */
/* set priority for ETHERNET interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_ETH, INT_PRIORITY_LEVEL5);
/* set sub-priority for ETHERNET interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_ETH, INT_SUBPRIORITY_LEVEL3);
/* TCPIP Stack Initialization */
sysObj.tcpip = TCPIP_STACK_Init();
if (sysObj.tcpip == SYS_MODULE_OBJ_INVALID)
{
return;
}
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
APP_Initialize();
RESTAPI_Initialize();
}
void SYS_Initialize ( void* data ) {
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*) & sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
ANSELB = SYS_ANSELB; //JT - old ansel doesn't do shit
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
sysObj.drvUsart0 = DRV_USART_Initialize(DRV_USART_INDEX_0, (SYS_MODULE_INIT *) & drvUsart0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_UART2, INT_PRIORITY_LEVEL4);
SYS_INT_VectorSubprioritySet(INT_VECTOR_UART2, INT_SUBPRIORITY_LEVEL0);
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL4);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* Enable Global Interrupts */
SYS_INT_Enable();
//startup OLED
//if first power-up, wait for OLED to warm up
int waitii;
if (RCONbits.POR)
for (waitii = 0; waitii < 2000000; waitii++) {
}
RCONbits.POR = 0;
oled_init();
robot_config_ports();
/* Initialize the Application */
APP_Initialize();
}
void SYS_Initialize ( void* data )
{
uint8_t handle=0xff; //Handle to the driver
// populate the PMP init configuration structure
init.polarity.addressLatchPolarity = PMP_POLARITY_ACTIVE_HIGH;
init.polarity.rwStrobePolarity = PMP_POLARITY_ACTIVE_LOW;
init.polarity.writeEnableStrobePolarity = PMP_POLARITY_ACTIVE_LOW;
init.polarity.chipselect1Polarity = PMP_POLARITY_ACTIVE_HIGH;
init.polarity.chipselect2Polarity = PMP_POLARITY_ACTIVE_LOW;
init.ports.readWriteStrobe = PORT_ENABLE;
init.ports.writeEnableStrobe = PORT_ENABLE;
init.moduleInit.value = SYS_MODULE_POWER_RUN_FULL;
init.pmpID = PMP_ID_0;
init.stopInIdle = false;
init.muxMode = PMP_MUX_NONE;
object = DRV_PMP_Initialize (DRV_PMP_INDEX_0, (SYS_MODULE_INIT *)&init);
/* Initialize the Application */
APP_Initialize();
/* Initializethe interrupt system */
SYS_INT_Initialize();
SYS_INT_VectorPrioritySet(INT_VECTOR_T4, INT_PRIORITY_LEVEL2);
/* set priority for PMP interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_PMP, INT_PRIORITY_LEVEL6);
/* Initialize the global interrupts */
SYS_INT_Enable();
GFX_DRV_lcc_Initialize(0); //Initialize the Graphics Driver
while( handle != 0)
{
handle = GFX_DRV_lcc_Open(0);
}
GFX_Initialize();
/* Turn on the backlight */
DisplayBacklightOn();
/* Initialize the BSP */
// BSP_Initialize( );
}
void SYS_Initialize ( void* data )
{
/* Set up cache and wait states for
* maximum performance. */
SYSTEMConfigPerformance(80000000);
/* Initialize the BSP */
BSP_Initialize( );
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* set priority for NVM interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_FCE, INT_PRIORITY_LEVEL3);
/* set sub-priority for NVM interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_FCE, INT_SUBPRIORITY_LEVEL3);
/* Initialize the global interrupts */
SYS_INT_Enable();
/* Initialize the NVM driver */
appDrvObjects.drvNVMObject = DRV_NVM_Initialize(DRV_NVM_INDEX_0,
(SYS_MODULE_INIT *)&drvNVMInit);
/* Initialize the Application */
APP_Initialize ( );
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL4);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize(
USB_DEVICE_INDEX_0, (SYS_MODULE_INIT*) USBDescriptor_GetDeviceConfig());
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
APP_Initialize();
}
/*******************************************************************************
Function: ACCEL_RESULT ACCELInitialize(ACCEL_INIT *initialization)
*****************************************************************************/
ACCEL_RESULT ACCELInitialize(ACCEL_INIT *initialization, uint8_t accl_range)
{
PLIB_I2C_BaudRateSet(ACCEL_BMA250_I2C_MODULE, initialization->sourceClock, initialization->dataRate);
PLIB_I2C_Enable(ACCEL_BMA250_I2C_MODULE);
#ifndef ACCEL_USE_EXTERNAL_INTERUPT_HANDLER
#ifndef ACCEL_USE_POLLING
SYS_INT_VectorPrioritySet(ACCEL_BMA250_I2C_VECTOR,INT_PRIORITY_LEVEL_2);
#endif
#endif
if(ReadChipID() == ACCEL_INVALID)
return ACCEL_INVALID;
SetRangeAndBandwidth(accl_range);
ReadChipVersion();
SetThershold();
SetFIFO();
accelXYZData.acc_x_lsb.new_data_x = 0;
accelXYZData.acc_y_lsb.new_data_y = 0;
accelXYZData.acc_z_lsb.new_data_z = 0;
return ACCEL_VALID;
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
sysObj.drvUsart0 = DRV_USART_Initialize(DRV_USART_INDEX_0, (SYS_MODULE_INIT *)&drvUsart0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_UART2, INT_PRIORITY_LEVEL4);
SYS_INT_VectorSubprioritySet(INT_VECTOR_UART2, INT_SUBPRIORITY_LEVEL0);
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL4);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
APP_Initialize();
//Initialize LED
ANSELBbits.ANSB15 = 0; // 0 for digital, 1 for analog
TRISBbits.TRISB15 = 0; // 0 for output, 1 for input
// LATBbits.LATB7 = 1;
//
}
/****************************************************************************
* Function: DRV_EXTPHY_IntInit
*
* PreCondition: EthInit and EthPhyInit should have been called.
*
* Input: hClientObj - A valid open-instance handle, returned from the driver's open routine
* src - interrupt source
* intPri - intrrupt priority
* intSubPri - Interuupt Sub Priority
*
* Output: none
*
*
* Side Effects: None
*
* Overview: Initialize External Interrupt 3. One can take this as reference for their WOL
* Interrupt.
*
* Note: None
*****************************************************************************/
void DRV_EXTPHY_IntInit(DRV_HANDLE hClientObj,INT_SOURCE src,int intPri, int intSubPri)
{
// set up the External Interrupt 3 with a prioirty of 5 and 1 sub-priority
SYS_INT_SourceDisable(src); // stop Eth ints
SYS_INT_SourceStatusClear(src);
SYS_INT_VectorPrioritySet(src, intPri);
SYS_INT_VectorSubprioritySet(src, intSubPri);
SYS_INT_SourceEnable(src);
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_PORTS_Initialize();
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
sysObj.drvI2C0 = DRV_I2C_Initialize(DRV_I2C_INDEX_0, (SYS_MODULE_INIT *)&drvI2C0InitData);
sysObj.drvTmr0 = DRV_TMR_Initialize(DRV_TMR_INDEX_0, (SYS_MODULE_INIT *)&drvTmr0InitData);
sysObj.drvTmr1 = DRV_TMR_Initialize(DRV_TMR_INDEX_1, (SYS_MODULE_INIT *)&drvTmr1InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_T3, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T3, INT_SUBPRIORITY_LEVEL0);
SYS_INT_VectorPrioritySet(INT_VECTOR_T2, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T2, INT_SUBPRIORITY_LEVEL0);
/* Initialize System Services */
/*** Interrupt Service Initialization Code ***/
SYS_INT_Initialize();
/*** TMR Service Initialization Code ***/
sysObj.sysTmr = SYS_TMR_Initialize(SYS_TMR_INDEX_0, (const SYS_MODULE_INIT * const)&sysTmrInitData);
/* Initialize Middleware */
/* Initialize the Application */
FLIR_Initialize();
}
void SYS_Initialize ( void * data )
{
/* Initialize the BSP */
BSP_Initialize( );
/* Initialize the USB device layer */
usbDevObject = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 ,
( SYS_MODULE_INIT* ) & usbDevInitData);
/* check if the object returned by the device layer is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != usbDevObject), "Invalid USB DEVICE object");
/* Initialize the Application */
APP_Initialize (&appData);
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* set priority for USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB, INT_PRIORITY_LEVEL3);
/* set sub-priority for USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL3);
/* set priority for USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_CT, INT_PRIORITY_LEVEL3);
/* set sub-priority for USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_CT, INT_SUBPRIORITY_LEVEL3);
/* Initialize the global interrupts */
SYS_INT_Enable();
}
void SYS_Initialize ( void* data )
{
/* Set up cache and wait states for
* maximum performance. */
SYSTEMConfigPerformance(80000000);
/* Initialize the BSP */
BSP_Initialize( );
/* Initialize MDD */
USB_DEVICE_MDD_INTFLASH_Initialize( 0, (const SYS_MODULE_INIT * const)&mddFlashInitData );
/* Initialize the USB device layer */
appDrvObject.usbDevObject = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 ,
( SYS_MODULE_INIT* ) & usbDevInitData);
/* check if the object returned by the device layer is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != appDrvObject.usbDevObject), "Invalid USB DEVICE object");
/* open an instance of the device layer */
appData.usbDevHandle = USB_DEVICE_Open( USB_DEVICE_INDEX_0, 0 );
/* Register a callback with device layer to get event notification (for end point 0) */
USB_DEVICE_EventCallBackSet(appData.usbDevHandle, APP_USBDeviceEventHandler);
/* Register a callback for acquiring vendor specific setup packet */
//USB_DEVICE_ControlEventCallBackSet(appData.usbDevHandle, APP_UsbDeviceControlEventCallBack );
USB_DEVICE_Attach(appData.usbDevHandle);
/* Initialize the Application */
APP_Initialize ( );
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* set priority for USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB, INT_PRIORITY_LEVEL3);
/* set sub-priority for USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL3);
/* Initialize the global interrupts */
SYS_INT_Enable();
}
/****************************************************************************
* Function: DRV_EXTPHY_IntInit
*
* PreCondition: EthInit and EthPhyInit should have been called.
*
* Input: hClientObj - A valid open-instance handle, returned from the driver's open routine
* src - interrupt source
* intPri - intrrupt priority
* intSubPri - Interuupt Sub Priority
*
* Output: none
*
*
* Side Effects: None
*
* Overview: Initialize External Interrupt 3. One can take this as refreence for their WOL
* Interrupt.
*
* Note: None
*****************************************************************************/
static void DRV_EXTPHY_IntInit(DRV_HANDLE hClientObj,SYS_INT_SOURCE src,int intPri, int intSubPri)
{
// set up the External Interrupt 3 with a prioirty of 5 and 1 sub-priority
SYS_INT_SourceDisable(src); // stop Eth ints
SYS_INT_SourceStatusClear(src);
#if defined (HARMONY_INT)
SYS_INT_VectorPrioritySet(src, intPri);
SYS_INT_VectorSubprioritySet(src, intSubPri);
#else
SYS_INT_PrioritySet(src, intPri);
SYS_INT_SubprioritySet(src, intSubPri);
SYS_INT_DynamicRegister(src, LAN8740WOLIsr, (void*)&hClientObj);
#endif
SYS_INT_SourceEnable(src);
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGEnable();
SYS_PORTS_Initialize();
sysObj.sysDma = SYS_DMA_Initialize((SYS_MODULE_INIT *)&sysDmaInit);
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
sysObj.drvTmr0 = DRV_TMR_Initialize(DRV_TMR_INDEX_0, (SYS_MODULE_INIT *)&drvTmr0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_T3, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T3, INT_SUBPRIORITY_LEVEL0);
/*** SPI Driver Index 0 initialization***/
sysObj.spiObjectIdx0 = DRV_SPI_Initialize(DRV_SPI_INDEX_0, (const SYS_MODULE_INIT * const)&drvSpi0InitData);
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
LEDSCROLLER_Initialize();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
/* Initialize Drivers */
sysObj.drvUsart0 = DRV_USART_Initialize(DRV_USART_INDEX_0, (SYS_MODULE_INIT *)&drvUsart0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_UART1, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_UART1, INT_SUBPRIORITY_LEVEL0);
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Initialize the Application */
APP_Initialize();
}
void APP_Initialize(void) {
#ifdef PRE_APP_INIT_HOOK
PRE_APP_INIT_HOOK();
#endif
// We can do this after USB_DEVICE_Initialize() has been called since it's
// not used until we reach the tasks function.
UIDStore_AsUnicodeString(USBDescriptor_UnicodeUID());
CoarseTimer_Settings timer_settings = {
.timer_id = AS_TIMER_ID(COARSE_TIMER_ID),
.interrupt_source = AS_TIMER_INTERRUPT_SOURCE(COARSE_TIMER_ID)
};
SYS_INT_VectorPrioritySet(AS_TIMER_INTERRUPT_VECTOR(COARSE_TIMER_ID),
INT_PRIORITY_LEVEL6);
CoarseTimer_Initialize(&timer_settings);
// Initialize the Logging system, bottom up
USBTransport_Initialize(NULL);
USBConsole_Initialize();
SysLog_Initialize(NULL);
// Initialize the DMX / RDM Transceiver
TransceiverHardwareSettings transceiver_settings = {
.usart = AS_USART_ID(TRANSCEIVER_UART),
.usart_vector = AS_USART_INTERRUPT_VECTOR(TRANSCEIVER_UART),
.usart_tx_source = AS_USART_INTERRUPT_TX_SOURCE(TRANSCEIVER_UART),
.usart_rx_source = AS_USART_INTERRUPT_RX_SOURCE(TRANSCEIVER_UART),
.usart_error_source = AS_USART_INTERRUPT_ERROR_SOURCE(TRANSCEIVER_UART),
.port = TRANSCEIVER_PORT,
.break_bit = TRANSCEIVER_PORT_BIT,
.tx_enable_bit = TRANSCEIVER_TX_ENABLE_PORT_BIT,
.rx_enable_bit = TRANSCEIVER_RX_ENABLE_PORT_BIT,
.input_capture_module = AS_IC_ID(TRANSCEIVER_IC),
.input_capture_vector = AS_IC_INTERRUPT_VECTOR(TRANSCEIVER_IC),
.input_capture_source = AS_IC_INTERRUPT_SOURCE(TRANSCEIVER_IC),
.timer_module_id = AS_TIMER_ID(TRANSCEIVER_TIMER),
.timer_vector = AS_TIMER_INTERRUPT_VECTOR(TRANSCEIVER_TIMER),
.timer_source = AS_TIMER_INTERRUPT_SOURCE(TRANSCEIVER_TIMER),
.input_capture_timer = AS_IC_TMR_ID(TRANSCEIVER_TIMER),
};
Transceiver_Initialize(&transceiver_settings, NULL, NULL);
// Base RDM Responder
RDMResponderSettings responder_settings = {
.identify_port = RDM_RESPONDER_IDENTIFY_PORT,
.identify_bit = RDM_RESPONDER_IDENTIFY_PORT_BIT,
.mute_port = RDM_RESPONDER_MUTE_PORT,
.mute_bit = RDM_RESPONDER_MUTE_PORT_BIT,
};
memcpy(responder_settings.uid, UIDStore_GetUID(), UID_LENGTH);
RDMResponder_Initialize(&responder_settings);
ReceiverCounters_ResetCounters();
// RDM Handler
RDMHandlerSettings rdm_handler_settings = {
.default_model = LED_MODEL_ID,
.send_callback = NULL
};
RDMHandler_Initialize(&rdm_handler_settings);
// Initialize RDM Models, keep these in Model ID order.
LEDModel_Initialize();
RDMHandler_AddModel(&LED_MODEL_ENTRY);
ProxyModel_Initialize();
RDMHandler_AddModel(&PROXY_MODEL_ENTRY);
MovingLightModel_Initialize();
RDMHandler_AddModel(&MOVING_LIGHT_MODEL_ENTRY);
SensorModel_Initialize();
RDMHandler_AddModel(&SENSOR_MODEL_ENTRY);
NetworkModel_Initialize();
RDMHandler_AddModel(&NETWORK_MODEL_ENTRY);
DimmerModel_Initialize();
RDMHandler_AddModel(&DIMMER_MODEL_ENTRY);
// Initialize the Host message layers.
MessageHandler_Initialize(NULL);
StreamDecoder_Initialize(NULL);
Flags_Initialize();
// SPI DMX Output
SPIRGBConfiguration spi_config;
spi_config.module_id = SPI_MODULE_ID;
spi_config.baud_rate = SPI_BAUD_RATE;
spi_config.use_enhanced_buffering = SPI_USE_ENHANCED_BUFFERING;
SPIRGB_Init(&spi_config);
// Send a frame with all pixels set to 0.
SPIRGB_BeginUpdate();
SPIRGB_CompleteUpdate();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGEnable();
SYS_PORTS_Initialize();
/* Board Support Package Initialization */
BSP_Initialize();
/* System Services Initialization */
SYS_INT_Initialize();
/* Initialize Drivers */
sysObj.drvTmr0 = DRV_TMR_Initialize(DRV_TMR_INDEX_0, (SYS_MODULE_INIT *)&drvTmr0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_T2, INT_PRIORITY_LEVEL4);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T2, INT_SUBPRIORITY_LEVEL0);
/* Configure the Flash Controller Interrupt Priority */
SYS_INT_VectorPrioritySet(INT_VECTOR_FCE, INT_PRIORITY_LEVEL4);
/* Configure the Flash Controller Interrupt Sub Priority */
SYS_INT_VectorSubprioritySet(INT_VECTOR_FCE, INT_SUBPRIORITY_LEVEL1);
/* Initialize the NVM Driver */
sysObj.drvNvm = DRV_NVM_Initialize(DRV_NVM_INDEX_0, (SYS_MODULE_INIT *)&drvNvmInit);
/* Initialize the NVM Media Driver Layer */
sysObj.drvNvmMedia = DRV_NVM_MEDIA_Initialize(DRV_NVM_MEDIA_INDEX_0,(SYS_MODULE_INIT *)&drvNvmMediaInit);
/* Initialize System Services */
sysObj.sysConsole0 = SYS_CONSOLE_Initialize(SYS_CONSOLE_INDEX_0, (SYS_MODULE_INIT *)&consUsbInit);
sysObj.sysDebug = SYS_DEBUG_Initialize(SYS_DEBUG_INDEX_0, (SYS_MODULE_INIT*)&debugInit);
/*** TMR Service Initialization Code ***/
sysObj.sysTmr = SYS_TMR_Initialize(SYS_TMR_INDEX_0, (const SYS_MODULE_INIT * const)&sysTmrInitData);
SYS_CMD_Initialize();
SYS_FS_Initialize( (const void *) sysFSInit );
SYS_RANDOM_Initialize(0, 0);
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL1);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* set priority for ETHERNET interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_ETH, INT_PRIORITY_LEVEL5);
/* set sub-priority for ETHERNET interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_ETH, INT_SUBPRIORITY_LEVEL0);
/* TCPIP Stack Initialization */
sysObj.tcpip = TCPIP_STACK_Init();
if (sysObj.tcpip == SYS_MODULE_OBJ_INVALID)
{
return;
}
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
APP_Initialize();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_PORTS_Initialize();
/* Board Support Package Initialization */
BSP_Initialize();
/* Initialize Drivers */
sysObj.drvTmr0 = DRV_TMR_Initialize(DRV_TMR_INDEX_0, (SYS_MODULE_INIT *)&drvTmr0InitData);
SYS_INT_VectorPrioritySet(INT_VECTOR_T1, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T1, INT_SUBPRIORITY_LEVEL0);
/* Initialize USB Driver */
sysObj.drvUSBObject = DRV_USBHS_Initialize(DRV_USBHS_INDEX_0, (SYS_MODULE_INIT *) &drvUSBInit);
/* Initialize System Services */
/*** Command Service Initialization Code ***/
SYS_CMD_Initialize((SYS_MODULE_INIT*)&sysCmdInit);
sysObj.sysConsole0 = SYS_CONSOLE_Initialize(SYS_CONSOLE_INDEX_0, (SYS_MODULE_INIT *)&consUsbInit0);
/*** Debug Service Initialization Code ***/
sysObj.sysDebug = SYS_DEBUG_Initialize(SYS_DEBUG_INDEX_0, (SYS_MODULE_INIT*)&debugInit);
/*** Interrupt Service Initialization Code ***/
SYS_INT_Initialize();
/*** Random Service Initialization Code ***/
SYS_RANDOM_Initialize(0, 0);
/*** TMR Service Initialization Code ***/
sysObj.sysTmr = SYS_TMR_Initialize(SYS_TMR_INDEX_0, (const SYS_MODULE_INIT * const)&sysTmrInitData);
/* Initialize Middleware */
/* set priority for ETHERNET interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_ETH, INT_PRIORITY_LEVEL5);
/* set sub-priority for ETHERNET interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_ETH, INT_SUBPRIORITY_LEVEL3);
/* TCPIP Stack Initialization */
sysObj.tcpip = TCPIP_STACK_Init();
if (sysObj.tcpip == SYS_MODULE_OBJ_INVALID)
{
return;
}
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL1);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Set the priority of the USB DMA Interrupt */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1_DMA, INT_PRIORITY_LEVEL1);
/* Set Sub-priority of the USB DMA Interrupt */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1_DMA, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* Enable Global Interrupts */
SYS_INT_Enable();
/* Initialize the Application */
APP_Initialize();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
/* Initialize Drivers */
// DRV_SPI0_Initialize();
// DRV_SPI1_Initialize();
//DRV_I2C1_Initialize();
SYS_INT_VectorPrioritySet(INT_VECTOR_T2, INT_PRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_T2, INT_SUBPRIORITY_LEVEL0);
/*Initialize CAN0 */
DRV_CAN0_Initialize();
//For Debugging
// SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_G, PORTS_BIT_POS_8);
// SYS_PORTS_PinClear(PORTS_ID_0, PORT_CHANNEL_G, PORTS_BIT_POS_8);
// SYS_PORTS_PinDirectionSelect(PORTS_ID_0, SYS_PORTS_DIRECTION_OUTPUT, PORT_CHANNEL_E, PORTS_BIT_POS_8);
// SYS_PORTS_PinClear(PORTS_ID_0, PORT_CHANNEL_E, PORTS_BIT_POS_8);
/* Indicate initializing */
led_on(LED_RED);
/* Initialize PMP0 */
DRV_PMP0_Initialize();
DRV_PMP0_ModeConfig();
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Set priority of USB interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_USB1, INT_PRIORITY_LEVEL4);
/* Wait FPGA_DONE*/
// while(!FpgaDone);
/* Set Sub-priority of USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB1, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB device layer */
sysObj.usbDevObject0 = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 , ( SYS_MODULE_INIT* ) & usbDevInitData);
/* Enable Global Interrupts */
SYS_INT_Enable();
#ifdef DEBUG_PERCEPIO
/* Initialize Percepio */
vTraceInitTraceData();
if(uiTraceStart() != 1) {
while(true);
}
#endif
/* Initialize the Application */
APP_Initialize();
APP1_Initialize();
APP2_Initialize();
Xcp_Initialize();
}
void SYS_Initialize ( void* data )
{
/* Core Processor Initialization */
SYS_CLK_Initialize( NULL );
sysObj.sysDevcon = SYS_DEVCON_Initialize(SYS_DEVCON_INDEX_0, (SYS_MODULE_INIT*)&sysDevconInit);
SYS_DEVCON_PerformanceConfig(SYS_CLK_SystemFrequencyGet());
SYS_DEVCON_JTAGDisable();
SYS_PORTS_Initialize();
#ifdef DEBUG_ON
setDebugVal(SYS_INIT_START); // has to be after ports init
#endif
/* Initialize Drivers */
/*Initialize TMR0 */
DRV_TMR0_Initialize();
DRV_USART0_Initialize();
DRV_USART1_Initialize();
#ifdef DEBUG_ON
setDebugVal(SYS_INIT_UART);
#endif
/*Initialize OC0 */
DRV_OC0_Initialize();
/*Initialize OC1 */
DRV_OC1_Initialize();
/* Initialize System Services */
SYS_INT_Initialize();
#ifdef DEBUG_ON
setDebugVal(SYS_INIT_SYS);
#endif
/*Setup the INT_SOURCE_EXTERNAL_2 and Enable it*/
SYS_INT_VectorPrioritySet(INT_VECTOR_INT2, INT_PRIORITY_LEVEL3);
SYS_INT_VectorSubprioritySet(INT_VECTOR_INT2, INT_SUBPRIORITY_LEVEL0);
SYS_INT_ExternalInterruptTriggerSet(INT_EXTERNAL_INT_SOURCE2,INT_EDGE_TRIGGER_RISING);
SYS_INT_SourceEnable(INT_SOURCE_EXTERNAL_2);
/*Setup the INT_SOURCE_EXTERNAL_1 and Enable it*/
SYS_INT_VectorPrioritySet(INT_VECTOR_INT1, INT_PRIORITY_LEVEL3);
SYS_INT_VectorSubprioritySet(INT_VECTOR_INT1, INT_SUBPRIORITY_LEVEL0);
SYS_INT_ExternalInterruptTriggerSet(INT_EXTERNAL_INT_SOURCE1,INT_EDGE_TRIGGER_RISING);
SYS_INT_SourceEnable(INT_SOURCE_EXTERNAL_1);
/*Setup the INT_SOURCE_EXTERNAL_3 and Enable it*/
SYS_INT_VectorPrioritySet(INT_VECTOR_INT3, INT_PRIORITY_LEVEL3);
SYS_INT_VectorSubprioritySet(INT_VECTOR_INT3, INT_SUBPRIORITY_LEVEL0);
SYS_INT_ExternalInterruptTriggerSet(INT_EXTERNAL_INT_SOURCE3,INT_EDGE_TRIGGER_RISING);
SYS_INT_SourceEnable(INT_SOURCE_EXTERNAL_3);
/* Initialize Middleware */
/* Initialize the Application */
MOTORAPP_Initialize();
#ifdef DEBUG_ON
setDebugVal(SYS_INIT_APP);
#endif
UART_TX_APP_Initialize();
#ifdef DEBUG_ON
setDebugVal(SYS_INIT_UART_TX_APP);
#endif
UART_RX_APP_Initialize();
#ifdef DEBUG_ON
setDebugVal(SYS_INIT_UART_RX_APP);
#endif
}
void SYS_Initialize ( void* data )
{
unsigned int cache_status;
/* enable cache */
// cache_status = CHECON;
// cache_status |= (3 << _CHECON_PREFEN_POSITION);
// CHECON = cache_status;
// CheKseg0CacheOn();
SYSTEMConfigPerformance(80000000);
/* Initialize the BSP */
BSP_Initialize( );
//TODO
/* Create the USB Driver Initialization
* data structure */
usbInitData.usbID = USB_ID_1;
usbInitData.operationMode = USB_OPMODE_HOST;
usbInitData.stopInIdle = false;
usbInitData.suspendInSleep = false;
usbInitData.interruptSource = INT_SOURCE_USB_1;
SYS_INT_VectorPrioritySet( INT_VECTOR_USB, INT_PRIORITY_LEVEL4);
// SYS_INT_PrioritySet( INT_VECTOR_T3, INT_PRIORITY_LEVEL5);
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL0);
/* Initialize the USB Host controller driver */
USBHostdemoappDrvObject.usbHCObject = DRV_USB_Initialize (DRV_USB_INDEX_0 ,
( SYS_MODULE_INIT* ) &usbInitData);
/* check if the object returned by the controller driver is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != USBHostdemoappDrvObject.usbHCObject), "Invalid USB HC object");
/* Initialize the USB host layer */
USBHostdemoappDrvObject.usbHostObject = USB_HOST_Initialize (USB_HOST_INDEX_0 ,
( SYS_MODULE_INIT *)& usbHostInitData );
/* check if the object returned by the device layer is valid */
// SYS_ASSERT((SYS_MODULE_OBJ_INVALID != appDrvObject.usbHostObject), "Invalid USB HOST object");
// /* open an instance of the device layer */
// USBHostdemoappDrvObject.usbHostCDCHandle = USB_HOST_CDC_Open( USB_HOST_INDEX_0 );
// /* Register a callback with device layer to get event notification (for end point 0) */
// USB_DEVICE_EventCallBackSet(appData.usbDevHandle, APP_UsbDeviceEventCallBack);
/* Initialize the Application */
APP_Initialize ( );
// /* /* Initializethe interrupt system */
SYS_INT_Initialize();
// /* set priority for USB interrupt source */
SYS_INT_VectorPrioritySet(INT_SOURCE_USB_1, INT_PRIORITY_LEVEL3);
// /* set sub-priority for USB interrupt source */
SYS_INT_VectorSubprioritySet(INT_SOURCE_USB_1, INT_SUBPRIORITY_LEVEL3);
// /* Initialize the global interrupts */
SYS_INT_Enable();
}
/*******************************************************************************
Function:
void SYS_Initialize ( void *data )
Summary:
Initializes the board, services, drivers, application and other modules
Description:
This routine initializes the board, services, drivers, application and other
modules as configured at build time. In a bare-metal environment (where no
OS is supported), this routine should be called almost immediately after
entering the "main" routine.
Precondition:
The C-language run-time environment and stack must have been initialized.
Parameters:
data - Pointer to the system initialzation data structure containing
pointers to the board, system service, and driver
initialization routines
Returns:
None.
Example:
<code>
SYS_INT_Initialize(NULL);
</code>
Remarks:
Basic System Initialization Sequence:
1. Initilize minimal board services and processor-specific items
(enough to use the board to initialize drivers and services)
2. Initialize all supported system services
3. Initialize all supported modules
(libraries, drivers, middleware, and application-level modules)
4. Initialize the main (static) application, if present.
The order in which services and modules are initialized and started may be
important.
For a static system (a system not using the ISP's dynamic implementation
of the initialization and "Tasks" services) this routine is implemented
for the specific configuration of an application.
*/
void SYS_Initialize(void* data)
{
BSP_Initialize();
// cache configuration
cache_enable(0);
SetPic32MZIoPins();
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* Remap the SPI pins */
PLIB_PORTS_RemapOutput(PORTS_ID_0, OTPUT_FUNC_SDO2, OUTPUT_PIN_RPG8);
PLIB_PORTS_RemapInput(PORTS_ID_0, INPUT_FUNC_SDI2, INPUT_PIN_RPD7);
/* set priority for SPI interrupt source */
SYS_INT_VectorPrioritySet(INT_VECTOR_SPI2_TX, INT_PRIORITY_LEVEL3);
SYS_INT_VectorPrioritySet(INT_VECTOR_SPI2_RX, INT_PRIORITY_LEVEL3);
/* set sub-priority for SPI interrupt source */
SYS_INT_VectorSubprioritySet(INT_VECTOR_SPI2_TX, INT_SUBPRIORITY_LEVEL1);
SYS_INT_VectorSubprioritySet(INT_VECTOR_SPI2_RX, INT_SUBPRIORITY_LEVEL1);
clkObject.systemClock = 200000000L;
//Turn ON the system clock
if(!SYS_TICK_Initialize(clkObject.systemClock, SYS_TICKS_PER_SECOND))
{
return;
}
SYS_INT_Enable();
/* Initialize the clock system service. This is used
* by the SPI Driver. */
clkObject.MZperipheralClock[2] = 100000000L;
clkObject.peripheralClock = 100000000L;
/* Initialize the SPI driver */
appDrvObjects.drvSPIObject = DRV_SPI_Initialize(DRV_SPI_INDEX_0,
(SYS_MODULE_INIT *)&drvSPIInit);
/* Initialize the SDCARD driver*/
appDrvObjects.drvSDCARDObject = DRV_SDCARD_Initialize(DRV_SDCARD_INDEX_0,
(SYS_MODULE_INIT *)&drvSDCARDInit);
/* Initialize the SYS_FS Layer */
SYS_FS_Initialize( (const void *) sysFATFSInit );
if(!_SYS_DEBUG_INIT(SYS_DEBUG_PORT))
{
return;
}
if(!_SYS_CONSOLE_INIT(SYS_CONSOLE_PORT))
{
return;
}
if(!_SYS_RANDOM_INIT())
{
return;
}
if (!_SYS_COMMAND_INIT())
{
return;
}
if (!SYS_USERIO_Initialize(0))
{
return;
}
// TCP/IP stack initialization
SYS_OUT_MESSAGE("TCPStack " TCPIP_STACK_VERSION " "" ");
// Initialize the TCPIP stack
if (!TCPIP_STACK_Init())
{
return;
}
APP_Initialize();
return;
} //SYS_Initialize
