How to use interrupt?

Hello.

Please help me!

I tried "edge" and "level" both.

But nothing changed.

I'm at a loss.

Please give me a advise.

Thank you.

Can you give me some advice?

I am really in trouble.

I use StratixII dev kit.

So, hardware should be OK.

But I'm not sure how to use interrupt.

Thank you.

I&#39;m in the same problem as m_isshiki (and also a newbie http://forum.niosforum.com/work2/style_emoticons/<#EMO_DIR#>/smile.gif ).

Without eCos, i used my interrupt this way:

static void HandleRising1Interrupt(void *context, alt_u32 id)

{

// Do the interrupt routine stuff

// ...

IOWR_ALTERA_AVALON_PIO_EDGE_CAP(PIO_INT_RISING1_BASE, 0);

}

void main()

{

IOWR_ALTERA_AVALON_PIO_IRQ_MASK(PIO_INT_RISING1_BASE, 0xF);

IOWR_ALTERA_AVALON_PIO_EDGE_CAP(PIO_INT_RISING1_BASE, 0);

alt_irq_register(PIO_INT_RISING1_IRQ, (void *) 0, HandleRising1Interrupt);

// The rest of the application

// ...

}

My interrupt is defined by the following constants in system.h:

/*

* pio_int_rising1 configuration

*

*/

# define PIO_INT_RISING1_NAME "/dev/pio_int_rising1"# define PIO_INT_RISING1_TYPE "altera_avalon_pio"# define PIO_INT_RISING1_BASE 0x02000820# define PIO_INT_RISING1_IRQ 4# define PIO_INT_RISING1_DO_TEST_BENCH_WIRING 0# define PIO_INT_RISING1_DRIVEN_SIM_VALUE 0x0000# define PIO_INT_RISING1_HAS_TRI 0# define PIO_INT_RISING1_HAS_OUT 0# define PIO_INT_RISING1_HAS_IN 1# define PIO_INT_RISING1_CAPTURE 1# define PIO_INT_RISING1_EDGE_TYPE "RISING"# define PIO_INT_RISING1_IRQ_TYPE "EDGE"# define PIO_INT_RISING1_FREQ 70000000

As you can see, it&#39;s defined as a "rising edge" interrupt.

Now I&#39;m trying to do the same with eCos, using a similar code to that used by m_isshiki, but with no result.

Could anybody please explain how to handle my interrupt with eCos?

Thank you very much.

--- Quote Start ---

originally posted by m_isshiki@Dec 13 2005, 08:48 AM

can you give me some advice?

i am really in trouble.

i use stratixii dev kit.

so, hardware should be ok.

but i&#39;m not sure how to use interrupt.

thank you.

<div align='right'><{post_snapback}> (index.php?act=findpost&pid=11507)

--- quote end ---

--- Quote End ---

i think you can not use printf in ISR.

Restricted Environment

ISRs run in a restricted environment. A large number of the HAL API

calls are not available from ISRs. For example, accesses to the HAL file

system are not permitted. As a general rule, when writing your own ISR,

never include function calls that can block waiting for an interrupt.

In addition, you should be careful when calling ANSI C standard library

functions inside of an ISR. No calls should be made using the C standard

library I/O API, because calling these functions can result in deadlock

within the system, i.e., the system can become permanently blocked

within the ISR. In particular, you should not call printf() from within an ISR without careful consideration. If stdout is mapped to a device

driver that uses interrupts for proper operation, the printf() call can

deadlock the system waiting for an interrupt that never occurs because

interrupts are disabled. You can use printf() from within ISRs safely,

but only if the device driver does not use interrupts..

yes, you should try something like

HAL_WRITE_UINT8(LED_ADDRESS, 0x55); //all uneven LEDs lit up

if you want printf do so in the DSR, because it is meant to do it there.

I&#39;m pretty sure you provided a code snippet, but I don&#39;t see you clearing the IRQ source in either the ISR or DSR which would lead to an infinite IRQ loop.

How are you generating the IRQ? Are you sure you are actually generating an interrupt?

Are you sure you are attaching to the correct vector number?

Finally remember that printf is not re-entrant so if you have prints in regular code and DSR code you will need to protect against simultaneous accesses.

I use the interrupt with the button pio like that:

# include <cyg/hal/io.h> // for IOWR and IORD

unsigned char ledpio;

cyg_interrupt int_pio;

cyg_handle_t int_pio_handle;

cyg_uint32 isr_pio( cyg_vector_t vector,

cyg_addrword_t data){

ledpio = ledpio|1; //

IOWR (LED_PIO_BASE , 0, ledpio);

cyg_interrupt_mask(vector);

cyg_interrupt_acknowledge(vector);

IOWR(BUTTON_PIO_BASE , 3, 0x00); // Reset the edgecapture register

ledpio = ledpio&~1; //

IOWR (LED_PIO_BASE , 0, ledpio);

return(CYG_ISR_HANDLED | CYG_ISR_CALL_DSR);

}

