Zitat:

---

Original von MaikG:
>--- Assembler ---

Ich hab die NDK3.9 Dateien jetzt dazu kopiert bekomme aber einen fehler bei
AUDSIZE EQU 398

---

Hab's doch geahnt, dass Devpac inkompatibel zu Deinem Assembler ist!
Probier es mal mit Semikolons:

code:

---

*************************************
**
** Copyright © 1997 J.v.d.Loo
*
** Example stuff for the use of one of the two CIA-B timers - in mind
** the RKM Hardware Reference Manual from 1989, Appendix F, page 317 - 333.
*
** By the way: This code is reentrant.
*
* A68k AudioGrabber.asm -iSDK_OS3:include_i
* BLink AudioGrabber.o TO AudioGrabber
*

	IFD	__G2
		MACHINE	MC68000
		OPT	OW-
		OUTPUT	RAM:AudioGrabber
	ENDC

	include	exec/exec_lib.i
	include	exec/interrupts.i
	include	exec/execbase.i

	include	dos/dos.i
	include	dos/dosextens.i

	include	resources/cia_lib.i

	include	hardware/custom.i
	include	hardware/cia.i


   STRUCTURE	__Table,0
	APTR	_SysBase
	APTR	_CIABBase
	APTR	_ThisTask

	APTR	_Memory
	ULONG	_AudioHit

	ULONG	_Timer				; CIA-B Timer A (#0) or B (#1)
	ULONG	_PAL_NTSC			; PAL (#0) or NTSC (#2) machine
	ULONG	_Counter

	STRUCT	_IRQStruct,IS_SIZE		; CIA-B interrupt structure
	STRUCT	_IRQCause,IS_SIZE		; By Cause() required one

	ALIGNLONG
	LABEL	tb_SIZEOF


AUDSIZE	EQU	398				; As larger this buffer is as less noises occur (short blips)

_custom	EQU	$DFF000
_ciaa	EQU	$BFE001
_ciab	EQU	$BFD000

* BITDEFs macros don't work for A68k; A68k is too old...
	IFND	MEMF_CHIP
MEMF_CHIP	EQU	2
	ENDC

_main
	lea	-tb_SIZEOF(sp),sp		; Make some room on stack (for data area)
	movea.l	sp,A4				; Store address data area into processor register A4

	movea.l	(4).w,A6			; Get Exec base

	move.l	A6,_SysBase(A4)

	suba.l	A1,A1
	jsr	_LVOFindTask(A6)
	move.l	D0,_ThisTask(A4)		; Store address of own process structure

	move.l	#AUDSIZE,D0
	moveq	#MEMF_CHIP,D1
	jsr	_LVOAllocMem(A6)
	move.l	D0,_Memory(A4)
	bne.s	.goon

	moveq	#103,D0
	bra.w	_exit
.goon

	cmpi.b	#50,PowerSupplyFrequency(A6)	; Which power frequency?
	bne.s	.NTSC

	clr.l	_PAL_NTSC(A4)			; It's PAL
	bra.s	_OpenResource

.NTSC
	move.l	#2,_PAL_NTSC(A4)		; It's NTSC


_OpenResource
	lea	_CIABName(pc),A1
	moveq	#0,D0				; Any version
	jsr	_LVOOpenResource(A6)		; Open it...
	move.l	D0,_CIABBase(A4)
	beq.w	_ErrorOpenResource

*
** Set up CIA-B interrupt structure
*
	lea	_IRQStruct(A4),A0		; Initialize IRQ structure I

	clr.l	LN_PRED(A0)			; Not really required because the resource
	clr.l	LN_SUCC(A0)			; will overwrite it with its own settings

	move.b	#NT_INTERRUPT,LN_TYPE(A0)
	move.b	#32,LN_PRI(A0)

	move.l	A4,IS_DATA(A0)			; Pointer to data array

	lea	_IRQCode(pc),A1
	move.l	A1,IS_CODE(A0)			; Code to execute

	lea	_IRQName(pc),A1
	move.l	A1,LN_NAME(A0)

*
** Set up Cause() interrupt structure
*
	lea	_IRQCause(A4),A0		; Initialize IRQ structure II

	clr.l	LN_PRED(A0)			; Not really required - these two are
	clr.l	LN_SUCC(A0)			; dynamically changed by Exec

	move.b	#NT_UNKNOWN,LN_TYPE(A0)		; Type should be un-known - type assigned by Exec!
	move.b	#32,LN_PRI(A0)			; Only -32, -16, 0, +16 and +32 supported!

	move.l	A4,IS_DATA(A0)			; Pointer to data array

	lea	_IRQCauseCode(pc),A1
	move.l	A1,IS_CODE(A0)			; Code to execute

	lea	_IRQName(pc),A1
	move.l	A1,LN_NAME(A0)

*
** Since the data area is located on the stack and we don't know which values
** the data contain since they are uninitialized, and a call to AddICRVector
** causes immediately the interrupt code to be started and we also avoid a
** Disable() call, we have to initialize _Counter and _AudioHit here:
*
	clr.l	_Counter(A4)
	clr.l	_AudioHit(A4)

*
** Attempt to start one of the CIA-B timer interrupts...
*
	moveq	#0,D2				; Start with Timer A
	movea.l	_CIABBase(A4),A6
.try
	lea	_IRQStruct(A4),A1		; IRQ to execute (immediately)
	move.l	D2,D0				; Timer (which one?)
	jsr	_LVOAddICRVector(A6)
	tst.l	D0
	beq.s	_GotIRQ				; If the interrupt is free

	addq.b	#1,D2				; Next timer
	cmpi.b	#2,D2				; Timer C?
	beq.w	_ErrorTimer			; Timer C does not exist!
	bra.s	.try				; Else try Timer B

_GotIRQ
	move.l	D2,_Timer(A4)			; Save indicator for later (0 = Timer A, 1 = Timer B)

	lea	_ciab,A0			; CIA-B hardware address ($BFD000)

	move.l	_PAL_NTSC(A4),D0		; 0 or 2
	lea	_PAL_NTSC_Times(pc),A1
	move.w	0(A1,D0.l),D0			; PAL time or NTSC time value to delay between each occurring

	tst.l	_Timer(A4)			; 0 or 1
	bne.s	_TimerB				; 1 = Timer B

_TimerA
	move.b	ciacra(A0),D1			; Control register Timer A
	andi.b	#%10000000,D1			; Select mode (bit 7 currently unused)
	ori.b	#1,D1				; Set Timer A to start
	move.b	D1,ciacra(A0)
	move.b	#%10000001,ciaicr(A0)		; Enable Timer A

	move.b	D0,ciatalo(A0)			; Write delay time into registers
	lsr.w	#8,D0
	move.b	D0,ciatahi(A0)
	bra.s	_ok				; Done

_TimerB
	move.b	ciacrb(A0),D1			; Control register Timer B
	andi.b	#%10000000,D1			; Select mode
	ori.b	#1,D1				; Set Timer B to start
	move.b	D1,ciacrb(A0)
	move.b	#%10000010,ciaicr(A0)		; Enable Timer B

	move.b	D0,ciatblo(A0)			; Write delay time into registers
	lsr.w	#8,D0
	move.b	D0,ciatbhi(A0)

_ok

*	btst	#CIAB_GAMEPORT0,_ciaa		; Left mouse button (a busy loop - a absolute taboo)
*	bne.s	_wait				; - so we use the following construct:

	move.l	#SIGBREAKF_CTRL_C,D0		; Wait for a control-c signal, when pressed,
	movea.l	_SysBase(A4),A6			; awake us,
	jsr	_LVOWait(A6)			; otherwise sleep...

	lea	_custom,A0
	move.w	#15,dmacon(A0)			; Turn off audio channels 0 - 4

	movea.l	_CIABBase(A4),A6
	lea	_IRQStruct(A4),A1
	move.l	_Timer(A4),D0
	jsr	_LVORemICRVector(A6)		; Stop only the CIA-B interrupt - since the other one
*						; is raised by software...

	moveq	#0,D0
_exit
	move.l	D0,D2

	tst.l	_Memory(A4)
	beq.s	1$

	movea.l	_SysBase(A4),A6
	movea.l	_Memory(A4),A1
	move.l	#AUDSIZE,D0
	jsr	_LVOFreeMem(A6)

1$
	move.l	_ThisTask(A4),A0
	move.l	D2,pr_Result2(A0)		; Set error code to process
	lea	tb_SIZEOF(sp),sp		; Restore stack
	move.l	D2,D0
	rts

_ErrorTimer
	moveq	#50,D0
	bra.s	_exit

_ErrorOpenResource
	moveq	#100,D0
	bra.s	_exit

*
** D0/D1/A0/A1/A5/A6 scratch registers
*
_IRQCode	; Through CIA-B hardware caused interrupt...
	movea.l	A1,A5				; IS_DATA

	move.l	_Counter(A5),D0			; Current position for data to be stored
	cmpi.l	#AUDSIZE,D0			; End of buffer reached?
	bne.s	.getaud				; If so...

	moveq	#0,D0

.getaud
	movea.l	_Memory(A5),A0
	lea	_ciaa,A1			; CIA-A hardware address

	move.b	ciaprb(A1),D1			; Get byte at parallel device
	addi.b	#128,D1				; Make a signed byte
	move.b	D1,0(A0,D0.l)			; Store the byte

	addq.l	#1,D0				; One more stored
	move.l	D0,_Counter(A5)			; and remember amount

	cmpi.l	#4,D0				; Indicator for start audio (leading bytes)
	bne.s	.out				; If not...

	tst.l	_AudioHit(A5)			; If already fired up audio...
	bne.s	.out

	lea	_IRQCause(A5),A1
	movea.l	_SysBase(A5),A6
	jsr	_LVOCause(A6)			; Start audio hardware once

.out
	lea	$DFF000,A0			; In case of a VBlank IRQ...
	moveq	#0,D0				; Set Z-Flag
	rts

*
** D0/D1/A0/A1/A5 scratch registers - A6 must remain intact
*
_IRQCauseCode	; Executed each ~1/16688 second - regardless what for a machine and which power supply!
	movea.l	A1,A5				; IS_DATA

	tst.l	_AudioHit(A5)			; Already fired up audio channel 0?
	bne.s	.out2				; If so...

	bsr.s	.startaudio

.out2
	moveq	#0,D0				; Ready and out
	rts


.startaudio
	movea.l	_Memory(A5),A0			; Address CHIP memory
	lea	_custom,A1			; DMA hardware address

	move.l	A0,aud0+ac_ptr(A1)		; Address memory
	move.w	#AUDSIZE/2,aud0+ac_len(A1)	; Amount in words of data
	move.w	#214,aud0+ac_per(A1)		; Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud0+ac_vol(A1)		; Full volume

	move.l	A0,aud1+ac_ptr(A1)		; Address memory
	move.w	#AUDSIZE/2,aud1+ac_len(A1)	; Amount in words of data
	move.w	#214,aud1+ac_per(A1)		; Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud1+ac_vol(A1)		; Full volume

	move.l	A0,aud2+ac_ptr(A1)		; Address memory
	move.w	#AUDSIZE/2,aud2+ac_len(A1)	; Amount in words of data
	move.w	#214,aud2+ac_per(A1)		; Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud2+ac_vol(A1)		; Full volume

	move.l	A0,aud3+ac_ptr(A1)		; Address memory
	move.w	#AUDSIZE/2,aud3+ac_len(A1)	; Amount in words of data
	move.w	#214,aud3+ac_per(A1)		; Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud3+ac_vol(A1)		; Full volume

	move.w	#$800F,dmacon(A1)		; Turn on audio channels 0 - 4

	st.b	D0
	move.l	D0,_AudioHit(A5)		; Indicate audio started
	rts


_PAL_NTSC_Times
	dc.w	42,43		709379/16688 = ~42, 715909/16688 = ~43	(1/16688 second till next
*				IRQ will be raised)
_IRQName
	dc.b	'AudioGrabber',0
_CIABName
	dc.b	'ciab.resource',0

	END

---

Zitat:

---

...mehr noch, das hätte den durchschnittlichen C-Programmierer nur durcheinander gebracht.

Zitat:

---

Der "durchschnittliche" C-Programmierer geht jedesmal mit einer "Black Box"-Struct um, wenn er eine Datei öffnet (FILE *).

---

---

Es geht nicht um das Abstrahieren selber und auch nicht um die Implementierung. Jeder kann das machen wie es ihm beliebt.
Was ich mit einfachen Worten versucht habe aufzuzeigen, und was mir wieder nicht gelungen ist, dass unter Verwendung eines anderen Datentyps, der Nutzer dieser Funktionen, keinen Einblick in die Materie bekommt und auch nicht benötigt, um diese Funktionen zu verwenden.
Da der Quellcode offen liegt und nur aus einer Datei besteht, ist die Einführung eines anderen Datentyps zwar möglich, würde aber den durchschnittlichen C-Programmierer (und als solchen bezeichne ich mich selber) durcheinander bringen, weil dann in den entsprechenden Routinen gecastet werden muss - und das ist bestimmt dem Lesen nicht förderlich.

Es steht Dir und anderen frei, das Beispiel so zu modifizieren, dass Diplom-Informatiker daran ihre Freude finden - und ich wette, dass ich dann Schwierigkeiten hätte, meinen, von euch verwendeten Code, zu verstehen.


Gruß

Zitat:

---

...und vor allem munter mit anderen, völlig falschen Zeigern zu mischen. "void*", bzw. das zugehörige #define'd "APTR" wird ja gerade im AmigaOS sehr gerne eingesetzt, mit den entsprechenden Nachteilen.

---

Zitat:

---

Es gibt gar keinen Grund, "void*" einzusetzen, wenn man eine Struktur kapseln will. Man kann einfach "struct Foo;" deklarieren, und "struct Foo*" für seinen Funktionen verwenden--gekapselt, da Inhalt für den Aufrufer nicht bekannt, trotzdem typsicher, da struct Foo*" trotzdem etwas anderes als "struct Bar*" wäre.

---

Zitat:

---

Ich denke nicht, daß SoftInterrupts so häufig Verwendung finden, es sei denn, man möchte dafür Sorge tragen, daß einen das Multitasking nicht bei zeitkritischen Aufgaben ausbremst. Hardware-Interrupts sind meiner Meinung nach eigentlich häufiger anzutreffen (u.A. für die CIA-Timer).

---

Zitat:

---

Wenn ich ehrlich bin muß ich sagen, daß ich dieses Beispiel für Anfänger wesentlich schwerer zu durchschauen finde, weil dort nicht so wirklich klar wird, auf welche Weise der SoftInt "aufgerufen" wird bzw. was diesen Interrupt eigentlich auslöst.

---

Zitat:

---

Es wird auch nicht ganz klar, welchen Nutzen man daraus ziehen kann, daß "andere Interrupts" davon aufgerufen werden können.

---

Das geht noch tiefer in die Materie als geplant...
Sei's drum.
Bestimmte Gerätetreiber und Hardwarekomponenten darf man nur von niederwertigen Interrupts aus aufrufen - da diese selber Interrupts oder DMAs verwenden. Um einen Systemabsturz zu vermeiden, ist man dann normalerweise gezwungen, Cause() von innerhalb eines höherwertigen Interrupts aus aufzurufen, was wiederum mehr Sorgfalt und Arbeit bei der Programmierung bedeutet.

Als Beispiel:
Versuche mal innerhalb eines CIA-B Interrupts (erstes Beispiel) das Audio-Device zu benutzen - und poste hier mal die GURUs, falls Du das Glück hast, das noch welche ausgegeben werden können...

Zitat:

---

Für die Vorstellung Vieler dürfte ein Interrupt etwas "im Wesen deutlich verschiedenes" zu Tasks/Prozessen sein, diese Beispiel zeigt aber im Grunde (korrigiere mich, wenn ich da falsch liege) einen Task, der teilweise aus dem "normalen" Multitasking rausgenommen und auf Interrupt-Ebene verlagert wurde.

---

Korrigiert?
Korrigiert!

Wie oben beschrieben, ist es ein echter Interrupt - nur halt niederwertiger.

Zitat:

---

Ich denke nicht, daß ein Unerfahrerener so ohne weiteres kapiert, daß dieser "Interrupt" quasi wie ein normaler Task via Signal vom timer.device "aufgeweckt" wird (was ja keineswegs der landläufigen Vorstellung von einem Interrupt entspricht).

---

Wie gesagt, deshalb habe ich ja auch versucht zu erklären, warum ich so gerne das Ganze abstrahiert hätte. Ist mir ganz klar nicht gelungen.
Ich hätte zudem darauf hinweisen müssen, dass nicht das Timer-Device den Interrupt auslöst sondern nur anfordert.
Auslöser ist Cause() - und das verursacht den Level-1 Interrupt - durch das Setzen des 2. Bits im INTREQ Register ($DFF09C). Damit ist wiederum der Hardwarebaustein gefunden, der erst einen Level-1 Interrupt unter Classics ermöglicht, Agnus.

Zitat:

---

[...] (er hackt ganz gern ).

---

Dann könnte er sich auch simultan in der Linux-Gemeinde betätigen; dort scheint hacken eine Art Sport zu werden.
Vielleicht schafft's Hacken auch als Olympische Disziplin anerkannt zu werden... wer weiß.

Zitat:

---

Ich fand das erste Beispiel jedenfalls schön praxisbezogen und gut dokumentiert, Abstraktion wie im letzten Beispiel ist eigentlich ein Thema für fortgeschrittenere Programmierer und für seine Zwecke auch gar nicht wirklich nötig.

---

Richtig, es war auch nicht für ihn gedacht - sondern für die, die systemkonform programmieren müssen und/oder die sich nicht mit Details auseinander setzen wollen, da man die Routinen so wie sie sind, verwenden kann ( InitIRQ(), StartIRQ(), DeleteIRQ() ).
Alles andere, also die Implementierung selber, soll der Nutzer ja gar nicht sehen und auch darüber keinen Kopf machen.
Wie gesagt, den Datentyp wollte ich verstecken - das geht aber nicht bei nur einem Quellcode...
Stelle Dir vor, die drei Funktionen wären in einer Link-Lib. Der Datentyp den InitIRQ() zurückgibt würde in einer Include-Datei mit "VOID *" spezifiziert anstatt mit "struct TimeOutIRQData *" - und nur die drei Funktionen wüssten, das "VOID *" in Wirklichkeit "struct TimeOutIRQData *" wäre. Wäre es dann nicht extrem leicht für einen Nutzer, diese Funktionen zu verwenden?


Ciao - ich bin raus

Zitat:

---

Das Beispiel ist wirklich primitiv.

Nicht für mich.

---

Tschuldigung, aber ich glaube Du machst Dich nur selber bange.

Also, erstmal relaxen!

Das erste Buch, das ich zum Thema Programmierung gelesen habe, fing mit diesen Worten an:
"Wenn Sie bei Bit nicht mehr an Bier denken, sind Sie auf dem richtigen Weg!"

Als ich mich mit C++ beschäftigte, sprangen zwei freundliche Worte mir entgegen:
"Don't panic!"

Das solltest Du auch beherzigen.

Letztendlich ist die Interrupt-Programmierung auf einem Amiga nicht komplizierter als der Rest, den Du mittels Deiner favorisierten Programmiersprache und den Betriebssystemroutinen erzielen kannst.

Ich gestehe, dass Du es schwieriger hast als andere, da Du keine fehlerfreie Compiler-Umgebung besitzt und dementsprechend auch nicht die Beispielprogramme übersetzen kannst, so dass Du letztendlich diese nicht modifizieren kannst, um zu sehen, welche Eingriffe welche Folgen haben.
Programmieren bedeutet auch, Fehler machen zu dürfen, aus denen gelernt werden kann.

Daher kann ich Dir nur dringend ans Herz legen, eine fehlerfreie vbcc-Umgebung zu schaffen, ansonsten wirst Du Dich schwer tun, die Beispielprogramme nachzuvollziehen.

Falls Du nicht weißt woher Du das NDK3.9 bekommen sollst, hier ein Link:
http://aweb.sunsite.dk/files/dev/NDK3.9.lzx

Zitat:

---

Ausser ggf. Optionen und Kommentaren ist es doch alles das selbe.

---

Zitat:

---

Ich hab ASM-Pro.

---

code:

---

*************************************
**
** Copyright © 1997 J.v.d.Loo
*
** Example stuff for the use of one of the two CIA-B timers - in mind
** the RKM Hardware Reference Manual from 1989, Appendix F, page 317 - 333.
*
** By the way: This code is reentrant.
*


	IFD	__G2
		MACHINE	MC68000
		OPT	OW-
		OUTPUT	RAM:AudioGrabber
	ENDC

	include	exec/exec_lib.i
	include	exec/interrupts.i
	include	exec/execbase.i

	include	dos/dos.i
	include	dos/dosextens.i

	include	resources/cia_lib.i

	include	hardware/custom.i
	include	hardware/cia.i


   STRUCTURE	__Table,0
	APTR	_SysBase
	APTR	_CIABBase
	APTR	_ThisTask

	APTR	_Memory
	ULONG	_AudioHit

	ULONG	_Timer				CIA-B Timer A (#0) or B (#1)
	ULONG	_PAL_NTSC			PAL (#0) or NTSC (#2) machine
	ULONG	_Counter

	STRUCT	_IRQStruct,IS_SIZE		CIA-B interrupt structure
	STRUCT	_IRQCause,IS_SIZE		By Cause() required one

	ALIGNLONG
	LABEL	tb_SIZEOF


AUDSIZE	EQU	398				As larger this buffer is as less noises occur (short blips)

_custom	equ	$DFF000
_ciaa	equ	$BFE001
_ciab	equ	$BFD000


_main
	lea	-tb_SIZEOF(sp),sp		Make some room on stack (for data area)
	movea.l	sp,A4				Store address data area into processor register A4

	movea.l	4.w,A6				Get Exec base
	move.l	A6,_SysBase(A4)

	suba.l	A1,A1
	jsr	_LVOFindTask(A6)
	move.l	D0,_ThisTask(A4)		Store address of own process structure

	move.l	#AUDSIZE,D0
	moveq	#MEMF_CHIP,D1
	jsr	_LVOAllocMem(A6)
	move.l	D0,_Memory(A4)
	bne.s	.goon

	moveq	#103,D0
	bra.w	_exit
.goon

	cmpi.b	#50,PowerSupplyFrequency(A6)	Which power frequency?
	bne.s	.NTSC

	clr.l	_PAL_NTSC(A4)			It's PAL
	bra.s	_OpenResource

.NTSC
	move.l	#2,_PAL_NTSC(A4)		It's NTSC


_OpenResource
	lea	_CIABName(pc),A1
	moveq	#0,D0				Any version
	jsr	_LVOOpenResource(A6)		Open it...
	move.l	D0,_CIABBase(A4)
	beq.w	_ErrorOpenResource

*
** Set up CIA-B interrupt structure
*
	lea	_IRQStruct(A4),A0		Initialize IRQ structure I

	clr.l	LN_PRED(A0)			Not really required because the resource
	clr.l	LN_SUCC(A0)			will overwrite it with its own settings

	move.b	#NT_INTERRUPT,LN_TYPE(A0)
	move.b	#32,LN_PRI(A0)

	move.l	A4,IS_DATA(A0)			Pointer to data array

	lea	_IRQCode(pc),A1
	move.l	A1,IS_CODE(A0)			Code to execute

	lea	_IRQName(pc),A1
	move.l	A1,LN_NAME(A0)

*
** Set up Cause() interrupt structure
*
	lea	_IRQCause(A4),A0		Initialize IRQ structure II

	clr.l	LN_PRED(A0)			Not really required - these two are
	clr.l	LN_SUCC(A0)			dynamically changed by Exec

	move.b	#NT_UNKNOWN,LN_TYPE(A0)		Type should be un-known - type assigned by Exec!
	move.b	#32,LN_PRI(A0)			Only -32, -16, 0, +16 and +32 supported!

	move.l	A4,IS_DATA(A0)			Pointer to data array

	lea	_IRQCauseCode(pc),A1
	move.l	A1,IS_CODE(A0)			Code to execute

	lea	_IRQName(pc),A1
	move.l	A1,LN_NAME(A0)

*
** Since the data area is located on the stack and we don't know which values
** the data contain since they are uninitialized, and a call to AddICRVector
** causes immediately the interrupt code to be started and we also avoid a
** Disable() call, we have to initialize _Counter and _AudioHit here:
*
	clr.l	_Counter(A4)
	clr.l	_AudioHit(A4)

*
** Attempt to start one of the CIA-B timer interrupts...
*
	moveq	#0,D2				Start with Timer A
	movea.l	_CIABBase(A4),A6
.try
	lea	_IRQStruct(A4),A1		IRQ to execute (immediately)
	move.l	D2,D0				Timer (which one?)
	jsr	_LVOAddICRVector(A6)
	tst.l	D0
	beq.s	_GotIRQ				If the interrupt is free

	addq.b	#1,D2				Next timer
	cmpi.b	#2,D2				Timer C?
	beq.w	_ErrorTimer			Timer C does not exist!
	bra.s	.try				Else try Timer B

_GotIRQ
	move.l	D2,_Timer(A4)			Save indicator for later (0 = Timer A, 1 = Timer B)

	lea	_ciab,A0			CIA-B hardware address ($BFD000)

	move.l	_PAL_NTSC(A4),D0		0 or 2
	lea	_PAL_NTSC_Times(pc),A1
	move.w	0(A1,D0.l),D0			PAL time or NTSC time value to delay between each occurring

	tst.l	_Timer(A4)			0 or 1
	bne.s	_TimerB				1 = Timer B

_TimerA
	move.b	ciacra(A0),D1			Control register Timer A
	andi.b	#%10000000,D1			Select mode (bit 7 currently unused)
	ori.b	#1,D1				Set Timer A to start
	move.b	D1,ciacra(A0)
	move.b	#%10000001,ciaicr(A0)		Enable Timer A

	move.b	D0,ciatalo(A0)			Write delay time into registers
	lsr.w	#8,D0
	move.b	D0,ciatahi(A0)
	bra.s	_ok				Done

_TimerB
	move.b	ciacrb(A0),D1			Control register Timer B
	andi.b	#%10000000,D1			Select mode
	ori.b	#1,D1				Set Timer B to start
	move.b	D1,ciacrb(A0)
	move.b	#%10000010,ciaicr(A0)		Enable Timer B

	move.b	D0,ciatblo(A0)			Write delay time into registers
	lsr.w	#8,D0
	move.b	D0,ciatbhi(A0)

_ok

*	btst	#CIAB_GAMEPORT0,_ciaa		Left mouse button (a busy loop - a absolute taboo)
*	bne.s	_wait				- so we use the following construct:

	move.l	#SIGBREAKF_CTRL_C,D0		Wait for a control-c signal, when pressed,
	movea.l	_SysBase(A4),A6			awake us,
	jsr	_LVOWait(A6)			otherwise sleep...

	lea	_custom,A0
	move.w	#15,dmacon(A0)			Turn off audio channels 0 - 4

	movea.l	_CIABBase(A4),A6
	lea	_IRQStruct(A4),A1
	move.l	_Timer(A4),D0
	jsr	_LVORemICRVector(A6)		Stop only the CIA-B interrupt - since the other one
*						is raised by software...

	moveq	#0,D0
_exit
	move.l	D0,D2

	tst.l	_Memory(A4)
	beq.s	1$

	movea.l	_SysBase(A4),A6
	movea.l	_Memory(A4),A1
	move.l	#AUDSIZE,D0
	jsr	_LVOFreeMem(A6)

1$
	move.l	_ThisTask(A4),A0
	move.l	D2,pr_Result2(A0)		Set error code to process
	lea	tb_SIZEOF(sp),sp		Restore stack
	move.l	D2,D0
	rts

_ErrorTimer
	moveq	#50,D0
	bra.s	_exit

_ErrorOpenResource
	moveq	#100,D0
	bra.s	_exit

*
** D0/D1/A0/A1/A5/A6 scratch registers
*
_IRQCode	; Through CIA-B hardware caused interrupt...
	movea.l	A1,A5				IS_DATA

	move.l	_Counter(A5),D0			Current position for data to be stored
	cmpi.l	#AUDSIZE,D0			End of buffer reached?
	bne.s	.getaud				If so...

	moveq	#0,D0

.getaud
	movea.l	_Memory(A5),A0
	lea	_ciaa,A1			CIA-A hardware address

	move.b	ciaprb(A1),D1			Get byte at parallel device
	addi.b	#128,D1				Make a signed byte
	move.b	D1,0(A0,D0.l)			Store the byte

	addq.l	#1,D0				One more stored
	move.l	D0,_Counter(A5)			and remember amount

	cmpi.l	#4,D0				Indicator for start audio (leading bytes)
	bne.s	.out				If not...

	tst.l	_AudioHit(A5)			If already fired up audio...
	bne.s	.out

	lea	_IRQCause(A5),A1
	movea.l	_SysBase(A5),A6
	jsr	_LVOCause(A6)			Start audio hardware once

.out
	lea	$DFF000,A0			In case of a VBlank IRQ...
	moveq	#0,D0				Set Z-Flag
	rts

*
** D0/D1/A0/A1/A5 scratch registers - A6 must remain intact
*
_IRQCauseCode	; Executed each ~1/16688 second - regardless what for a machine and which power supply!
	movea.l	A1,A5				IS_DATA

	tst.l	_AudioHit(A5)			Already fired up audio channel 0?
	bne.s	.out				If so...

	bsr.s	.startaudio

.out
	moveq	#0,D0				Ready and out
	rts


.startaudio
	movea.l	_Memory(A5),A0			Address CHIP memory
	lea	_custom,A1			DMA hardware address

	move.l	A0,aud0+ac_ptr(A1)		Address memory
	move.w	#AUDSIZE/2,aud0+ac_len(A1)	Amount in words of data
	move.w	#214,aud0+ac_per(A1)		Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud0+ac_vol(A1)		Full volume

	move.l	A0,aud1+ac_ptr(A1)		Address memory
	move.w	#AUDSIZE/2,aud1+ac_len(A1)	Amount in words of data
	move.w	#214,aud1+ac_per(A1)		Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud1+ac_vol(A1)		Full volume

	move.l	A0,aud2+ac_ptr(A1)		Address memory
	move.w	#AUDSIZE/2,aud2+ac_len(A1)	Amount in words of data
	move.w	#214,aud2+ac_per(A1)		Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud2+ac_vol(A1)		Full volume

	move.l	A0,aud3+ac_ptr(A1)		Address memory
	move.w	#AUDSIZE/2,aud3+ac_len(A1)	Amount in words of data
	move.w	#214,aud3+ac_per(A1)		Period 214 ~= 16688 Hz, "C-3"
	move.w	#64,aud3+ac_vol(A1)		Full volume

	move.w	#$800F,dmacon(A1)		Turn on audio channels 0 - 4

	st.b	D0
	move.l	D0,_AudioHit(A5)		Indicate audio started
	rts


_PAL_NTSC_Times
	dc.w	42,43		709379/16688 = ~42, 715909/16688 = ~43	(1/16688 second till next
*				IRQ will be raised)
_IRQName
	dc.b	'AudioGrabber',0
_CIABName
	dc.b	'ciab.resource',0

	END

---

Zitat:

---

OS4 kommt bald für Classic, dann gibts CIA's.

---

Zitat:

---

Also, ich hab das 1. AudioGrabber gerade mal durch den vbcc gescheucht (Cubic-Installation), Compilerlauf war völlig problemlos (keine Warnungen oder Fehler).

---

Pweeh. Und ich hatte schon die Befürchtung, dass ich etwas falsch bei den manuellen Installationen gemacht hätte.

Zitat:

---

Groß auf Funktion testen konnte ich es mangels Sampler allerdings nicht ;-)

---

Zitat:

---

Ein Knackser zum Start dürfte aber darauf hinweisen, daß es versucht, Audio abzuspielen. Beenden ließ es sich mit Break-C ebenfall problemlos.

---

Zitat:

---

Nachtrag: Es scheint aber die Sound-Emulation von WinUAE zu beeinflussen, der Windows-Sound klingt reichlich verbogen nach Start des Audio-Grabber. Eine Ahnung, was dafür verantwortlich sein könnte?

---

Zitat:

---

Sehr schönes Beispiel für Interrupts in C übrigens, vielen Dank dafür!

---

code:

---

/* vc -c99 -cpu=68020 -O1 -sc -sd TimerIRQ.c -o TimerIRQ -lvcs -lamigas */

#include <exec/memory.h>
#include <exec/interrupts.h>
#include <exec/ports.h>
#include <exec/io.h>

#include <dos/dos.h>
#include <dos/dosextens.h>

#include <devices/timer.h>

/* Beide müssen schon geöffnet sein (Startup-Code)... */
extern struct DosLibrary *DOSBase;
extern struct ExecBase *SysBase;

#define __NOLIBBASE__	/* Wir benötigen keine anderen! */

#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/timer.h>

#include <clib/alib_protos.h>


/* Wir müssen Argumente in Registern handhaben */
#ifdef __GNUC__
 #define REG( reg,arg) arg __asm( #reg)
#else
 #ifdef __VBCC__
  #define REG( reg,arg) __reg(#reg) arg
 #else
  #define REG( reg,arg) register __##reg arg
 #endif
#endif


/* MaxonC++/HisoftC++ verstehen kein __saveds - also großes Datenmodell
   verwenden! */
#ifdef __MAXON__
#define __saveds
#endif

/* Interrupt basierend */
#if defined(__SASC) || defined(__STORM__) || defined(__GNUC__)
 #define SUPERIOR __interrupt __saveds
#else
 #if defined(__VBCC__)
 #define SUPERIOR __amigainterrupt __saveds
 #else
   #define SUPERIOR __saveds	/* MaxonC++/HiSoftC++ */
 #endif
#endif


/* Diese drei Flaggen beherrscht unser Interrupt */
#define KILL   -1
#define ALIVE	1
#define KILLED	0

struct TimeOutIRQData
{
	/* Alles Interrupt private Daten - Hände weg! */
	struct MsgPort	 	*TimeOutPort;
	struct Interrupt	*TimeOutIRQ;
	struct timerequest	*TimeOutRequest;
	struct Task			*TimeOutTask;
	ULONG				TimeOutDelay;
	LONG				TimeOutFlag;
	ULONG				TimeOutSignal;
	/* Zeiger auf Benutzer spezifizierte Funktion */
	LONG				(*IRQUsersCode)(APTR);
	/* Zeiger auf Benutzer spezifizierte Daten (Struktur?) */
	APTR				IRQUsersData;
	/* Falls ungleich null, wird ein Signal gesendet */
	LONG				SendSignal;
};



/* Diese Routine wird innerhalb eines Cause()-Aufrufs ausgeführt! */
SUPERIOR LONG IRQCodeEntry( REG(a1, struct TimeOutIRQData *tid) )
{
	struct timerequest *tr;
	LONG i;

	i = 2;

	/* Entferne nur die Nachricht vom Port */
	tr = (struct timerequest *) GetMsg( tid->TimeOutPort);

	/* Während wir (kurzzeitg) leben, können wir dem Hauptprogramm ein Signal geben... */
	if ( (tr) && (tid->TimeOutFlag == ALIVE) )
	{
		/* Falls Benutzer-Code vorhanden, diesen jetzt anspringen */
		if (tid->IRQUsersCode)
			tid->SendSignal = (LONG) tid->IRQUsersCode( (APTR) tid->IRQUsersData);

		/* Falls SendSignal != 0 wird Signal gesendet! */
		if (tid->SendSignal)
			Signal( tid->TimeOutTask, (1 << tid->TimeOutSignal) );

		/* Mit diesem Selbsterhaltenden Trick rufen wir uns in bestimmten
		   Zeitabständen selber auf!
		   NB: BeginIO() darf nur in Verbindung mit den Timer- und
		   Audio-Devices innerhalb eines Interrupts verwendet werden. */
		tr->tr_node.io_Command = TR_ADDREQUEST;
		tr->tr_time.tv_micro = tid->TimeOutDelay;
		BeginIO( (struct IORequest *) tr);
	}
	else	/* Upps, wir sollen Selbstmord begehen... */
	{
		/* Sage Hauptprogramm, dass wir's nicht geschafft haben... ;-) */
		tid->TimeOutFlag = KILLED;
	}

	return i - 2;
}

/*
 * Initialisiere einen Interrupt:
 * @callsPerSecond:	Wie oft pro Sekunde soll ein Interrupt generiert werden?
 * @irqname:		Der Name anhand dessen der Interrupt identifiziert werden
 *					kann.
 * @usersCode:		Routine, die im Interrupt abgearbeitet werden soll - darf
 *					natürlich auch NULL sein - dann wird halt nichts anderes
 *					gemacht, als in bestimmten Zeitabständen ein Signal an
 *					das Hauptprogramm zu senden.
 *					Falls usersCode spezifiziert wurde, wird nur dann ein
 *					Signal ans Hauptprogramm gesendet, wenn diese Routine
 *					einen Wert ungleich null zurück gibt (Returncode).
 * @usersData:		Zeiger auf eine Variable oder Struktur die usersCode
 *					empfängt (m68k Stack, PPC Register)
 */

struct TimeOutIRQData *InitIRQ( ULONG callsPerSecond,  STRPTR irqname,
				LONG (*usersCode)(), APTR usersData)
{
	struct TimeOutIRQData *tid;

	/* Globale Struktur, die mit dem Interrupt geteilt wird */
	if ( (tid = (struct TimeOutIRQData *)
		 AllocVec( sizeof (struct TimeOutIRQData),
	 		   MEMF_PUBLIC | MEMF_CLEAR)) )
	{
		/* Für einen MessagePort, benutzt von einem Interrupt, benötigen
		   wir kein Signal - also CreatePort() und/oder CreateMsgPort()
		   nicht benutzen! */
		if ( (tid->TimeOutPort = (struct MsgPort *)
					  AllocVec( sizeof (struct MsgPort),
		  			MEMF_PUBLIC | MEMF_CLEAR)) )
		{
			/* Initialisiere Message-Liste */
			NewList( &(tid->TimeOutPort->mp_MsgList));

			/* Die Interrupt-Struktur selber... */
			if ( (tid->TimeOutIRQ = (struct Interrupt *)
						AllocVec( sizeof (struct Interrupt),
								  MEMF_PUBLIC | MEMF_CLEAR)) )
			{
				/* Software-Interrupts dürfen nur Prioritäten mit Werten
				   von -32, -16, 0, +16, +32 besitzen - und der korrekte
				   Typ für Software-Interrupts ist NT_INTERRUPT */
				tid->TimeOutIRQ->is_Node.ln_Name = irqname;	/* Brandmarke... */

				/* Je niedriger, desto besser... */
				tid->TimeOutIRQ->is_Node.ln_Pri = -32;

				/* Software-Interrupt's Einstieg */
				tid->TimeOutIRQ->is_Code = (void (*)()) IRQCodeEntry;

				/* Wir übergeben eigene Struktur */
				tid->TimeOutIRQ->is_Data = tid;

				/* Es ist ein MessagePort */
				tid->TimeOutPort->mp_Node.ln_Type = NT_MSGPORT;

				/* ...und wird von einem Interrupt verwendet. */
				tid->TimeOutPort->mp_Flags = PA_SOFTINT;

				/* Interrupt's Adresse */
				tid->TimeOutPort->mp_SigTask = (struct Task *) tid->TimeOutIRQ;

				/* Einen "TimeRequest" initialisieren. */
				if ( (tid->TimeOutRequest = (struct timerequest *)
						CreateExtIO( tid->TimeOutPort, sizeof (struct timerequest))) )
				{
					/* Öffne Timer-Device. NULL heißt Zugriff! */
					if ( !(OpenDevice( "timer.device",
							UNIT_MICROHZ,
							(struct IORequest *) tid->TimeOutRequest,
							0)))
					{
						/* Wenn der Interrupt auf diese Flagge stößt, weiß
						   er, dass er laufen darf */
						tid->TimeOutFlag = ALIVE;

						/* Das Signal, auf welches das Hauptprogramm zu
						   reagieren hat... */
						tid->TimeOutSignal = AllocSignal( -1L);

						if (tid->TimeOutSignal != -1L)
						{
							/* Lass den Interrupt wissen, an wen das betreffende
							   Signal gesendet werden muss */
							tid->TimeOutTask = FindTask( NULL);

							/* Wie oft pro Sekunde soll ein Interrupt generiert
							   werden? */
							tid->TimeOutDelay = 1000000 / callsPerSecond;

							/* Der Benutzer-Code */
							tid->IRQUsersCode = (LONG (*)(APTR)) usersCode;

							/* ...und die Daten, die der Code empfängt */
							tid->IRQUsersData = usersData;

							/* Standardmäßig wird bei jedem generierten
							   Interrupt ein Signal gesendet */
							tid->SendSignal = 1;

							return tid;	/* Alles in Butter! */
						}
						CloseDevice( (struct IORequest *) tid->TimeOutRequest);
					}
				}
				DeleteExtIO( (struct IORequest *) tid->TimeOutRequest);
			}
			FreeVec( tid->TimeOutIRQ);
		}
		FreeVec( tid->TimeOutPort);
	}
	FreeVec( tid);

	return NULL;	/* Irgendein Fehler... */
}

/*
 * Nach der Initialisierung wollen wir natürlich auch den Interrupt
 * starten.
 */
void StartIRQ( struct TimeOutIRQData *tid)
{
	/* Das Kommando, welches wir benutzen müssen... */
	tid->TimeOutRequest->tr_node.io_Command = TR_ADDREQUEST;

	/* Der Wert, nachdem ein Interrupt generiert wird. */
	tid->TimeOutRequest->tr_time.tv_micro = tid->TimeOutDelay;

	/* Starte Interrupt. */
	BeginIO( (struct IORequest *) tid->TimeOutRequest);
}


/*
 * Interrupt und Ressourcen freigeben.
 */
void DeleteIRQ( struct TimeOutIRQData *tid)
{
	tid->TimeOutFlag = KILL;

	/* Spiele nicht mit einem aktiven Interrupt herum... */
	/* ...das System könnte ärgerlich reagieren (GURU) */
	while (tid->TimeOutFlag != KILLED)
		Delay( 5);

	FreeSignal( tid->TimeOutSignal);
	CloseDevice( (struct IORequest *) tid->TimeOutRequest);
	DeleteExtIO( (struct IORequest *) tid->TimeOutRequest);
	FreeVec( tid->TimeOutIRQ);
	FreeVec( tid->TimeOutPort);
	FreeVec( tid);
}


/*
 * Damit die Struktur privat bleibt, müssen wir eine Funktion einführen,
 * damit man das Signal-Bit auslesen kann.
 */
ULONG GetIRQsSignalBit( struct TimeOutIRQData *tid)
{
	return tid->TimeOutSignal;
}


/*
 * Kleines Gimmick - wir können dem Interrupt auch eine neue Zeitspanne
 * zuweisen:
 */
void SetNewIRQDelay( struct TimeOutIRQData *tid, ULONG callsPerSecond)
{
	/* Wie oft pro Sekunde soll ein Interrupt generiert werden? */
	tid->TimeOutDelay = 1000000 / callsPerSecond;
}


/* Hauptprogramm */
int main( int argc, char **argv)
{
	struct TimeOutIRQData *tid;
	BOOL alive;
	ULONG received, counter;

	/* Bitte, keine Werte größer 15 verwenden - I/O Operationen (VFPrintf) sind langsam... */
	tid = InitIRQ( 15, "15-mal pro Sekunde IRQ", NULL, NULL);
	if (tid)
	{
		alive = TRUE;
		counter = 0;

		StartIRQ( tid);

		while (alive)
		{
			counter ++;

			received = Wait( SIGBREAKF_CTRL_C | (1 << GetIRQsSignalBit( tid)) );
			if (received & SIGBREAKF_CTRL_C)
				alive = FALSE;
			else
				VFPrintf( Output(),
					  "Signal vom Interrupt eingetroffen, zum %ld-mal!n",
					  (CONST APTR) &counter );
		}

		DeleteIRQ( tid);
	}

	return 0;
}

---

code:

---

LONG MyCode( ULONG *cnt)
{
	*cnt = *cnt + 1;
	if (*cnt % 15)
		return 0;
	else
		return 1;	/* Nur jeder 15. Aufruf veranlasst uns, ein Signal zu
					   senden (jede halbe Sekunde) */ 
}


/* Hauptprogramm */
int main( int argc, char **argv)
{
	struct TimeOutIRQData *tid;
	BOOL alive;
	ULONG received, counter;

	tid = InitIRQ( 30, "30-mal pro Sekunde IRQ", (LONG (*)()) &MyCode, &counter);
	if (tid)
	{
		alive = TRUE;
		counter = 0;

		StartIRQ( tid);

		while (alive)
		{
			received = Wait( SIGBREAKF_CTRL_C | (1 << GetIRQsSignalBit( tid)) );
			if (received & SIGBREAKF_CTRL_C)
				alive = FALSE;
			else
				VFPrintf( Output(),
					  "Signal vom Interrupt eingetroffen, Zähler = %ld.n",
					  (CONST APTR) &counter );
		}

		DeleteIRQ( tid);
	}

	return 0;
}

---

Wenn ich ganz ehrlich bin, gefällt mir dieser Interrupt-Typ wesentlich besser.

Gruß

Zitat:

---

Entweder Du benutzt einen Interrupt oder eine Schleife in Deinem Hauptprogramm, die mittels des Timer-Device eine bestimmte Zeit wartet.

Zitat:

---

Wie das theoretisch mit dem Timer-Device funktionieren sollte weiss ich selbstverständlich. Nur geht dieses nicht für 16000 HZ, nur bis 12000 HZ geht das sauber. Das auch nur unter einem 060er.

---

---

Zitat:

---

Du verstehst den Begriff Interrupt nicht richtig.

Zitat:

---

Doch, doch. Nur ist es vermutlich einfacher für mich diesen CIA-Countdown zu starten und dann auf eine 0 im entsprechenden Register zu warten.

---

---

Nix da mit warten via Polling!
Wenn ein Prozess 16000-mal pro Sekunde Rechenzeit vom Betriebssystem verlangt, wird er ganz schnell ganz langsam.
Den Grund habe ich oben genannt - der Scheduler lässt dies gar nicht zu.

Deshalb wird im 2. Beispiel (AudioGrabber2) nur dann der Prozess via Signal-Bit benachrichtigt, wenn ein Puffer voll ist; Interrupts werden vom Task-Scheduler ignoriert.
Da beide verwendeten Puffer in diesem Beispiel für 2 Sekunden Sampling ausreichend sind, bekommt der Prozess alle 2 Sekunden eine Nachricht die besagt, dass einer der beiden Puffer voll ist - also 32 KBytes an Daten empfangen wurden.

Nochmals, der Interrupt läuft ständig - und füllt zwei Puffer, je 32 KBytes groß. Falls einer der Puffer voll ist, wird ein Signal an das Hauptprogramm gesendet; nun kann das Hauptprogramm diese Daten auswerten (oder kopieren), bis es wieder ein Signal vom Interrupt erhält, dass der andere Puffer auch voll ist, was zudem bedeutet, dass der Inhalt des ersten Puffers von jetzt an überschrieben wird. Beim nächsten Eintreffen des Signals wird der Pufferinhalt des zweiten Puffers überschrieben - und so fortlaufend, bis Du den Interrupt beendest.
Analog zum Füllen der beiden Puffer, wird ein Puffer zur Audioausgabe verwendet - also drei Puffer:

code:

---

SUPERIOR ULONG CIAB_Code( REG(a1, struct InterruptData *irq_data) )
{
	char data_byte;
	LONG i;
	UBYTE *buffer;

	i = 2;

	--> Lese Byte und setze Vorzeichen
	data_byte = ciaa->ciaprb;
	data_byte += 128;

	--> Audio-Puffer: Falls Daten darin noch Platz finden, Daten-Byte ablegen.
	if (AudioDataOffset < AUDIOSIZE)
	{
		AudioBuffer[AudioDataOffset] = data_byte;
		AudioDataOffset++;
	}
	else	--> Ansonsten, fange wieder bei null an.
	{
		AudioDataOffset = 0;
		AudioBuffer[AudioDataOffset] = data_byte;
		AudioDataOffset++;
	}

	--> Anbei: Die Audiohardware spielt ununterbrochen von diesem Puffer!

	--> Nur falls wir noch nicht die Audio-Ausgabe anwarfen, machen wir das
	--> jetzt - und zwar einmalig - die Audiohardware kümmert sich um den Rest.
	if (AudioDataOffset == STARTOFFSET)
	{
		if ( !AudioHit)
			Cause( Soft_IRQ);	--> Starte Audiohardware.
	}

	--> So, jetzt geht's mit den beiden anderen Puffern los!

	--> Passt das Daten-Byte noch in den aktuell verwendeten Puffer?
	--> ( singleBufSize = 32768 )
	--> ( dataIndex - irgendwo zwischen 0 und 32767 )
	if (irq_data->dataIndex < irq_data->singleBufSize)
	{
		--> Yep, passt.
		--> Welchen Puffer verwenden wir gerade: den ersten oder zweiten?
		--> ( bufIndex ist entweder 0 oder 1 (für zwei Puffer) und somit
		--> zeigt bufPtr[0] auf den ersten und bufPtr[1] auf den zweiten )
		buffer = irq_data->bufPtr[irq_data->bufIndex];

		--> Jetzt müssen wir die aktuelle Puffer-Position (0 bis 32767)
		--> noch auf die Adresse addieren, und wir wissen wo das Daten-Byte
		--> eingeschoben werden soll.
		buffer += irq_data->dataIndex;

		--> Schreibe das Daten-Byte in den Puffer
		*buffer = (UBYTE) data_byte;

		--> Position (irgendwo zwischen 0 - 32767) plus 1
		irq_data->dataIndex = irq_data->dataIndex + 1;
	}
	else
	{
		--> Nö, Daten-Byte passt nicht mehr (Position (dataIndex) = 32768)

		--> In der übermittelten Struktur setzen wir jetzt "filledBuffer"
		--> auf die Adresse des vollen Puffers. Diese Variable kann dann
		--> das Hauptprogramm auslesen.
		irq_data->filledBuffer = irq_data->bufPtr[irq_data->bufIndex];

		--> Jetzt testen, ob wir noch einen weiteren Puffer zur Verfügung haben
		--> oder ob wir einen bestehenden Pufferinhalt überschreiben müssen.
		--> ( amountBuffer hat den Wert zwei - für 2 Puffer - und bufIndex ist
		--> entweder 0 oder 1 )
		if ( (irq_data->amountBuffers - 1) > irq_data->bufIndex)
			irq_data->bufIndex = irq_data->bufIndex + 1;	--> Nächster Puffer
									--> (bei nur zwei
									--> Puffern, immer
									--> der zweite)
		else
			irq_data->bufIndex = 0;		--> Ersten Puffer wieder verwenden

		--> Welchen Puffer verwenden wir gerade: den ersten oder zweiten?
		--> Anbei, Du könntest auch vier Puffer verwendet, diese Routine verkraftet
		--> das...
		buffer = irq_data->bufPtr[irq_data->bufIndex];

		--> Da wir sowieso mit dem ersten Byte im Puffer (Position == 0) beginnen,
		--> können wir uns das Errechnen der Position sparen.
		*buffer = (UBYTE) data_byte;

		--> Nächste Position, also dort wo das nächste Daten-Byte abgelegt wird,
		--> ist Position 1, da wir gerade Position 0 mit dem Daten-Byte belegt
		--> haben.
		irq_data->dataIndex = 1;

		--> Signalisiere Hauptprogramm, das ein Puffer voll ist.
		Signal( irq_data->mainTask, (1 << irq_data->sigBit));
	}

---

code:

---

while (alive == TRUE)
{
	received = Wait( SIGBREAKF_CTRL_C|(1 << signalBit));
	if (received & SIGBREAKF_CTRL_C)
		alive = FALSE;
	else
		VFPrintf( Output(),
			  "Buffer at address 0x%08lx full!n",
			  (CONST APTR) &(IRQData->filledBuffer) );
}

---

Zitat:

---

Es wäre hilfreich, wenn Du ein klein wenig "C" verstehen würdest.

Zitat:

---

Ich kann schon etwas C, nur hab ich noch nie mit Interrupts gearbeitet.

---

---

Zitat:

---

Ich weiß nicht wie gut Deine Assembler-Kenntnisse sind; wenn sie ausreichend sind, kann ich die entsprechenden Fragmente auch als Assembler-Quellcode posten; das Original wurde eh in 68k-Assembler verfasst.

---

Zitat:

---

Mittlerweile kann ich C besser als Assembler.
Obwohl in ASM könnte man es sicherlich "Compilieren".

---

Zitat:

---

Sieh den Interrupt-Code als zweites, eigenständiges Programm, das simultan zu Deinem Hauptprogramm läuft.

Zitat:

---

Also müsste ich alles ausser "SUPERIOR" in MBasic übersetzten und SUPERIOR währe dann der Interrupt welchen ich per ASM einbinden könnte.

---

---

Zitat:

---

Es gibt zwei Möglichkeiten.
Entweder habe ich Compiler-Umgebungen die kein anderer hat oder Du hast eine fehlerhafte.

Zitat:

---

Ich habe schon erfolgreich andere progs damit Compiliert.

---

---

Zitat:

---

Unter gcc, vbcc und MaxonC++ sind diese Beispiele in meinen Umgebungen kompilierbar.

Zitat:

---

Muss mal gcc probieren aber bei den war die Installation so kompliziert
das ich mir bei dem tatsächlich nicht sicher bin ob der geht.

---

---

Zitat:

---

und

---

Zitat:

---

1. In kontinuierlichen Zeitabständen ein Byte vom parallelen Port lesen.
2. Dieses Byte vorzeichengerecht irgendwo ablegen.
3. Den Vorgang wiederholen.

Zitat:

---

Ja, wobei 1./ Zeitabstände das Problem sind

---

---

Zitat:

---

Ob Du nun einen Interrupt verwendest liegt ganz allein bei Dir.

Zitat:

---

Also die CIAs zählen runter und lösen einen Interrupt aus.
Könnte ich diesen Interrupt auch per Hardwareregister lesen und zu 0 setzten und dann geht es von vorne los?

---

---

Zitat:

---

Könnte ich diesen Interrupt auch per Hardwareregister lesen und zu 0 setzten und dann geht es von vorne los?

---

Zitat:

---

Interrupts müssen bestimmte Voraussetzungen erfüllen damit es nicht zum Systemabsturz oder Verlangsamung des Systems kommt. Ich gehe davon aus, dass das in Basic nicht so ohne weiteres bewerkstelligt werden kann.

Zitat:

---

Also a0, a1, d2 und d3 dürfen in jedem fall von einem Inline ASM Code verwendet werden.

---

---

Zitat:

---

Ja, also die beiden Dateien hab ich jetzt 1:1 ersetzt die fehlermeldung ändert sich nicht. Beim 2. Source ist es nur eine andere Zeilennummer.

---

Zitat:

---

Wie übermittelst Du den Speicherbereich, welcher die Audiodaten aufnehmen soll?

Zitat:

---

Eigentlich dachte ich mir das so, wenn der Sampler zum Audioausgang geschaltet werden soll starte ich das Programm, wenn z.B. 5 sek um sind stoppe ich es. Gut, wenn ich jetzt mit Puffern arbeiten will muss ich da was übergeben. Aber man kann da irgendwie Daten per Datenregister rüberschicken. Da gibt es ein Beispiel für.

---

---

Zitat:

---

Was macht Dein Programm in der Zeit, wo keine Arbeiten anfallen und nur der Interrupt aktiv ist?
Wie willst Du Deinem Programm signalisieren, dass der Puffer voll ist? Dazu braucht die Interrupt-Routine die Task-Adresse Deiner Anwendung und das Signal-Bit, welches Deine Anwendung aufwachen lässt.

Das Beispiel was ich hier zeigte, ist simpel.

Zitat:

---

Wenn man sich damit schon beschäftigt hat bestimmt...

---

---

Zitat:

---

Werden keine Prozessor-Register zerstört?

Zitat:

---

Kein schimmer.

---

---

Zitat:

---

Wird der Interrupt mit gesetztem Z-Flag beendet?

Zitat:

---

Weiss nichtmal was ein Z-Flag ist, aber MBasic wird wohl nicht wissen was ein Interrupt ist und da nichts machen.

---

---

Zitat:

---

Ist der Code kurz und optimiert genug um das System nicht zu beeinträchtigen?

Zitat:

---

Das Kopieren von einem Byte von Sampler->Buffer bekomme ich auch in Assembler hin(dürften 4 Befehle sein). Nur vorher muss ich genau verstehen wie das mit den CIA's Funktioniert. Z.b. Teilt man den die Adresse des Aufzurufenden Programms im Speicher mit?

---

---

Zitat:

---

Okay, datei 1 hab ich erstellt, datei 2 an die existierende angefügt

---

Zitat:

---

error 1002 in line 45: invalid extension
vasmm68k_mot fehlgeschlagen Rückgabewert 20

---

Zitat:

---

Das ist nicht so einfach, will ich es auf Basic portieren tauchen
etliche neue fragen auf.

---

Zitat:

---

Wenn ich es bei C belasse, kann ich es so lassen wie es ist und als Inline Assembler einbinden.
Oder aber Starten und mittels eines Signals wieder beenden.

---

C code:

---

/*
;: ts=4

Written entirely in the middle of the night.... 05/29/02
Last Modified: 06/03/02

Written by:
	Joerg van de Loo
		using
	MaxonC++ V4

This file is released to Amiga-C group...

*** gekürzt *** (PAB)

*/

#include	<hardware/cia.h>
#include	<hardware/custom.h>
#include	<exec/execbase.h>
#include	<exec/memory.h>
#include	<exec/interrupts.h>
#include	<dos/dos.h>

#include	<clib/cia_protos.h>
#include	<clib/exec_protos.h>


#if !defined(__MAXON__)
#include	<proto/cia.h>
#include	<proto/exec.h>
#else
#include	<pragma/cia_lib.h>
#include	<pragma/exec_lib.h>
#endif


extern struct ExecBase *Sysbase;
struct Library *CiaBase;

struct Interrupt *CIAB_IRQ;
struct Interrupt *Soft_IRQ;

#define custom ((struct Custom *) (0xDFF000))
#define ciaa ((struct CIA *) (0xBFE001))
#define ciab ((struct CIA *) (0xBFD000))

UBYTE *AudioBuffer;
ULONG AudioDataOffset = 0;
ULONG AudioHit = 0;

/* PAL: 709379 Hz / 16688 Hz = 42.50, NTSC: 715909 Hz / 16888 Hz = 42.89 */
UWORD Timeout[2] =
{
 42,43
};

/* 398 bytes required at 16688 Hz (== samples per second) for one loop...
   (16688 / 42)
*/
#define AUDIOSIZE 398

/* When 2 bytes (one sample) have been already fetched, start audio */
#define STARTOFFSET 2

/* ~PERIOD = 1/(Hz*28/10e7) :: 10e7 == 100000000
     or
   1 / (Hz * 0.000000279365)
*/

#define PERIOD 214		/* Equivalent to 16688 Hz... (" C-3 ") */
#define VOLUME 64		/* Max. volume */


UWORD PowerIndex;


#ifdef __GNUC__
 #define REG( reg,arg) arg __asm( #reg)
#else
 #ifdef __VBCC__
  #define REG( reg,arg) __reg(#reg) arg
 #else
  #define REG( reg,arg) register __##reg arg
 #endif
#endif


/* Maxon doesn't support __saveds - so apply a work-around by using large
   data model! */
#ifdef __MAXON__
#define __saveds
#endif

/* Interrupt related */
#if defined(__SASC) || defined(__STORM__) || defined(__GNUC__)
 #define SUPERIOR __interrupt __saveds
#else
 #if defined(__VBCC__)
 #define SUPERIOR __amigainterrupt __saveds
 #else
   #define SUPERIOR __saveds	/* MaxonC++/HiSoftC++ */
 #endif
#endif


const unsigned short __ret_a4_code[] =
{
	0x200C,
	0x4E75
};

/* Make above code accessible as function */
/* Need these assembler instructions here:
	move.l	A4,D0
	rts
*/
const APTR (*__ret_a4)( void) = (const APTR (*) (void)) __ret_a4_code;


/* NOTE: Only the registers D0, D1, A0 and A1 are trashed by my compiler -
   so it works.
   You  may,  of course, use the __saveds keyword to get your local base
   register and to restore the initial content.
   Unfortunately, my compiler doesn't support it.
*/

SUPERIOR ULONG CIAB_Code( REG(a1, APTR data) )
{
	char data_byte;
	LONG i;

	i = 2;
	data_byte = ciaa->ciaprb;	/* Get the data at parallel port */
	data_byte += 128;			/* Make a signed byte */

	if (AudioDataOffset < AUDIOSIZE)
	{
		AudioBuffer[AudioDataOffset] = data_byte;
		AudioDataOffset++;
	}
	else	/* Restart at first data byte in buffer */
	{
		AudioDataOffset = 0;
		AudioBuffer[AudioDataOffset] = data_byte;
		AudioDataOffset++;
	}

	if (AudioDataOffset == STARTOFFSET)
	{
		if ( !AudioHit)
			Cause( Soft_IRQ);	/* Only once called, audio hardware */
	}							/* restarts itself from beginning... */

	return i - 2;	/* For stupid compilers which don't deal with */
}					/* interrupts (MaxonC++/HiSoftC++) */

void StartAudio( void)
{
	custom->aud[0].ac_ptr = (UWORD *) AudioBuffer;
	custom->aud[0].ac_len = AUDIOSIZE / 2;	/* Amount in number of words */
	custom->aud[0].ac_per = PERIOD;
	custom->aud[0].ac_vol = VOLUME;

	custom->aud[1].ac_ptr = (UWORD *) AudioBuffer;
	custom->aud[1].ac_len = AUDIOSIZE / 2;	/* Amount in number of words */
	custom->aud[1].ac_per = PERIOD;
	custom->aud[1].ac_vol = VOLUME;

	custom->aud[2].ac_ptr = (UWORD *) AudioBuffer;
	custom->aud[2].ac_len = AUDIOSIZE / 2;	/* Amount in number of words */
	custom->aud[2].ac_per = PERIOD;
	custom->aud[2].ac_vol = VOLUME;

	custom->aud[3].ac_ptr = (UWORD *) AudioBuffer;
	custom->aud[3].ac_len = AUDIOSIZE / 2;	/* Amount in number of words */
	custom->aud[3].ac_per = PERIOD;
	custom->aud[3].ac_vol = VOLUME;

	custom->dmacon = (0x800F);				/* Start audio channels 0
											   through 3 */

	AudioHit = 1;
}


/* NOTE: Only the registers D0, D1, A0 and A1 are trashed by my compiler -
   so it works.
   You  may,  of course, use the __saveds keyword to get your local base
   register and to restore the initial content.
   Unfortunately, my compiler doesn't support it.

   From  within  a  level-6 irq (CIA-B) we can't call a level-3 irq (audio
   DMA)  so  we need to call it from a irq below of 3 - Cause() is level-1
   so it fits.
*/

SUPERIOR ULONG Soft_Code( REG(a1, APTR data) )
{
	LONG i;

	i = 2;

	StartAudio();

	return i - 2;	/* For stupid compilers which don't deal with */
}					/* interrupts (MaxonC++/HiSoftC++) */

int main( void)
{
	UBYTE icrb, cr;

	if ( (AudioBuffer = (UBYTE *) AllocMem( AUDIOSIZE, MEMF_CHIP)) )
	{
		if ( (CiaBase = (struct Library *) OpenResource( "ciab.resource")) )
		{
			if ( (CIAB_IRQ = (struct Interrupt *)
							 AllocMem( sizeof( struct Interrupt),
										MEMF_CLEAR|MEMF_PUBLIC)) )
			{
				if ( (Soft_IRQ = (struct Interrupt *)
								 AllocMem( sizeof( struct Interrupt),
											MEMF_CLEAR|MEMF_PUBLIC)) )
				{
					CIAB_IRQ->is_Node.ln_Type = (UBYTE) NT_INTERRUPT;
					CIAB_IRQ->is_Node.ln_Name = "Audio Grabber";
					CIAB_IRQ->is_Data = __ret_a4();
					#ifndef __cplusplus
					CIAB_IRQ->is_Code = (void *) &CIAB_Code;
					#else
					/* Cast operator necessary when compiled in C++ mode... */
					(void *) CIAB_IRQ->is_Code = (void *) &CIAB_Code;
					#endif
					Soft_IRQ->is_Node.ln_Type = NT_INTERRUPT;
					Soft_IRQ->is_Node.ln_Name = "Audio Grabber";
					Soft_IRQ->is_Data = __ret_a4();
					#ifndef __cplusplus
					Soft_IRQ->is_Code = (void *) &Soft_Code;	/* Ditto */
					#else
					(void *) Soft_IRQ->is_Code = (void *) &Soft_Code;
					#endif

					/* Determine basic system clock */
					if ( ((struct ExecBase *) SysBase)->PowerSupplyFrequency == 50)
						PowerIndex = 0;
					else
						PowerIndex = 1;

					/* There are only two vectors, timer A and B (0 and 1) */
					for (icrb = 0; icrb < 2; icrb++)
					{
						/* Supply vector, - established? */
						if ( !(AddICRVector( CiaBase, icrb, CIAB_IRQ)) )
							break;
					}

					/* If vector is in range ( 0 to 1 ) */
					if (icrb <= 1)
					{
						if (icrb == 0)				/* Got timer A ? */
						{
							cr = ciab->ciacra;		/* Control register timer A */
							cr &= 128;				/* Select mode (bit 7 unused) */
							cr |= 1;				/* Set timer A to start */
							ciab->ciacra = cr;
							ciab->ciaicr = 129;		/* Enable timer A */

							/* Write delay time into registers */
							ciab->ciatalo = (Timeout[PowerIndex] & 0xFF);
							ciab->ciatahi = (Timeout[PowerIndex] >> 8 & 0xFF);
						}
						else						/* Timer B */
						{
							cr = ciab->ciacrb;		/* Control register timer B */
							cr &= 128;				/* Select mode */
							cr |= 1;				/* Set timer B to start */
							ciab->ciacrb = cr;
							ciab->ciaicr = 130;		/* Enable timer B */

							/* Write delay time into registers */
							ciab->ciatblo = (Timeout[PowerIndex] & 0xFF);
							ciab->ciatbhi = (Timeout[PowerIndex] >> 8 & 0xFF);
						}

						Wait( SIGBREAKF_CTRL_C);

						custom->dmacon = 15;		/* Turn off audio */

						/* Tell system reuse allowed */
						RemICRVector( CiaBase, icrb, CIAB_IRQ);
					}

					FreeMem( Soft_IRQ, sizeof( struct Interrupt) );
				}
				FreeMem( CIAB_IRQ, sizeof( struct Interrupt) );
			}
/*			CloseResource( CiaBase);	--- not necessary and not possible!	*/
		}
		FreeMem( AudioBuffer, AUDIOSIZE);
	}

	return 0;
}

---