Sammel-Interrupt mit avr-gcc

**PicNick** · 24.02.2006, 09:06

Laßt mich mitreden:
Geht darum, von ZWEI verschiedenen Interrupt-Vektoren aus EINE Funktion aufzurufen ?
Ich würde an beiden ISR-vectoren schreiben, (wenn GCC das zuläßt)

Code:

<__vector_10>: 
     RCALL func_tion
     RETI
<__vector_11>: 
     RCALL func_tion
     RETI

func_tion: wie auch immer, aber mit RET, kein RETI (logo, aber eigentlich ist das auch wurst)

durch den RCALL steht an einer definierten stelle vom Stack, welche ISR das nun eigentlich ist , die könnt man sich holen

**ogni42** · 24.02.2006, 09:50

Der Return Code steht immer auf dem Stack (auch beim call).

Hier geht es in der Hauptsache darum, das möglichst einfach in C zu realisieren. In assembler ruft man einfach stets diesselbe Unterroutine auf. Der C Compiler generiert aber jede Menge zusätzlichen Code und den möchten wir nach Möglichkeit einsparen.

**SprinterSB** · 24.02.2006, 09:57

Das push muss doch vor dem ldi stehen, sonst zerstört die ISR R24. Ausserdem "weiß" GCC nicht, welche Register eine Funktion verwendet, bzw. es wird davon ausgegangen, daß die Werte in R18-R27 und Z zerstört werden (siehe Registerverwendung).

Jedenfalls scheint das ganze komplizierter zu sein, als es auf den ersten Blick erscheint...

So könnte es gehen, zumindest für 2 ISRs:

Code:

// Jump to Symbol sym
#define jump(sym)                                     \
   __asm__ __volatile ("rjmp " #sym)

// Set T-Flag
#define set()                                         \
   __asm__ __volatile ("set")

// Clear T-Flag
#define clt()                                         \
   __asm__ __volatile ("clt")

// Load Bit n with T-Flag
#define bld(n)                                        \
    ({                                                \
        unsigned char _x;                             \
        __asm__ __volatile ("bld %0, %1" : "=r" (_x) : "M" (n)); \
        _x & (1 << (n));                                           \
    })    

char blah;

SIGNAL (foo)
{
   if (bld(0) & 1)
		blah = 1;
	else
		blah = -1;
}

void __attribute__ ((naked))
SIG_INTERRUPT0()
{
	clt();
   jump (foo);
}

void __attribute__ ((naked))
SIG_INTERRUPT1()
{
	set();
   jump (foo);
}

Das ergibt

Code:

0000005c <foo>:
  5c:	1f 92       	push	r1
  5e:	0f 92       	push	r0
  60:	0f b6       	in	r0, 0x3f	; 63
  62:	0f 92       	push	r0
  64:	11 24       	eor	r1, r1
  66:	8f 93       	push	r24
;;;;;;;;;;;;; Prolog Ende
  68:	80 f9       	bld	r24, 0
  6a:	80 ff       	sbrs	r24, 0
  6c:	02 c0       	rjmp	.+4      	; 0x72
  6e:	81 e0       	ldi	r24, 0x01	; 1
  70:	01 c0       	rjmp	.+2      	; 0x74
  72:	8f ef       	ldi	r24, 0xFF	; 255
  74:	80 93 7b 00 	sts	0x007B, r24
;;;;;;;;;;;;; Epilog Anfang
  78:	8f 91       	pop	r24
  7a:	0f 90       	pop	r0
  7c:	0f be       	out	0x3f, r0	; 63
  7e:	0f 90       	pop	r0
  80:	1f 90       	pop	r1
  82:	18 95       	reti

00000084 <__vector_1>:
  84:	e8 94       	clt
  86:	ea cf       	rjmp	.-44     	; 0x5c

00000088 <__vector_2>:
  88:	68 94       	set
  8a:	e8 cf       	rjmp	.-48     	; 0x5c

Das geht aber nur mit 2 ISRs

Ausserdem wird das T-Flag durch die ISR zerstört. Weiter tragisch ist das nicht, weil es nicht von GCC verwendet wird. Aber sonstwo kann man es auch nicht mehr verwenden.

Das in einem globalen Register zu merken geht auch nicht. Das Register kann nur R16-R31 sein, weil R0-R15 kein andi, ori kennen. Und von den Registern kann man keines global machen, ausser evtl. R26, R27, was aber überall zu deutlich mieserem Code führen durfte!

**PicNick** · 24.02.2006, 09:59

Der Return Code steht immer auf dem Stack (auch beim call).

Aber geh', was sie nicht sagen.
Aber welche return-addresse steht beim Interrupt normalerweise dort ? richtig !

**SprinterSB** · 24.02.2006, 10:02

@PickNick: Das Problem ist dann, in func_tion zu entscheiden, welche IRQ auftrat. __builtin_return_address(0) funktioniert nicht für avr-gcc. Dazu müsste man wissen, welche/wieviel Register verwendet werden, und was im Prolog gepusht wird, wie groß der Frame ist (falls vorhanden), etc

Ich würde schon gerne bei C bleiben, und nicht in asm schreiben...

**PicNick** · 24.02.2006, 10:14

Welcher Interrupt, ist aus der return addresse erkennbar (die return addresse zeigt ja in dem Fall mitten in die vektoren rein).
Geht natürlich nur bei "R"call (16 Bit ) die andern 16 Bit für den reti

Sprinter: Irgendwann mußt du wissen, ob du Hochsprache schreibst oder nicht. Solche platformabhängigen Schweinereien werden mit Recht von höheren Sprachen nicht supported.

**ogni42** · 24.02.2006, 10:21

@picknick. Latürnich

Ich Depp.

@Sprinter: Mit dem Push meinte ich die Parameterübergabe über den Stack. R24 kann ja beliebig verwendet werden.

Was ist denn an meinem Vorschlag

Code:

void _VECTOR(2)( void )  __attribute__ ((naked));
void _VECTOR(2)( void )
{
   foo(2);
    __asm__ __volatile__ ("reti" ::);
}

auszusetzen? Kleiner ist der Assembler Code kaum zu bekommen.
Das funktioniert auch für mehr als zwei ISRs und die aufgerufene Funktion foo() weiss, von welcher ISR der Aufruf stammt.

BTW. RJUMP wird, da die maximale Sprunglänge begrenzt ist, nicht immer funktionieren.

**SprinterSB** · 24.02.2006, 10:26

Die return-Adresse zeigt nicht in die VecTab, weil in der VecTab ein jump steht (und nicht ein call). Das Problem ist nicht, die ret-Adresse auszuwerten, sondern an die Ort der ret-Adresse zu kommen. Das einzige, was es dafür gibt, wäre __builtin_return_address (ist aber ein Erratum, s.o.).

Die Return-Adresse oben wäre __vector_10+2, was der Linker zu einer Konstanten auflöst. Aber wie formulierst du den Ort der Return-Adresse?

Schreiben will ich in C, keine Frage. Aber die Welt ist eben nicht Schwarz-Weiß. Manchmal muss man sich in die Unterwelt begeben. Und den Aufenthalt dort macht man so kurz und knapp es eben geht.

**SprinterSB** · 24.02.2006, 10:30

@ogni: Das geht nicht, weil dir foo() Register kaputt macht, die nicht wieder hergestellt werden. Du schreist also ISR mit normalem Funktions-Prolog/Epilog, was die Register-Sicherung angeht. Das crasht!

**ogni42** · 24.02.2006, 10:35

Hier mal ein etwas kompletteres Beispiel, bei dem man sieht, dass bei foo() nichts kaputt geschrieben wird. Es geht eigentlich nur um R24. Das kann man in der ISR ja noch per asm pushen/popen

Code:

#include <avr/interrupt.h>
#include <avr/signal.h>
#include <inttypes.h>

void foo( uint8_t whichISR )
{
	volatile uint8_t isr = whichISR;
}

void _VECTOR(1)( void )  __attribute__ ((naked));
void _VECTOR(1)( void )
{
   foo(1);
    __asm__ __volatile__ ("reti" ::);
} 


void _VECTOR(2)( void )  __attribute__ ((naked));
void _VECTOR(2)( void )
{
   foo(2);
    __asm__ __volatile__ ("reti" ::);
} 


void _VECTOR(3)( void )  __attribute__ ((naked));
void _VECTOR(3)( void )
{
   foo(3);
    __asm__ __volatile__ ("reti" ::);
}

Wie assembliert mit -Os zu:

Code:

	.file	"scratch.c"
	.arch atmega48
__SREG__ = 0x3f
__SP_H__ = 0x3e
__SP_L__ = 0x3d
__tmp_reg__ = 0
__zero_reg__ = 1
	.global __do_copy_data
	.global __do_clear_bss
	.section	.debug_abbrev,"",@progbits
.Ldebug_abbrev0:
	.section	.debug_info,"",@progbits
.Ldebug_info0:
	.section	.debug_line,"",@progbits
.Ldebug_line0:
	.text
.Ltext0:
.global	foo
	.type	foo, @function
foo:
.LFB3:
.LM1:
/* prologue: frame size=1 */
	push r28
	push r29
	in r28,__SP_L__
	in r29,__SP_H__
	sbiw r28,1
	in __tmp_reg__,__SREG__
	cli
	out __SP_H__,r29
	out __SREG__,__tmp_reg__
	out __SP_L__,r28
/* prologue end (size=10) */
.LM2:
	std Y+1,r24
/* epilogue: frame size=1 */
	adiw r28,1
	in __tmp_reg__,__SREG__
	cli
	out __SP_H__,r29
	out __SREG__,__tmp_reg__
	out __SP_L__,r28
	pop r29
	pop r28
	ret
/* epilogue end (size=9) */
/* function foo size 20 (1) */
.LFE3:
	.size	foo, .-foo
.global	__vector_1
	.type	__vector_1, @function
__vector_1:
.LFB4:
.LM3:
/* prologue: frame size=0 */
/* prologue: naked */
/* prologue end (size=0) */
.LM4:
	ldi r24,lo8(1)
	rcall foo
.LM5:
/* #APP */
	reti
/* #NOAPP */
/* epilogue: frame size=0 */
/* epilogue: naked */
/* epilogue end (size=0) */
/* function __vector_1 size 4 (4) */
.LFE4:
	.size	__vector_1, .-__vector_1
.global	__vector_2
	.type	__vector_2, @function
__vector_2:
.LFB5:
.LM6:
/* prologue: frame size=0 */
/* prologue: naked */
/* prologue end (size=0) */
.LM7:
	ldi r24,lo8(2)
	rcall foo
.LM8:
/* #APP */
	reti
/* #NOAPP */
/* epilogue: frame size=0 */
/* epilogue: naked */
/* epilogue end (size=0) */
/* function __vector_2 size 4 (4) */
.LFE5:
	.size	__vector_2, .-__vector_2
.global	__vector_3
	.type	__vector_3, @function
__vector_3:
.LFB6:
.LM9:
/* prologue: frame size=0 */
/* prologue: naked */
/* prologue end (size=0) */
.LM10:
	ldi r24,lo8(3)
	rcall foo
.LM11:
/* #APP */
	reti
/* #NOAPP */
/* epilogue: frame size=0 */
/* epilogue: naked */
/* epilogue end (size=0) */
/* function __vector_3 size 4 (4) */
.LFE6:
	.size	__vector_3, .-__vector_3
.Letext0:
	.section	.debug_line
	.long	.LELT0-.LSLT0

.LSLT0:
	.word	2

	.long	.LELTP0-.LASLTP0

.LASLTP0:
	.byte	0x1
	.byte	0x1
	.byte	0xf6
	.byte	0xf5
	.byte	0xa
	.byte	0x0
	.byte	0x1
	.byte	0x1
	.byte	0x1
	.byte	0x1
	.byte	0x0
	.byte	0x0
	.byte	0x0
	.byte	0x1
	.ascii	".."
	.byte	0
	.ascii	"C:/Programme/WinAVR/bin/../lib/gcc/avr/3.4.3/../../../../avr"
	.ascii	"/include"
	.byte	0
	.byte	0x0
	.string	"stdint.h"
	.uleb128 0x2
	.uleb128 0x0
	.uleb128 0x0
	.string	"scratch.c"
	.uleb128 0x1
	.uleb128 0x0
	.uleb128 0x0
	.byte	0x0
.LELTP0:
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM1

	.byte	0x4
	.uleb128 0x2
	.byte	0x19
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM2

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM3

	.byte	0x19
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM4

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM5

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM6

	.byte	0x1a
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM7

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM8

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM9

	.byte	0x1a
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM10

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.LM11

	.byte	0x15
	.byte	0x0
	.uleb128 0x3
	.byte	0x2
	.word	.Letext0

	.byte	0x0
	.uleb128 0x1
	.byte	0x1
.LELT0:
	.section	.debug_info
	.long	220

	.word	2

	.long	.Ldebug_abbrev0

	.byte	0x2
	.uleb128 0x1
	.long	.Ldebug_line0

	.word	.Letext0

	.word	.Ltext0

	.long	.LASF10

	.byte	0x1
	.long	.LASF11

	.long	.LASF12

	.uleb128 0x2
	.long	.LASF0

	.byte	0x1
	.byte	0x6
	.uleb128 0x3
	.long	.LASF13

	.byte	0x1
	.byte	0x46
	.long	51

	.uleb128 0x2
	.long	.LASF1

	.byte	0x1
	.byte	0x8
	.uleb128 0x4
	.string	"int"
	.byte	0x2
	.byte	0x5
	.uleb128 0x2
	.long	.LASF2

	.byte	0x2
	.byte	0x7
	.uleb128 0x2
	.long	.LASF3

	.byte	0x4
	.byte	0x5
	.uleb128 0x2
	.long	.LASF4

	.byte	0x4
	.byte	0x7
	.uleb128 0x2
	.long	.LASF5

	.byte	0x8
	.byte	0x5
	.uleb128 0x2
	.long	.LASF6

	.byte	0x8
	.byte	0x7
	.uleb128 0x5
	.long	152

	.byte	0x1
	.string	"foo"
	.byte	0x2
	.byte	0x6
	.byte	0x1
	.word	.LFB3

	.word	.LFE3

	.byte	0x6
	.byte	0x6c
	.byte	0x93
	.uleb128 0x1
	.byte	0x6d
	.byte	0x93
	.uleb128 0x1
	.uleb128 0x6
	.long	.LASF14

	.byte	0x2
	.byte	0x5
	.long	40

	.byte	0x1
	.byte	0x68
	.uleb128 0x7
	.string	"isr"
	.byte	0x2
	.byte	0x7
	.long	152

	.byte	0x2
	.byte	0x91
	.sleb128 1
	.byte	0x0
	.uleb128 0x8
	.long	40

	.uleb128 0x9
	.byte	0x1
	.long	.LASF7

	.byte	0x2
	.byte	0xc
	.byte	0x1
	.word	.LFB4

	.word	.LFE4

	.byte	0x8
	.byte	0x90
	.uleb128 0x20
	.byte	0x93
	.uleb128 0x1
	.byte	0x90
	.uleb128 0x21
	.byte	0x93
	.uleb128 0x1
	.uleb128 0x9
	.byte	0x1
	.long	.LASF8

	.byte	0x2
	.byte	0x14
	.byte	0x1
	.word	.LFB5

	.word	.LFE5

	.byte	0x8
	.byte	0x90
	.uleb128 0x20
	.byte	0x93
	.uleb128 0x1
	.byte	0x90
	.uleb128 0x21
	.byte	0x93
	.uleb128 0x1
	.uleb128 0x9
	.byte	0x1
	.long	.LASF9

	.byte	0x2
	.byte	0x1c
	.byte	0x1
	.word	.LFB6

	.word	.LFE6

	.byte	0x8
	.byte	0x90
	.uleb128 0x20
	.byte	0x93
	.uleb128 0x1
	.byte	0x90
	.uleb128 0x21
	.byte	0x93
	.uleb128 0x1
	.byte	0x0
	.section	.debug_abbrev
	.uleb128 0x1
	.uleb128 0x11
	.byte	0x1
	.uleb128 0x10
	.uleb128 0x6
	.uleb128 0x12
	.uleb128 0x1
	.uleb128 0x11
	.uleb128 0x1
	.uleb128 0x25
	.uleb128 0xe
	.uleb128 0x13
	.uleb128 0xb
	.uleb128 0x3
	.uleb128 0xe
	.uleb128 0x1b
	.uleb128 0xe
	.byte	0x0
	.byte	0x0
	.uleb128 0x2
	.uleb128 0x24
	.byte	0x0
	.uleb128 0x3
	.uleb128 0xe
	.uleb128 0xb
	.uleb128 0xb
	.uleb128 0x3e
	.uleb128 0xb
	.byte	0x0
	.byte	0x0
	.uleb128 0x3
	.uleb128 0x16
	.byte	0x0
	.uleb128 0x3
	.uleb128 0xe
	.uleb128 0x3a
	.uleb128 0xb
	.uleb128 0x3b
	.uleb128 0xb
	.uleb128 0x49
	.uleb128 0x13
	.byte	0x0
	.byte	0x0
	.uleb128 0x4
	.uleb128 0x24
	.byte	0x0
	.uleb128 0x3
	.uleb128 0x8
	.uleb128 0xb
	.uleb128 0xb
	.uleb128 0x3e
	.uleb128 0xb
	.byte	0x0
	.byte	0x0
	.uleb128 0x5
	.uleb128 0x2e
	.byte	0x1
	.uleb128 0x1
	.uleb128 0x13
	.uleb128 0x3f
	.uleb128 0xc
	.uleb128 0x3
	.uleb128 0x8
	.uleb128 0x3a
	.uleb128 0xb
	.uleb128 0x3b
	.uleb128 0xb
	.uleb128 0x27
	.uleb128 0xc
	.uleb128 0x11
	.uleb128 0x1
	.uleb128 0x12
	.uleb128 0x1
	.uleb128 0x40
	.uleb128 0xa
	.byte	0x0
	.byte	0x0
	.uleb128 0x6
	.uleb128 0x5
	.byte	0x0
	.uleb128 0x3
	.uleb128 0xe
	.uleb128 0x3a
	.uleb128 0xb
	.uleb128 0x3b
	.uleb128 0xb
	.uleb128 0x49
	.uleb128 0x13
	.uleb128 0x2
	.uleb128 0xa
	.byte	0x0
	.byte	0x0
	.uleb128 0x7
	.uleb128 0x34
	.byte	0x0
	.uleb128 0x3
	.uleb128 0x8
	.uleb128 0x3a
	.uleb128 0xb
	.uleb128 0x3b
	.uleb128 0xb
	.uleb128 0x49
	.uleb128 0x13
	.uleb128 0x2
	.uleb128 0xa
	.byte	0x0
	.byte	0x0
	.uleb128 0x8
	.uleb128 0x35
	.byte	0x0
	.uleb128 0x49
	.uleb128 0x13
	.byte	0x0
	.byte	0x0
	.uleb128 0x9
	.uleb128 0x2e
	.byte	0x0
	.uleb128 0x3f
	.uleb128 0xc
	.uleb128 0x3
	.uleb128 0xe
	.uleb128 0x3a
	.uleb128 0xb
	.uleb128 0x3b
	.uleb128 0xb
	.uleb128 0x27
	.uleb128 0xc
	.uleb128 0x11
	.uleb128 0x1
	.uleb128 0x12
	.uleb128 0x1
	.uleb128 0x40
	.uleb128 0xa
	.byte	0x0
	.byte	0x0
	.byte	0x0
	.section	.debug_pubnames,"",@progbits
	.long	67

	.word	2

	.long	.Ldebug_info0

	.long	224

	.long	100

	.string	"foo"
	.long	157

	.string	"__vector_1"
	.long	179

	.string	"__vector_2"
	.long	201

	.string	"__vector_3"
	.long	0

	.section	.debug_aranges,"",@progbits
	.long	16

	.word	2

	.long	.Ldebug_info0

	.byte	0x2
	.byte	0x0
	.word	.Ltext0

	.word	.Letext0-.Ltext0

	.word	0

	.word	0

	.section	.debug_str,"MS",@progbits,1
.LASF5:
	.string	"long long int"
.LASF12:
	.string	"D:\\priv\\Tech\\atmel\\learning\\scratch\\default"
.LASF2:
	.string	"unsigned int"
.LASF10:
	.string	"GNU C 3.4.3"
.LASF4:
	.string	"long unsigned int"
.LASF6:
	.string	"long long unsigned int"
.LASF14:
	.string	"whichISR"
.LASF13:
	.string	"uint8_t"
.LASF1:
	.string	"unsigned char"
.LASF3:
	.string	"long int"
.LASF7:
	.string	"__vector_1"
.LASF8:
	.string	"__vector_2"
.LASF9:
	.string	"__vector_3"
.LASF0:
	.string	"signed char"
.LASF11:
	.string	"../scratch.c"
/* File "../scratch.c": code   32 = 0x0020 (  13), prologues  10, epilogues   9 */

foo() macht keine Register kaputt, und da der Mega48 ein kleineres Flash hat, wird auch RCALL benutzt. foo() kann durch den Übergabeparameter feststellen von wo der Aufruf kommt, und in den ISR steht der richtige RETI. Die interne Variable in foo ist im Beispiel nur volatile damit der Compiler sie nicht wegoptimiert.

Thema: Sammel-Interrupt mit avr-gcc

Themen-Optionen

Thema durchsuchen

Anzeige

Lesezeichen

Lesezeichen

Berechtigungen