void initInterrupts(void){
// PS2
alt_up_ps2_dev * ps2_device = alt_up_ps2_open_dev(PS2_NAME);
if(ps2_device == NULL){
printf("can't find PS/2 device\n");
return 1;
}
alt_up_ps2_clear_fifo (ps2_device) ;
alt_irq_register(PS2_IRQ, ps2_device, ps2_isr);
// register the PS/2 interrupt
IOWR_8DIRECT(PS2_BASE,4,1);
// button
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(PUSH_BUTTON_BASE, 0x7);
// enable interrupts for all buttons
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(PUSH_BUTTON_BASE, 0x7);
alt_irq_register(PUSH_BUTTON_IRQ, NULL, button_interrupts_function);
//
//
// frequency analyzer
alt_irq_register(FREQUENCY_ANALYSER_IRQ,(void*)&frequency_value, frequency_interrupt_function);
}
int main(void){
int i; // different values for period
int j; // different values for duty cycles
int k; // different values for background task
for(i=1; i<=14; i+=2){
for(j =1; j<=14; j+=3){
for(k = 10; k<=10000; k*=10){
/* ----Periodic Polling with Timer Interrupt---- */
init(i, j);
#ifdef TIMER_1_BASE
alt_u32 timerPeriod; // 32 bit period used for timer
// calculate timer period for 20 micro seconds
timerPeriod = TIMER_1_FREQ/50000;
// initialize timer interrupt vector
alt_irq_register(TIMER_1_IRQ, (void*)0, timer_ISR);
// initialize timer period
IOWR(TIMER_1_BASE, 2, (alt_u16)timerPeriod);
IOWR(TIMER_1_BASE, 3, (alt_u16)(timerPeriod >> 16));
// clear timer interrupt bit in status register
IOWR(TIMER_1_BASE, 0, 0x0);
// initialize timer control - start timer, run continuously, enable interrupts
IOWR(TIMER_1_BASE, 1, 0x7);
#endif
printf("Periodic Polling Period:%d DutyCycle:%d BkgTsk:%d \n", i,j,k);
eventCounter = 0;
while(eventCounter < 100){
background(k);
}
finalize();
usleep(100);
/* ----Pulse Interrupt---- */
init(i, j);
// set up the interrupt vector
alt_irq_register(PIO_PULSE_IRQ, (void*)0, pulse_ISR );
// reset the edge capture register by writing to it (any value will do)
IOWR(PIO_PULSE_BASE, 3, 0x0);
// enable interrupts for all four buttons
IOWR(PIO_PULSE_BASE, 2, 0x1);
printf("Interrupt Period:%d DutyCycle:%d BkgTsk:%d \n", i,j,k);
eventCounterPulse = 0;
while(eventCounterPulse < 100){
background(k);
}
finalize();
usleep(100);
}
}
}
}
xComPortHandle xSerialPortInitMinimal( unsigned long ulWantedBaud, unsigned portBASE_TYPE uxQueueLength )
{
/* Create the queues used to hold Rx and Tx characters. */
xRxedChars = xQueueCreate( uxQueueLength, ( unsigned portBASE_TYPE ) sizeof( signed char ) );
xCharsForTx = xQueueCreate( uxQueueLength + 1, ( unsigned portBASE_TYPE ) sizeof( signed char ) );
/* If the queues were created correctly then setup the serial port hardware. */
if( ( xRxedChars != serINVALID_QUEUE ) && ( xCharsForTx != serINVALID_QUEUE ) )
{
portENTER_CRITICAL();
{
uartControl = ALTERA_AVALON_UART_CONTROL_RTS_MSK | ALTERA_AVALON_UART_CONTROL_RRDY_MSK | ALTERA_AVALON_UART_CONTROL_DCTS_MSK;
IOWR_ALTERA_AVALON_UART_CONTROL( UART_BASE, uartControl );
/* register the interrupt handler */
alt_irq_register ( UART_IRQ, NULL, vUARTInterruptHandler );
}
portEXIT_CRITICAL();
}
else
{
return ( xComPortHandle ) 0;
}
return ( xComPortHandle ) 1;
}
void rt_hw_uart_init(void)
{
// init uart
set_baudrate(115200);
IOWR_ALTERA_AVALON_UART_CONTROL(RS232_BASE, 0x80);//接收中断使能
IOWR_ALTERA_AVALON_UART_STATUS(RS232_BASE, 0x0); // clean status
alt_irq_register(RS232_IRQ, NULL, uart_isr);
// register device
uart_device.type = RT_Device_Class_Char;
/* device interface */
uart_device.init = rt_uart_init;
uart_device.open = rt_uart_open;
uart_device.close = rt_uart_close;
uart_device.read = rt_uart_read;
uart_device.write = rt_uart_write;
uart_device.control = rt_uart_control;
uart_device.user_data = RT_NULL;
uart_device.rx_indicate = RT_NULL;
uart_device.tx_complete = RT_NULL;
rt_device_register(&uart_device,
"uart", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STREAM | RT_DEVICE_FLAG_INT_RX);
}
int main()
{
int readdata = 0;
int offset = 0;
int toggle = 0;
int data = 0xDEAD;
// Register IRQ
alt_irq_register(0, 0, interruptServiceRoutine);
// Enable DMA
IOWR_32DIRECT(REGFILE_FINAL_0_BASE, DMACTRL, 0x1);
// Set DMA start address to 0
IOWR_32DIRECT(REGFILE_FINAL_0_BASE, DMAFSTART, 0);
// Write DMA line pitch
IOWR_32DIRECT(REGFILE_FINAL_0_BASE, DMALPITCH, LINE_PITCH);
// Set Grab start address to 0
IOWR_32DIRECT(REGFILE_FINAL_0_BASE, GFSTART, 0);
// Enable a snapshot and write 10 to GMODE // MUST BE STARTED AT 10
IOWR_32DIRECT(REGFILE_FINAL_0_BASE, GCTRL, 0x51);
// Write the line pitch
IOWR_32DIRECT(REGFILE_FINAL_0_BASE, GLPITCH, LINE_PITCH);
while (1)
{
}
return 0;
}
int main ()
{
/* set interrupt capability for the Button PIO. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(DE2_PIO_KEYS4_BASE, 0xf);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(DE2_PIO_KEYS4_BASE, 0x0);
// Register the ISR for buttons
alt_irq_register(DE2_PIO_KEYS4_IRQ, NULL, Key_InterruptHandler);
/* The alarm for calling the timer function */
static alt_alarm alarm;
/* Register the flashing function for the timer */
if (alt_alarm_start (&alarm,alt_ticks_per_second(),show,NULL) < 0)
{
printf ("No system clock available\n");
}
int current_prime = 0;
while (TRUE)
{
current_prime = next_prime(current_prime);
printf("\nNext Prime is %d",current_prime);
}
return 0;
}
// Function Name: phase2_interruptsync
// Function Purpose: Performs the necessary steps to set up interrupt
// generation for pio_pulse to generate an interrupt when
// an edge is detected from the output signal of the EGM.
// When the interrupts are generated, they are handled by
// the ISR called timer_ISR(). After the interrupt setup
// procedures are complete, the init() function is called
// to set up the EGM. A conditional while loop is used to run
// the background task while 100 pulses have not been
// captured yet. After 100 pulses have been captured,
// the test results are outputted and global variables used
// are reset for a clean testing environment.
// Function Parameters:
// period: the period of each pulse outputted by the EGM (input*81.93us)
// dutycycle: the duration for which the signal is held high (input*period/16)
// granularity: the maximum number of task units to complete per each call to
// background()
void phase2_interruptsync(int period, int dutycycle, int granularity)
{
/* set up the interrupt vector for pio_pulse, indicating pulse_ISR
as the ISR */
alt_irq_register( PIO_PULSE_IRQ, (void*)0, pulse_ISR );
/* reset the edge capture register by writing 0x0 to it */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(PIO_PULSE_BASE, 0x0);
/* set the interrupt request mask and enable interrupts */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(PIO_PULSE_BASE, 0x1);
init(period, dutycycle);
while(numPulses < 100)
{
background(granularity);
}
printf("INTERRUPT SYNCHRONIZATION - PERIOD: %d\t DUTYCYCLE: %d\t GRANULARITY: %d\t\n", period, dutycycle, granularity);
finalize();
numPulses = 0;
numEdges = 0;
previous_pulse = 0;
// Make the thread sleep for 0.5s to provide enough time for the
// finalize() method to output all of its data to the console.
usleep(500000);
}
void initAnimate(struct Cursor* cursor) {
int timer = 3000000;
IOWR_16DIRECT(TIMESTAMP_BASE, 8, timer & 0xFFFF);
IOWR_16DIRECT(TIMESTAMP_BASE, 12, timer >> 16);
IOWR_16DIRECT(TIMESTAMP_BASE, 4, 0x07);
alt_irq_register(TIMESTAMP_IRQ, cursor, (void*)animate_ISR);
}
master* master_init() {
//init sd
sd_init();
//allocates memory
master* m = (master*)malloc(sizeof(master));
m->l = malloc(sizeof(level));
m->c = malloc(sizeof(charac));
//m->o = malloc(sizeof(object));
m->o = &box;
m->co = &co;
m->spikes = &spikes;
m->box_3 = &box_3;
m->box_1 = &box_1;
m->flag = &flag;
srand(time(NULL));
m->ab = malloc(sizeof(audio_buffer));
//audio init
av_config_setup();
m->ab->audio_dev = alt_up_audio_open_dev(AUDIO_NAME); //audio setup
reset_audio_buffer(m->ab); //init circular buffer
preload_sfx(SFX, m->ab); //preloads sfx
//TODO: fix sfx
preload_sfx1("coin.wav", m->ab);
alt_irq_register(AUDIO_IRQ,m->ab,(alt_isr_func)audio_isr);
return m;
}
void Uart_init()
{
IOWR_ALTERA_AVALON_UART_CONTROL(RS232_BASE,0x80);
IOWR_ALTERA_AVALON_UART_STATUS(RS232_BASE,0x0);
alt_irq_register(RS232_IRQ,NULL,Uart_ISR);
}
void periodic_polling(int period, int dutyCycle, int granularity)
{
flag = 0;
printf("Results for periodic polling with init(%d , %d) and granularity of %d \n", period, dutyCycle, granularity);
#ifdef TIMER_1_BASE
alt_u32 timerPeriod;
// calculate timer period for 1 seconds
timerPeriod = TIMER_1_FREQ >> 16;
// initialize timer interrupt vector
alt_irq_register(TIMER_1_IRQ, (void*)0, timer_ISR);
// initialize timer period
IOWR(TIMER_1_BASE, 2, (alt_u16)timerPeriod);
IOWR(TIMER_1_BASE, 3, (alt_u16)(timerPeriod >> 16));
// clear timer interrupt bit in status register
IOWR(TIMER_1_BASE, 0, 0x0);
// initialize timer control - stop timer, start timer, run continuously, enable interrupts
IOWR(TIMER_1_BASE, 1, 0x4);
#endif
init(period, dutyCycle);
while(flag < 100)
{
background(granularity);
// initialize timer control - stop timer, start timer, run continuously, enable interrupts
IOWR(TIMER_1_BASE, 1, 0x7);
}
finalize();
}
void interrupt(int period, int dutyCycle, int granularity)
{
printf("Results for periodic polling with init(%d , %d)and granularity of %d \n", period, dutyCycle, granularity);
init(period, dutyCycle);
flag = 0;
#ifdef PIO_PULSE_BASE
//initialize the pulse PIO
//enable interrupts
IOWR(PIO_PULSE_BASE, 2, 1);
IOWR(PIO_PULSE_BASE, 3, 0);
//set up the interrupt vector
alt_irq_register( PIO_PULSE_IRQ, (void*)0, pulse_ISR );
#endif
//printf("flag2:%d\n", flag);
while(flag < 100)
{
background(granularity);
}
finalize();
}
void initAudioBuffer() {
int timer = 3000000;
IOWR_16DIRECT(AUDIOBUFFERPROCESS_BASE, 8, timer & 0xFFFF);
IOWR_16DIRECT(AUDIOBUFFERPROCESS_BASE, 12, timer >> 16);
IOWR_16DIRECT(AUDIOBUFFERPROCESS_BASE, 4, 0x08);
alt_irq_register(AUDIOBUFFERPROCESS_IRQ, NULL, (void*)mix_ISR);
}
void timerInit(void)
{
TIMER->STATUS.WORD = 0;
TIMER->PERIODL = 50000000;
TIMER->PERIODH = 50000000 >> 16;
TIMER->CONTROL.WORD = 7;
alt_irq_register(TIMER1_IRQ, (void *)TIMER1_BASE, timerISR);
}
void playCongrat()
{
// register isr
sound_data_counter = 0;
alt_irq_register(AUDIO_IRQ, 0x0, congrat_isr);
// enable interrupt
alt_irq_enable(AUDIO_IRQ);
alt_up_audio_enable_write_interrupt(audio_dev);
}
//Setups up required aspects for the program to run.
void Setup(){
SD_card_init();
init_mbr();
init_bs();
init_audio_codec();
IOWR(BUTTON_PIO_BASE, 2, 0xf);
IOWR(BUTTON_PIO_BASE, 3, 0x0);
alt_irq_register(BUTTON_PIO_IRQ, (void*)0, button_ISR);
}
void audio_init (void *isr)
{
audio_isr = isr;
// Register internal interrupt handler
alt_irq_register (AUDIO_IRQ, NULL, (alt_isr_func) audio_isr);
// Enable interrupts from audio module
*audio_ptr |= AUDIO_RE_MASK;
}
/*System initialization function. Should be called before your while(1)*/
void system_initialization(){
/*Hard-code to 1 right here, you can use ISR
*to change the value by yourself
*/
uartStartRecvFlag = 1;
/*Open Uart port and ready to transmit and receive*/
uart = open(UART_NAME, O_ACCMODE);
if(!uart){
printf("failed to open uart\n");
//return 0;
} else {
printf("Uart ready!\n");
}
//Interrupts Registrations
alt_irq_register(switch0_id, (void *)&switch0, handle_switch0_interrupt);
alt_irq_register(switch1_id, (void *)&switch1, handle_switch1_interrupt);
alt_irq_register(key0_id, (void *)&key0, handle_key0_interrupt);
alt_irq_register(key1_id, (void *)&key1, handle_key1_interrupt);
alt_irq_register(key2_id, (void *)&key2, handle_key2_interrupt);
alt_irq_register(key3_id, (void *)&key3, handle_key3_interrupt);
alt_irq_register(leftready_id, (void *)&leftready, handle_leftready_interrupt_test);
alt_irq_register(rightready_id, (void *)&rightready, handle_rightready_interrupt_test);
/*Interrupt enable -> mask to enable it*/
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH0_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCH1_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY0_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY1_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY2_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY3_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(LEFTREADY_BASE, 1);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(RIGHTREADY_BASE, 1);
/*Reset edge capture bit*/
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH0_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCH1_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY0_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY1_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY2_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY3_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(LEFTREADY_BASE, 0);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(RIGHTREADY_BASE, 0);
/*turn off all LEDs*/
IOWR_ALTERA_AVALON_PIO_DATA(LED_BASE, 0x00);
/*initialize SPI transmission*/
IOWR_ALTERA_AVALON_PIO_DATA(CS_BASE, 1); // ~CS low
IOWR_ALTERA_AVALON_PIO_DATA(SCLK_BASE, 0); // Initialize SCLK to high
}
/********************************************************************
* 名 称：InitPIO()
* 功 能：初始化LED_PIO为输出，KEY为输入，开中断，清边沿捕获寄存器
* 入口参数：无
* 出口参数：无
********************************************************************/
void InitPIO(void)
{
/* 初始化LED_PIO为输出，KEY为输入 */
IOWR_ALTERA_AVALON_PIO_DIRECTION(LED_PIO_BASE, LEDCON);
IOWR_ALTERA_AVALON_PIO_DIRECTION(KEY_PIO_BASE, 0x00);
/* 开KEY的中断 */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY_PIO_BASE, KEYCON);
/* 清边沿捕获寄存器 */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY_PIO_BASE, 0x00);
/* 注册中断服务子程序 */
alt_irq_register(KEY_PIO_IRQ, NULL, KeyDown_interrupts);
}
struct SwitchController* initSwitchController(void)
{
struct SwitchController* this = (struct SwitchController*)malloc(sizeof(struct SwitchController));
this->switches = 0;
this->switch_listener = NULL;
this->listener_context = NULL;
alt_irq_register(SWITCHES_IRQ, this, (void*) switch_ISR);
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(SWITCHES_BASE, 0);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(SWITCHES_BASE, 0);
return this;
}
static void disable_button_pio()
{
/* Disable interrupts from the button_pio PIO component. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0x0);
/* Un-register the IRQ handler by passing a null handler. */
#ifdef ALT_ENHANCED_INTERRUPT_API_PRESENT
alt_ic_isr_register(BUTTON_PIO_IRQ_INTERRUPT_CONTROLLER_ID, BUTTON_PIO_IRQ,
NULL, NULL, NULL);
#else
alt_irq_register( BUTTON_PIO_IRQ, NULL, NULL );
#endif
}
int main()
{
usigned_char pb1_flag = 0x0;
usigned_char pb2_flag = 0x0;
volatile u_char timer1_count_flag = 0x0;
while (1)
{
/* Set interrupt for PB1 and PB2. Save state of switches. */
alt_irq_register( BUTTON_PIO_IRQ, (void*)0, button_ISR ); // PB ISR setup.
IOWR(BUTTON_PIO_BASE, 3, 0x0); // Reset edge capture register.
IOWR(BUTTON_PIO_BASE, 2, 0x3); // Enable interrupts for 2 PBs.
// Save stat eof switches
/* Initialize timer 0 */
alt_u32 timerPeriod; // 32 bit period used for timer
timerPeriod = 1 * TIMER_0_FREQ; // 1 second frequency
IOWR( TIMER_0_BASE, 2, (alt_u16)timerPeriod );
IOWR( TIMER_0_BASE, 3, (alt_u16)(timerPeriod >> 16) );
/* Initalize timer 1 */
// Initialize timer interrupt vector
alt_irq_register( TIMER_0_IRQ, (void *)0, TIMER_ISR );
// Clear timer interrupt bit in status register
IOWR( TIMER_0_BASE, 0, 0x0 );
// Initialize timer control - start timer, run continuously, enable interrupts
IOWR( TIMER_0_BASE, 1, 0x7 );
/* If PB1 start timer 1 interrupt. After every second, add to LED byte. Output. */
// if timer1_count_flag > 7 reset flag and stop timer.
// Else, output to the leds.
/* If PB2 start timer 2 interrupt. After every second, add to LCD byte. Output. */
}
return( 0 );
}
void init(){
/* Recast the edge_capture pointer to match the
alt_irq_register() function prototype. */
void* distFlag_ptr = (void*) &distFlag;
void* angleFlag_ptr = (void*) &angleFlag;
void* graphicsFlag_ptr = (void*) &graphicsFlag;
// Enable distance calc interrupt
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(DIST_READY_BASE, 1);
// Reset the edge capture register
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(DIST_READY_BASE, 0x0);
// Register the ISR
alt_irq_register(DIST_READY_IRQ, distFlag_ptr,distance_interrupt );
// Enable anlge calc interrupt
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(ANGLE_BASE, 1);
// Reset the edge capture register
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(ANGLE_BASE, 0x0);
// Register the ISR
alt_irq_register(ANGLE_READY_IRQ,angleFlag_ptr , angle_interrupt);
// Enable graphics interrupt
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(GRAPHICS_READY_BASE, 1);
// Reset the edge capture register
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(GRAPHICS_READY_BASE, 0x0);
// Register the ISR
alt_irq_register(GRAPHICS_READY_IRQ, graphicsFlag_ptr, graphics_interrupt);
//clear screen
int i,g;
for(i=-9;i<18;i++){
for(g=-7;g<14;g++){
drawRect(i,g,0);
}
}
drawRect(0,0,0xF00);
}
int main(void) {
//Registering the timer interrupt request
alt_irq_register(TIMER_0_IRQ, (void*) 0, TIMER_ISR);
//Establishing the timer's period
IOWR(TIMER_0_BASE, 2, (alt_u16)TIMER_0_FREQ);
IOWR(TIMER_0_BASE, 3, (alt_u16)(TIMER_0_FREQ >> 16));
//Clear the timer bit in register and initialise
IOWR(TIMER_0_BASE, 0, 0x0);
IOWR(TIMER_0_BASE, 1, 0x7);
//Initialise the interrupt request
alt_irq_register(BUTTON_PIO_IRQ, (void*) 0, button_ISR);
IOWR(BUTTON_PIO_BASE, 2, 0xF);
IOWR(BUTTON_PIO_BASE, 3, 0x0);
IOWR(LED_PIO_BASE, 0, 0x00);
IOWR(SEVEN_SEG_PIO_BASE,0, 0xffff);
while (1) { }
return (0);
}
/* Initialize the button_pio. */
static void init_button_pio()
{
/* Recast the edge_capture pointer to match the
alt_irq_register() function prototype. */
void* edge_capture_ptr = (void*) &edge_capture;
/* Enable all 4 button interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY_BASE, 0xf);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY_BASE, 0x0);
/* Register the ISR. */
alt_irq_register( KEY_IRQ,
edge_capture_ptr,
handle_button_interrupts );
}
int set_audio_interrupt(alt_up_audio_dev *audio, volatile int edge_capture_thing)
{
// Need to disable both audio interrupts before setting them up
// otherwise you get stuck in them when they are setup
alt_up_audio_disable_read_interrupt(audio);
alt_up_audio_disable_write_interrupt(audio);
void *edge_pointer = (void*)&edge_capture_thing;
#ifdef ALT_ENHANCED_INTERRUPT_API_PRESENT
return alt_ic_isr_register(AUDIO_CORE_IRQ_INTERRUPT_CONTROLLER_ID,
AUDIO_CORE_IRQ, playMusicISR, edge_pointer, 0x0);
#else
return alt_irq_register(AUDIO_CORE_IRQ, edge_pointer, playMusicISR);
#endif
}
static void init_button_pio()
{
/* initialize the push button interrupt vector */
alt_irq_register( BUTTON_PIO_IRQ, (void*) 0, BUTTON_ISR);
/* Reset the edge capture register. */
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE, 0x0);
/* Enable all 4 button interrupts. */
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0xf);
/* Initialize Variables */
edge_capture = 0;
}
void altera_modular_adc_init(alt_modular_adc_dev* dev, alt_32 ic_id, alt_32 irq)
{
extern alt_llist altera_modular_adc_list;
alt_dev_llist_insert((alt_dev_llist*) dev, &altera_modular_adc_list);
if ((0 <= ic_id) && (0 <= irq))
{
/* Install IRQ handler */
#ifdef ALT_ENHANCED_INTERRUPT_API_PRESENT
alt_ic_isr_register(ic_id, irq, alt_adc_irq,
dev, NULL);
#else
alt_irq_register(irq, dev, alt_adc_irq);
#endif
}
}
/**
* Initiating UART Core with:
* 115200 Baudrate
* refer to /documentation/n2cpu_nii51010.pdf for more info
*/
void diverInitUART(int baud) {
//Each Bit in the control register enables an IRQ for a corresponding bit in the status register.
int control = ALTERA_AVALON_UART_CONTROL_RRDY_MSK | //enable Read Interrupts
ALTERA_AVALON_UART_CONTROL_E_MSK; //enable Exceptions for each Interrupt
IOWR_ALTERA_AVALON_UART_CONTROL(UART_0_BASE, control); //write contorl bitmask in the control register
IOWR_ALTERA_AVALON_UART_STATUS(UART_0_BASE, 0x00); //writing 0 in the status Register clears the dcts,e,toe,roe,brk,fe, and pe bits
//writing up the Baudrate-divisor
//setting Baudrate-divisor: div = clk / desired Baudrate + 0,5
int divisor = (int) (50000000 / baud + 0.5); //div will be 434
IOWR_ALTERA_AVALON_UART_DIVISOR(UART_0_BASE, divisor);
//install IRQ service routine
alt_irq_register(UART_0_IRQ, 0, (alt_isr_func) ISRUART);
alt_irq_enable(UART_0_IRQ);
}
void EnableKeyInterrupt(void){
int error;
// enable interrupt, 2-keybutton
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(KEY_BASE,0x03);
// clear capture flag
IOWR_ALTERA_AVALON_PIO_EDGE_CAP(KEY_BASE,0);
//
bKeyPressed = FALSE;
// register interrupt isr
error = alt_irq_register (KEY_IRQ, 0, KEY_ISR);
if (error)
printf("Failed to register interrut\r\n");
}
