EmbDev.net

Forum: ARM programming with GCC/GNU tools LPC2103 - UART0 Interrupt Problem


Author: Jongmun Kim (Company: inno) (jmkim519)
Posted on:

Rate this post
0 useful
not useful
Dear all,

I am Using LPC2103, I had Configured UART0 to IRQ

When working, VIC Register Status is
 -------------------------------------------
  vicIntSelect = 0;
  vicIntEnable = 0x000040;
  vicIRQStatus = 00000040;

  vicVectCtrl0 = 0x000026;
  vicVectAddr0 = 0x000380;
  vicVectAddr  = 0x000380;
 -------------------------------------------

But Didn't happen to uart0_rx_isr Routine

Could some body help me regarding this.


 -------------------------------------------
          /* Exception Vector Table */

_vectors:       ldr     PC, Reset_Addr
                ldr     PC, Undef_Addr
                ldr     PC, SWI_Addr
                ldr     PC, PAbt_Addr
                ldr     PC, DAbt_Addr
                nop
                ldr     PC, [PC,#-0xFF0]
                ldr     PC, FIQ_Addr

 -------------------------------------------
           /* My Working Code */

#include "LPC210x.h"

void uart0_rx_isr(void);

int main()
{
        PINSEL0 &= (~(0xF) & 0xFFFFFFFF);
        PINSEL0 |= 0x5;

        UART0_FCR = 0x7;
        UART0_LCR = 0x83;
        UART0_DLL = 0x41;

        UART0_DLM = 0x0;
        UART0_LCR = 0x3;

        /* Setting Interrupt */
        UART0_IER = 0x3;
        VICIntEnClr     = 0xFFFFFFF0;
        VICIntSelect    = 0x00000000;
        VICVectCntl0    = ((0x1<<5) | 6);
        VICVectAddr0    = (unsigned long)uart0_rx_isr;

        VICIntEnable    = (1<<6);
}

void uart0_rx_isr(void)
{
        volatile unsigned long uart0IIR = 0;

        uart0IIR = UART0_IIR;

        while (!(UART0_LSR & 1<<5));
        UART0_THR = 'T';

        VICVectAddr = 0;
}

Author: A. K. (prx)
Posted on:

Rate this post
0 useful
not useful
Is the processor interrupt enabled? ARM7 startup codes often call main() 
with interrupts disabled and your main enables the interrupts in VIC but 
not in the processor. Also it is rather undefined what happens once 
main() terminates.

BTW: A local variable of an interrupt handler almost never has to be 
"volatile". Only vars which could be accessed outside of the compilers 
visibility have to be volatile (such as a main program's var accessed by 
an interrupt handler).

Author: Jongmun Kim (Company: inno) (jmkim519)
Posted on:

Rate this post
0 useful
not useful
Thx. For your help.
But I am a beginner, I don't know exactly.
Here My startup code, For processor interrupt Enable, what I have to do?
/* Stack Sizes */
.set  UND_STACK_SIZE, 0x00000004    /* stack for "undefined instruction" interrupts is 4 bytes  */
.set  ABT_STACK_SIZE, 0x00000004    /* stack for "abort" interrupts is 4 bytes                  */
.set  FIQ_STACK_SIZE, 0x00000004    /* stack for "FIQ" interrupts  is 4 bytes               */
.set  IRQ_STACK_SIZE, 0X00000004    /* stack for "IRQ" normal interrupts is 4 bytes          */
.set  SVC_STACK_SIZE, 0x00000004    /* stack for "SVC" supervisor mode is 4 bytes          */



/* Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs (program status registers) */
.set  MODE_USR, 0x10                /* Normal User Mode                     */
.set  MODE_FIQ, 0x11                /* FIQ Processing Fast Interrupts Mode             */
.set  MODE_IRQ, 0x12                /* IRQ Processing Standard Interrupts Mode           */
.set  MODE_SVC, 0x13                /* Supervisor Processing Software Interrupts Mode       */
.set  MODE_ABT, 0x17                /* Abort Processing memory Faults Mode             */
.set  MODE_UND, 0x1B                /* Undefined Processing Undefined Instructions Mode     */
.set  MODE_SYS, 0x1F                /* System Running Priviledged Operating System Tasks  Mode  */

.set  I_BIT, 0x80                   /* when I bit is set, IRQ is disabled (program status registers) */
.set  F_BIT, 0x40                   /* when F bit is set, FIQ is disabled (program status registers) */


.text
.arm

.global  Reset_Handler
.global _startup
.func   _startup

_startup:

# Exception Vectors

_vectors:       ldr     PC, Reset_Addr
                ldr     PC, Undef_Addr
                ldr     PC, SWI_Addr
                ldr     PC, PAbt_Addr
                ldr     PC, DAbt_Addr
                nop              /* Reserved Vector (holds Philips ISP checksum) */
                ldr     PC, [PC,#-0xFF0]  /* see page 71 of "Insiders Guide to the Philips ARM7-Based Microcontrollers" by Trevor Martin  */
                ldr     PC, FIQ_Addr

Reset_Addr:     .word   Reset_Handler    /* defined in this module below  */
Undef_Addr:     .word   UNDEF_Routine    /* defined in main.c  */
SWI_Addr:       .word   SWI_Routine      /* defined in main.c  */
PAbt_Addr:      .word   UNDEF_Routine    /* defined in main.c  */
DAbt_Addr:      .word   UNDEF_Routine    /* defined in main.c  */
IRQ_Addr:       .word   IRQ_Routine      /* defined in main.c  */
FIQ_Addr:       .word   FIQ_Routine      /* defined in main.c  */
                .word   0          /* rounds the vectors and ISR addresses to 64 bytes total  */


# Reset Handler

Reset_Handler:

        /* Setup a stack for each mode - note that this only sets up a usable stack
        for User mode.   Also each mode is setup with interrupts initially disabled. */

          ldr   r0, =_stack_end
          msr   CPSR_c, #MODE_UND|I_BIT|F_BIT   /* Undefined Instruction Mode  */
          mov   sp, r0
          sub   r0, r0, #UND_STACK_SIZE
          msr   CPSR_c, #MODE_ABT|I_BIT|F_BIT   /* Abort Mode */
          mov   sp, r0
          sub   r0, r0, #ABT_STACK_SIZE
          msr   CPSR_c, #MODE_FIQ|I_BIT|F_BIT   /* FIQ Mode */
          mov   sp, r0
           sub   r0, r0, #FIQ_STACK_SIZE
          msr   CPSR_c, #MODE_IRQ|I_BIT|F_BIT   /* IRQ Mode */
          mov   sp, r0
          sub   r0, r0, #IRQ_STACK_SIZE
          msr   CPSR_c, #MODE_SVC|I_BIT|F_BIT   /* Supervisor Mode */
          mov   sp, r0
          sub   r0, r0, #SVC_STACK_SIZE
          msr   CPSR_c, #MODE_SYS|I_BIT|F_BIT   /* User Mode */
          mov   sp, r0

        /* copy .data section (Copy from ROM to RAM) */
                ldr     R1, =_etext
                ldr     R2, =_data
                ldr     R3, =_edata
1:            cmp     R2, R3
                ldrlo   R0, [R1], #4
                strlo   R0, [R2], #4
                blo     1b

        /* Clear .bss section (Zero init)  */
                mov     R0, #0
                ldr     R1, =_bss_start
                ldr     R2, =_bss_end
2:        cmp     R1, R2
                strlo   R0, [R1], #4
                blo     2b

        /* Enter the C code  */
                b       main

.endfunc
.end

Author: Jongmun Kim (Company: inno) (jmkim519)
Posted on:

Rate this post
0 useful
not useful
I figure out the problem.

When I change processor Interrupt Enable, it working.

I change Below

first, Stack size change

  .set  IRQ_STACK_SIZE, 0X00000004 

  -->

  .set  IRQ_STACK_SIZE, 0X00000080

second, IRQ Enable
  msr   CPSR_c, #MODE_SYS|I_BIT|F_BIT   /* User Mode */

  -->

  msr   CPSR_c, #MODE_USR   /* User Mode */

Reply

Entering an e-mail address is optional. If you want to receive reply notifications by e-mail, please log in.

Rules — please read before posting

  • Post long source code as attachment, not in the text
  • Posting advertisements is forbidden.

Formatting options

  • [c]C code[/c]
  • [avrasm]AVR assembler code[/avrasm]
  • [code]code in other languages, ASCII drawings[/code]
  • [math]formula (LaTeX syntax)[/math]




Bild automatisch verkleinern, falls nötig
Note: the original post is older than 6 months. Please don't ask any new questions in this thread, but start a new one.