/*****
* do_init() - initialize the system
*
* This function is executed once at start-up and after a reset. It initializes
* the peripherals and registers the interrupt handlers
*****/
XStatus do_init(void) {
XStatus Status; // status from Xilinx Lib calls
// initialize the N3EIF driver
// rotary encoder is set to increment from 0 by 1
// NOTE: it's the relative change from the last time the rotary encoder was sampled
// not the absolute change that matters. The actual change is handled in main() so we
// can apply a "speedup" factor if the knob is being turned quickly.
N3EIF_init(N3EIF_BASEADDR);
ROT_init(1, false);
ROT_clear();
// initialize the GPIO instance
Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// GPIO channel 1 is an 8-bit output port that your application can
// use. None of the bits are used by this program
XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xF0);
XGpio_DiscreteWrite(&GPIOInst, GPIO_OUTPUT_CHANNEL, gpio_port);
// initialize the PWM timer/counter instance but do not start it
// do not enable PWM interrupts
Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// initialize the PmodCtlSys
Status = PmodCtlSys_init(&SPIInst, SPI_DEVICEID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// initialize the interrupt controller
Status = XIntc_Initialize(&IntrptCtlrInst, INTC_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// connect the fixed interval timer (FIT) handler to the interrupt
Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID,
(XInterruptHandler) FIT_Handler, (void *) 0);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// start the interrupt controller such that interrupts are enabled for
// all devices that cause interrupts, specifically real mode so that
// the the FIT can cause interrupts thru the interrupt controller.
Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// enable the FIT interrupt
XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID);
return XST_SUCCESS;
}
/*****
* do_init() - initialize the system
*
* This function is executed once at start-up and after resets. It initializes
* the peripherals and registers the interrupt handlers
*****/
XStatus do_init(void)
{
XStatus Status; // status from Xilinx Lib calls
// initialize the S3E starter board interface
// rotary encoder is set to increment from 0 by DUTY_CYCLE_CHANGE
N3EIF_init(N3EIF_BASEADDR);
ROT_init(DUTY_CYCLE_CHANGE, true);
ROT_clear();
// initialize the GPIO instance
Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// GPIO channel 1 is an 8-bit input port. bit[7:1] = reserved, bit[0] = PWM output (for duty cycle calculation)
// GPIO channel 2 is an 8-bit output port. bit[7:1] = reserved, bit[0] = FIT clock
XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xFE);
// initialize the PWM timer/counter instance but do not start it
// do not enable PWM interrupts
Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// initialize the interrupt controller
Status = XIntc_Initialize(&IntrptCtlrInst,INTC_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// connect the fixed interval timer (FIT) handler to the interrupt
Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID,
(XInterruptHandler)FIT_Handler,
(void *)0);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// start the interrupt controller such that interrupts are enabled for
// all devices that cause interrupts.
Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// enable the FIT interrupt
XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID);
return XST_SUCCESS;
}
static void initialize()
{
CLOCK_StopTimer();
if (PPMin_Mode())
return;
PWM_Initialize();
num_channels = Model.num_channels;
if (Model.proto_opts[CENTER_PW] == 0) {
Model.proto_opts[CENTER_PW] = 1100;
Model.proto_opts[DELTA_PW] = 400;
Model.proto_opts[NOTCH_PW] = 400;
Model.proto_opts[PERIOD_PW] = 22500;
}
CLOCK_StartTimer(1000, ppmout_cb);
}
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 ADC */
DRV_ADC_Initialize();
/*Initialize TMR0 */
DRV_TMR0_Initialize();
DRV_USART0_Initialize();
/*Initialize OC0 */
DRV_OC0_Initialize();
/*Initialize OC1 */
DRV_OC1_Initialize();
/*Initialize OC2 */
DRV_OC2_Initialize();
/*Initialize OC3 */
DRV_OC3_Initialize();
/* Initialize System Services */
SYS_INT_Initialize();
/* Initialize Middleware */
/* Initialize the Application */
PWM_Initialize();
}
int do_init(void) {
int status; // status from Xilinx Lib calls
// initialize the Nexys4IO and Pmod544IO hardware and drivers
// rotary encoder is set to increment from 0 by DUTY_CYCLE_CHANGE
status = NX4IO_initialize(NX4IO_BASEADDR);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
status = PMDIO_initialize(PMDIO_BASEADDR);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
// successful initialization. Set the rotary encoder
// to increment from 0 by DUTY_CYCLE_CHANGE counts per rotation
PMDIO_ROT_init(DUTY_CYCLE_CHANGE, true);
PMDIO_ROT_clear();
// initialize the GPIO instances
status = XGpio_Initialize(&GPIOInst0, GPIO_0_DEVICE_ID);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
status = XGpio_Initialize(&GPIOInst1, GPIO_1_DEVICE_ID);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
// GPIO_0 channel 1 is an 8-bit input port. bit[7:1] = reserved, bit[0] = PWM output (for duty cycle calculation)
// GPIO_0 channel 2 is an 8-bit output port. bit[7:1] = reserved, bit[0] = FIT clock
XGpio_SetDataDirection(&GPIOInst0, GPIO_0_INPUT_CHANNEL, 0xFF);
XGpio_SetDataDirection(&GPIOInst0, GPIO_0_OUTPUT_CHANNEL, 0xFE);
// GPIO_1 channel 1 is a 32-bit input port - used to pass hw_detect 'high' count to application
// GPIO_1 channel 2 is an 8-bit output port - used to pass hw_detect 'low' count to application
XGpio_SetDataDirection(&GPIOInst1, GPIO_1_HIGH_COUNT, 0xFFFFFFFF);
XGpio_SetDataDirection(&GPIOInst1, GPIO_1_LOW_COUNT, 0xFFFFFFFF);
// initialize the PWM timer/counter instance but do not start it
// do not enable PWM interrupts. Clock frequency is the AXI clock frequency
status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false, AXI_CLOCK_FREQ_HZ);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
// initialize the interrupt controller
status = XIntc_Initialize(&IntrptCtlrInst, INTC_DEVICE_ID);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
// connect the fixed interval timer (FIT) handler to the interrupt
status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID, (XInterruptHandler)FIT_Handler, (void *)0);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
// start the interrupt controller such that interrupts are enabled for
// all devices that cause interrupts
status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
// enable the FIT interrupt
XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID);
// set the duty cycles for RGB1. The channels will be enabled/disabled
// in the FIT interrupt handler. Red and Blue make purple
NX4IO_RGBLED_setDutyCycle(RGB1, 64, 0, 64);
NX4IO_RGBLED_setChnlEn(RGB1, false, false, false);
return XST_SUCCESS;
}
/*****
* do_init() - initialize the system
*
* This function is executed once at start-up and after a reset. It initializes
* the peripherals and registers the interrupt handlers
*****/
XStatus do_init(void)
{
XStatus Status; // status from Xilinx Lib calls
// initialize the N3EIF hardware and driver
// rotary encoder is set to increment duty cycle from 0 by 5 w/
// no negative counts
N3EIF_init(N3EIF_BASEADDR);
ROT_init(DUTY_CYCLE_CHANGE, true);
ROT_clear();
// initialize the GPIO instance
Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// GPIO channel 1 is an 8-bit output port that your application can
// use. None of the bits are used by this program
XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xF0);
XGpio_DiscreteWrite(&GPIOInst, GPIO_OUTPUT_CHANNEL, gpio_port);
// initialize the PWM timer/counter instance but do not start it
// do not enable PWM interrupts
Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
//Initialize LIGHTSENSOR peripheral
Status = LIGHTSENSOR_Init(LIGHTSENSOR_BASEADDR);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// initialize the interrupt controller
Status = XIntc_Initialize(&IntrptCtlrInst,INTC_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// connect the fixed interval timer (FIT) handler to the interrupt
Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID,
(XInterruptHandler)FIT_Handler,
(void *)0);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// start the interrupt controller such that interrupts are enabled for
// all devices that cause interrupts, specifically real mode so that
// the the FIT can cause interrupts thru the interrupt controller.
Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// start the lightsensor
Status = LIGHTSENSOR_Start(LIGHTSENSOR_BASEADDR);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// enable the FIT interrupt
XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID);
return XST_SUCCESS;
}
void ApplicationEntryPoint()
{
#if defined(TEST_DAC)
UINT32 FramesNum = g_LPC24XX_DAC_Driver.GetBufferFrameCapacity();
if (DAC_FRAME_BUFFERS_NUM!=FramesNum)
{
debug_printf( "Error, BufferFrameCapacity != DAC_FRAME_BUFFERS_NUM: %d != %d.\r\n", FramesNum, DAC_FRAME_BUFFERS_NUM );
}
UINT32 nextInFrameOffset=0;
UINT16 frameLength = MAX_DECODED_FRAME_SIZE/2;
short* frameSignedStart = NULL;
LPC24XX_VIC& VIC = LPC24XX::VIC();
/*debug_printf("VIC INTRSEL = 0x%08x\r\n", VIC.INTRSEL);
VIC.INTRSEL |= 1 << LPC24XX_TIMER::getIntNo(LPC24XX_DAC::Timer);
debug_printf("new VIC INTRSEL = 0x%08x\r\n", VIC.INTRSEL);*/
VIC.VECTPRIORITY[LPC24XX_TIMER::getIntNo(LPC24XX_DAC::Timer)] = 0;
for(int i= 0; i< 32; i++)
{
debug_printf("PRIO INTR%02d = %d \r\n", i,VIC.VECTPRIORITY[i]);
}
debug_printf( "Init DAC, 8kHz output.\r\n" );
g_LPC24XX_DAC_Driver.Initialize(OUT_FREQ);
debug_printf( "BUFFER PRE-FILL TEST.\r\n" );
debug_printf( "Adding frames to the DAC driver buffer: " );
debug_printf("total frames to be added = %d\r\n", TEST_SAMPLES_NUM/MAX_DECODED_FRAME_SIZE-CUTOUT);
debug_printf("DAC frame buffers available = %d\r\n", DAC_FRAME_BUFFERS_NUM);
if(DAC_FRAME_BUFFERS_NUM<(TEST_SAMPLES_NUM/MAX_DECODED_FRAME_SIZE-CUTOUT))
debug_printf("ONLY THE FIRST %d FRAMES OF THE SAMPLE WILL BE PLAYED.\r\n", DAC_FRAME_BUFFERS_NUM);
while(nextInFrameOffset+(MAX_DECODED_FRAME_SIZE*CUTOUT) < TEST_SAMPLES_NUM)
{
//if(i%(1024*256)) continue;
frameSignedStart = (short*)(bin_data+nextInFrameOffset);
if(g_LPC24XX_DAC_Driver.AddFrame(frameSignedStart, frameLength))
{
debug_printf( " done.\r\n" );
nextInFrameOffset+=MAX_DECODED_FRAME_SIZE;
}
else
{
debug_printf( "Buffer full, starting playout.\r\n");
break;
}
}
resetDACISRTiming();
debug_printf( "DAC.On() in 2 seconds\r\n");
Events_WaitForEvents( 0, 2000 );
if(!hijackISRs())
return;
if(g_LPC24XX_DAC_Driver.On())
{
//debug_printf( "Done. 2sec wait.\r\n" ); don't output to avoid adding serial activity during the test
}
else
{
debug_printf( "FAILED.\r\n" );
}
while(g_LPC24XX_DAC_Driver.GetBufferLevel()>0)
{
//debug_printf("Samples left: %d\r\n", g_LPC24XX_DAC_Driver.GetBufferLevel());
//debug_printf("Frames left: %d\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft());
}
//stop logging interrupts before starting to output again
int finalIrqCount = irq_count;
irq_count = 8192;
Events_WaitForEvents( 0, 5000 );
if(!restoreISRs())
return;
debug_printf("%d frames left.\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft());
debug_printf("Final IRQ count = %u\r\n", finalIrqCount);
debug_printf( "BUFFER PRE-FILL TEST OVER.\r\n");
displayRunTestResults();
debug_printf("CSV DATA OUTPUT FOLLOWS\r\n");
//csvRunTestResults();
debug_printf("\r\nPARALLEL BUFFER FILL TEST\r\n" );
Events_WaitForEvents( 0, 3000 );
debug_printf( "DAC.Off()\r\n");
if(g_LPC24XX_DAC_Driver.Off())
{
debug_printf( "Done.\r\n" );
}
else
{
debug_printf( "FAILED.\r\n" );
}
debug_printf( "Uninit DAC\r\n");
g_LPC24XX_DAC_Driver.Uninitialize();
debug_printf( "Done.\r\n");
debug_printf( "Init DAC, 8kHz output.\r\n" );
g_LPC24XX_DAC_Driver.Initialize(OUT_FREQ);
resetDACISRTiming();
debug_printf( "DAC.On() in 2 seconds\r\n");
Events_WaitForEvents( 0, 2000 );
if(g_LPC24XX_DAC_Driver.On())
{
//debug_printf( "Done.\r\n" );
}
else
{
debug_printf( "FAILED.\r\n" );
}
debug_printf( "Adding frames to the DAC driver buffer: " );
nextInFrameOffset=0;
debug_printf("total frames to be added = %d\r\n", TEST_SAMPLES_NUM/MAX_DECODED_FRAME_SIZE-CUTOUT);
//FILL JUST ONCE
while(nextInFrameOffset+(MAX_DECODED_FRAME_SIZE*CUTOUT) < TEST_SAMPLES_NUM)
{
//if(i%(1024*256)) continue;
frameSignedStart = (short*)(bin_data+nextInFrameOffset);
if(g_LPC24XX_DAC_Driver.AddFrame(frameSignedStart, frameLength))
{
debug_printf( " done.\r\n" );
nextInFrameOffset+=MAX_DECODED_FRAME_SIZE;
}
else
{
//debug_printf( "FAIL.\r\n");
}
}
while(g_LPC24XX_DAC_Driver.GetBufferLevel()>0)
{
//debug_printf("Samples left: %d\r\n", g_LPC24XX_DAC_Driver.GetBufferLevel());
//debug_printf("Frames left: %d\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft());
}
Events_WaitForEvents( 0, 3000 );
displayRunTestResults();
debug_printf("CSV DATA OUTPUT FOLLOWS\r\n");
csvRunTestResults();
/*CONTINUOUS REFILL with samples
while(true)
{
//if(i%(1024*256)) continue;
frameSignedStart = (short*)(bin_data+nextInFrameOffset);
if(g_LPC24XX_DAC_Driver.AddFrame(frameSignedStart, frameLength))
{
//debug_printf( " done.\r\n" );
nextInFrameOffset+=MAX_DECODED_FRAME_SIZE;
if(nextInFrameOffset+(MAX_DECODED_FRAME_SIZE*CUTOUT)>=TEST_SAMPLES_NUM)
nextInFrameOffset = 0;
}
else
{
//debug_printf( "FAIL.\r\n");
}
debug_printf("Samples left: %d\r\n", g_LPC24XX_DAC_Driver.GetBufferLevel());
debug_printf("Frames left: %d\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft());
}*///end continuous refill
debug_printf("%d frames left.\r\n", g_LPC24XX_DAC_Driver.GetFramesLeft());
debug_printf( "PARALLEL BUFFER FILL TEST OVER.\r\n\r\n" );
//Events_WaitForEvents( 0, 10000 );
debug_printf( "DAC.Off()\r\n");
if(g_LPC24XX_DAC_Driver.Off())
{
debug_printf( "Done.\r\n" );
}
else
{
debug_printf( "FAILED.\r\n" );
}
debug_printf( "Uninit DAC()\r\n");
g_LPC24XX_DAC_Driver.Uninitialize();
debug_printf( "Done.\r\n");
#endif
#if defined(TEST_JOYSTICK)
extern LPC24XX_GPIO_Driver g_LPC24XX_GPIO_Driver;
wait_joystick = true;
for(UINT32 pin = LPC24XX_GPIO::c_P2_22; pin < LPC24XX_GPIO::c_P2_28; pin++)
{
if(pin == LPC24XX_GPIO::c_P2_24)
continue;
if(!g_LPC24XX_GPIO_Driver.EnableInputPin( pin, false, joystickISR, NULL, GPIO_INT_EDGE_HIGH, (GPIO_RESISTOR)2 ))
{
debug_printf("Cannot enable pin %u as INPUT pin.\r\n", pin);
exit(1);
}
debug_printf("Enabled pin %u as INPUT pin.\r\n", pin);
}
while(wait_joystick) {};
#endif
#if defined(TEST_SST39WF)
while(1)
{
lcd_printf ( "Hello, world from the LCD!\r\n" );
hal_printf ( "Hello, world from the HAL!\r\n" );
debug_printf( "Hello, world from the debug intf!\r\n" );
if(BlockStorageList::GetNumDevices() != 1)
{
debug_printf( "%d Block Devices present!\r\n", BlockStorageList::GetNumDevices() );
break;
}
BlockStorageDevice* SST = BlockStorageList::GetFirstDevice();
if(SST == NULL)
{
debug_printf( "GetFirstDevice failed.\r\n" );
break;
}
const BlockDeviceInfo* SSTInfo = SST->GetDeviceInfo();
if(SSTInfo == NULL)
{
debug_printf( "GetDeviceInfo failed.\r\n" );
break;
}
debug_printf( "NumRegions in BSDevice: %d\r\n", SSTInfo->NumRegions);
ByteAddress PhyAddress = (ByteAddress) 0xC0FFEEEE;
SectorAddress SectAddress = 0xC0FFEEEE;
UINT32 RangeIndex;
UINT32 RegionIndex;
const BlockRegionInfo *pBlockRegionInfo;
SST->FindForBlockUsage( /*UINT32*/ BlockRange::BLOCKTYPE_DEPLOYMENT ,
PhyAddress , RegionIndex, RangeIndex );
if(PhyAddress == 0xC0FFEEEE)
{
debug_printf( "FindForBlockUsage failed.\r\n" );
break;
}
debug_printf( "Sector 0x%08x physical address: 0x%08x\r\n", SectAddress, PhyAddress);
BYTE pSectorBuf[] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
//ERASE before writing!
if(!SST->IsBlockErased(PhyAddress, 0x1000))
{
debug_printf( "Erasing block " );
if(!SST->EraseBlock(SectAddress))
{
debug_printf( "failed.\r\n" );
break;
}
debug_printf( "successful.\r\n" );
}
if(SST->Write(/*UINT32*/ PhyAddress, /*UINT32 NumOfBytes*/ 16, /*BYTE* */ pSectorBuf, /*SectorMetadata* */ FALSE))
debug_printf( "Correctly written 16 bytes to Sector 0x%08x\r\n", SectAddress);
Events_WaitForEvents( 0, 2000 );
}
#endif //TEST_SST39WF
#if defined(TEST_PWM)
PWM_Initialize(PWM_CHANNEL_0);
// NOTE: on the EA_LPC2478 board the first pin we will return is the 11th pin on the left side from the top of the J1 connector
GPIO_PIN pin = PWM_GetPinForChannel( PWM_CHANNEL_0 );
// from 90% to 2/3, to 50%, to 1/3 to 10%
float dc[5] = { 0.9, 0.666, 0.5, 0.333, 0.1 };
UINT32 period1 = 1000; // 1Kxz
for(UINT32 idx = 0; idx < 5; ++idx)
{
UINT32 duration1 = (UINT32)((float)period1 * dc[idx]);
PWM_ApplyConfiguration( PWM_CHANNEL_0, pin, period1, duration1, FALSE);
PWM_Start ( PWM_CHANNEL_0, pin );
// 2 secs, then change
HAL_Time_Sleep_MicroSeconds_InterruptEnabled(1 * 1000 * 1000);
//Events_WaitForEvents( 0, 2 * 1000);
PWM_Stop ( PWM_CHANNEL_0, pin );
}
// from 10Khz to 1Khz, 50% duty cycle
for(UINT32 period = 10000; period >= 1000; period -= 1000)
{
UINT32 duration = period / 2;
PWM_ApplyConfiguration( PWM_CHANNEL_0, pin, period, duration, FALSE);
PWM_Start ( PWM_CHANNEL_0, pin );
// 2 secs, then change
HAL_Time_Sleep_MicroSeconds_InterruptEnabled(1 * 1000 * 1000);
//Events_WaitForEvents( 0, 2 * 1000);
PWM_Stop ( PWM_CHANNEL_0, pin );
}
PWM_Uninitialize(PWM_CHANNEL_0);
#endif // TEST_PWM
while(1)
{
lcd_printf ( "Hello, world!\r\n" );
hal_printf ( "Hello, world!\r\n" );
debug_printf( "Hello, world!\r\n" );
Events_WaitForEvents( 0, 1000 );
}
}
XStatus init_axi_devices(void) {
int status;
// INITIALIZE : Nexys4IO
status = NX4IO_initialize(XPAR_NEXYS4IO_0_S00_AXI_BASEADDR);
if (status != XST_SUCCESS) return XST_FAILURE;
NX4IO_setLEDs(0x0000FFFF);
// INITIALIZE : PMOD544IO
status = PMDIO_initialize(XPAR_PMOD544IOR2_0_S00_AXI_BASEADDR);
if (status != XST_SUCCESS) return XST_FAILURE;
// SET : Encoder val = 0, increment val = DUTY_CYCLE_CHANGE
NX4IO_setLEDs(0x0000FFFE);
PMDIO_ROT_init(DUTY_CYCLE_INCREMENTS, true);
PMDIO_ROT_clear();
NX4IO_setLEDs(0x0000FFFD);
// This is currently crashing the program =/
// No GPIO for now
// INITIALIZE : Degug signal GPIO (1X 4-bit)
/*status = XGpio_Initialize(&instGPIODebug, XPAR_AXI_GPIO_0_BASEADDR);*/
/*if (status != XST_SUCCESS) return XST_FAILURE;*/
/*NX4IO_setLEDs(0x0000FFFC);*/
/*// SET : Direction of output ports */
/*XGpio_SetDataDirection(&instGPIODebug, 0, 0xFFFFFFF0);*/
/*NX4IO_setLEDs(0x0000FFFB);*/
// INITIALIZE : PWM timer/counter
status = PWM_Initialize(&instPWMTimer, XPAR_AXI_TIMER_0_DEVICE_ID, false, XPAR_CPU_CORE_CLOCK_FREQ_HZ);
if (status != XST_SUCCESS) return XST_FAILURE;
NX4IO_setLEDs(0x0000FFFA);
// INITIALIZE : Interrupt controller
status = XIntc_Initialize(&instIntrCtrl, XPAR_MICROBLAZE_0_AXI_INTC_DEVICE_ID);
if (status != XST_SUCCESS) return XST_FAILURE;
NX4IO_setLEDs(0x0000FFF9);
// SET : GPIO handler to interrupt vector
status = XIntc_Connect(&instIntrCtrl, XPAR_MICROBLAZE_0_AXI_INTC_FIT_TIMER_0_INTERRUPT_INTR,
(XInterruptHandler)FIT_Handler,
(void *)0);
if (status != XST_SUCCESS) return XST_FAILURE;
NX4IO_setLEDs(0x0000FFF8);
// SET : Interrupt controller enabled for all devices
status = XIntc_Start(&instIntrCtrl, XIN_REAL_MODE);
if (status != XST_SUCCESS) return XST_FAILURE;
NX4IO_setLEDs(0x0000FFF7);
// SET : Interrupts enabled
XIntc_Enable(&instIntrCtrl, XPAR_MICROBLAZE_0_AXI_INTC_FIT_TIMER_0_INTERRUPT_INTR);
NX4IO_setLEDs(0x0000FFF6);
// SET : RGB LED duty cycles and disable output
NX4IO_RGBLED_setDutyCycle(RGB1, 64, 0, 64);
NX4IO_RGBLED_setChnlEn(RGB1, false, false, false);
NX4IO_setLEDs(0x0000FFF5);
return XST_SUCCESS;
}