void dsr_pio( cyg_vector_t vector,

cyg_ucount32 count,

cyg_addrword_t data){

ledpio = ledpio|2; //

IOWR (LED_PIO_BASE , 0, ledpio);

cyg_interrupt_unmask(vector);

ledpio = ledpio&~2; //

IOWR (LED_PIO_BASE , 0, ledpio);

}

void cyg_user_start(void)

{

cyg_thread_create(..);

cyg_thread_resume(..);

cyg_interrupt_create(

BUTTON_PIO_IRQ, // in /include/cyg/hal/system.h

99,

55,

&isr_pio,

&dsr_pio,

&int_pio_handle,

&int_pio);

cyg_interrupt_attach(int_pio_handle);

cyg_interrupt_unmask( BUTTON_PIO_IRQ);

IOWR(BUTTON_PIO_BASE , 1, 0x00);// PIO in input

IOWR(BUTTON_PIO_BASE , 3, 0x00);// Reset the edgecapture register

IOWR(BUTTON_PIO_BASE , 2, 0x01);// unmask bit0 all other masked

}

I use the Altera demo board Cyclone EP1C20F400

with the pio core descriped in Chapter 7 of the Nios II Processor Reference Handbook

Are you sure it is working well, because i am using your programme with just creating one single thread (led glow)but i am getting stuck after applying interrupt ,do youknow why,here is my programme,

# include <cyg/hal/io.h> // for IOWR and IORD# include <cyg/kernel/kapi.h>

unsigned char ledpio;

cyg_interrupt int_pio;

cyg_handle_t int_pio_handle;

static void ledglow(cyg_addrword_t data)

{

volatile char* a=0x2120890;//writing to the base of ledpio for 111 sequence

*a=0x7;

}

cyg_uint32 isr_pio( cyg_vector_t vector ,cyg_addrword_t data)

{

cyg_interrupt_mask(vector);

cyg_interrupt_acknowledge(vector);

IOWR(BUTTON_PIO_BASE , 3, 0x00); // Reset the edgecapture register

ledpio = 0x8; //

IOWR (LED_PIO_BASE , 0, ledpio);

return(CYG_ISR_HANDLED);

}

void dsr_pio( cyg_vector_t vector,cyg_ucount32 count,cyg_addrword_t data)

{

}

void cyg_user_start(void)

{# define STACK_SIZE 0x1000

static char stack[STACK_SIZE];

static cyg_thread thread_data;

static cyg_handle_t thread_handle;

cyg_thread_create(10,ledglow,0,"interrupt test",&stack[0],STACK_SIZE, &thread_handle,&thread_data);

cyg_thread_resume( thread_handle);

cyg_interrupt_create(BUTTON_PIO_IRQ, 99,0,&isr_pio,&dsr_pio,&int_pio_handle,&int_pio);

cyg_interrupt_attach(int_pio_handle);

cyg_interrupt_unmask( BUTTON_PIO_IRQ);

IOWR(BUTTON_PIO_BASE , 1, 0x0);// PIO in input

IOWR(BUTTON_PIO_BASE , 3, 0x00);// Reset the edgecapture register

IOWR(BUTTON_PIO_BASE , 2, 0x01);// unmask bit0 all other masked

}

--- Quote Start ---

originally posted by glecordier@Feb 6 2006, 06:31 AM

i use the interrupt with the button pio like that:

# include <cyg/hal/io.h> // for iowr and iord

unsigned char ledpio;

cyg_interrupt int_pio;

cyg_handle_t int_pio_handle;

cyg_uint32 isr_pio( cyg_vector_t vector,

cyg_addrword_t data){

ledpio = ledpio|1; //

iowr (led_pio_base , 0, ledpio);

cyg_interrupt_mask(vector);

cyg_interrupt_acknowledge(vector);

iowr(button_pio_base , 3, 0x00); // reset the edgecapture register

ledpio = ledpio&~1; //

iowr (led_pio_base , 0, ledpio);

return(cyg_isr_handled | cyg_isr_call_dsr);

}

void dsr_pio( cyg_vector_t vector,

cyg_ucount32 count,

cyg_addrword_t data){

ledpio = ledpio|2; //

iowr (led_pio_base , 0, ledpio);

cyg_interrupt_unmask(vector);

ledpio = ledpio&~2; //

iowr (led_pio_base , 0, ledpio);

}

void cyg_user_start(void)

{

cyg_thread_create(..);

cyg_thread_resume(..);

cyg_interrupt_create(

button_pio_irq, // in /include/cyg/hal/system.h

99,

55,

&isr_pio,

&dsr_pio,

&int_pio_handle,

&int_pio);

cyg_interrupt_attach(int_pio_handle);

cyg_interrupt_unmask( button_pio_irq);

iowr(button_pio_base , 1, 0x00);// pio in input

iowr(button_pio_base , 3, 0x00);// reset the edgecapture register

iowr(button_pio_base , 2, 0x01);// unmask bit0 all other masked

}

i use the altera demo board cyclone ep1c20f400

with the pio core descriped in chapter 7 of the nios ii processor reference handbook

<div align='right'><{post_snapback}> (index.php?act=findpost&pid=12562)

--- quote end ---

--- Quote End ---

It is not exactly the same

I use the isr and dsr routine

The source of interrupt is masked in the isr "cyg_interrupt_mask(vector);"

and unmasked in the dsr " cyg_interrupt_unmask(vector);"

In your code you use only the isr routine

so mask and unmask in the isr

or do not mask the source of the interrupt,

the edgecapture register masks for you until it is reset

the isr could be :

cyg_uint32 isr_pio( cyg_vector_t vector ,cyg_addrword_t data)

{

// cyg_interrupt_mask(vector);

cyg_interrupt_acknowledge(vector);

IOWR(BUTTON_PIO_BASE , 3, 0x00); // Reset the edgecapture register

ledpio = 0x8; //

IOWR (LED_PIO_BASE , 0, ledpio);

return(CYG_ISR_HANDLED);

}

okey now i am using ur programme only with creating one thread which will glow led ,so here initially the thread will runnig and when interrupt will come it will go to the isr and then dsr that i can see with the help of leds but after dsr it iwill not come again back to the thread..so here what should be the reason.?

i am a newbie,please give some suggestions,.

NIrav

# include <cyg/hal/io.h> // for IOWR and IORD# include <cyg/kernel/kapi.h>

unsigned char ledpio;

cyg_interrupt int_pio;

cyg_handle_t int_pio_handle;

cyg_uint32 isr_pio( cyg_vector_t vector,

cyg_addrword_t data){

ledpio = 0x1; //

IOWR (LED_PIO_BASE , 0, ledpio);

cyg_interrupt_mask(vector);

cyg_interrupt_acknowledge(vector);

IOWR(BUTTON_PIO_BASE , 3, 0x00); // Reset the edgecapture register

ledpio = 0x8; //

IOWR (LED_PIO_BASE , 0, ledpio);

return( CYG_ISR_CALL_DSR);

}

void dsr_pio( cyg_vector_t vector,

cyg_ucount32 count,

cyg_addrword_t data){

ledpio = 0x7; //

IOWR (LED_PIO_BASE , 0, ledpio);

cyg_interrupt_unmask(vector);

ledpio = 0x3; //

IOWR (LED_PIO_BASE , 0, ledpio);

}

static void ledglow(cyg_addrword_t data)

{

ledpio = 0x8; //

IOWR (LED_PIO_BASE , 0, ledpio);

}

void cyg_user_start(void)

{

# define STACK_SIZE 0x1000

static char stack[STACK_SIZE];

static cyg_thread thread_data;

static cyg_handle_t thread_handle;

cyg_thread_create(10,ledglow,0,"interrupt test",&stack[0],STACK_SIZE, &thread_handle,&thread_data);

cyg_thread_resume( thread_handle);

cyg_interrupt_create(

BUTTON_PIO_IRQ, // in /include/cyg/hal/system.h

99,

55,

&isr_pio,

&dsr_pio,

&int_pio_handle,

&int_pio);

cyg_interrupt_attach(int_pio_handle);

cyg_interrupt_unmask( BUTTON_PIO_IRQ);

IOWR(BUTTON_PIO_BASE , 1, 0x00);// PIO in input

IOWR(BUTTON_PIO_BASE , 3, 0x00);// Reset the edgecapture register

IOWR(BUTTON_PIO_BASE , 2, 0x01);// unmask bit0 all other masked

}

-----------------------------------------------------------------------------------------

--- Quote Start ---

originally posted by glecordier@Feb 8 2006, 04:29 AM

it is not exactly the same

i use the isr and dsr routine

the source of interrupt is masked in the isr "cyg_interrupt_mask(vector);"

and unmasked in the dsr " cyg_interrupt_unmask(vector);"

in your code you use only the isr routine

so mask and unmask in the isr

or do not mask the source of the interrupt,

the edgecapture register masks for you until it is reset

the isr could be :

cyg_uint32 isr_pio( cyg_vector_t vector ,cyg_addrword_t data)

{

// cyg_interrupt_mask(vector);

cyg_interrupt_acknowledge(vector);

iowr(button_pio_base , 3, 0x00); // reset the edgecapture register

ledpio = 0x8; //

iowr (led_pio_base , 0, ledpio);

return(cyg_isr_handled);

}

<div align='right'><{post_snapback}> (index.php?act=findpost&pid=12626)

--- quote end ---

--- Quote End ---