code:

---

ULONG *buffer;
  ULONG handle;
  WORD tmp;

 buffer=AllocVec(120000,MEMF_FAST);

 tmp=&0xBFE101;
 tmp=tmp-127;
 CopyMem(*tmp,buffer+repeat,1);

---

[ - Antworten - Zitieren - Direktlink - ]

code:

---

UBYTE *SampleData   = 0xBFE101;
UBYTE *SampleStrobe = 0xBFE301;
UBYTE tmp;
UBYTE *buffer;

buffer=(UBYTE*)AllocVec(120000*sizeof(UBYTE),MEMF_FAST);

While (repeat<120000) {
  tmp=*SampleData;       // Register auslesen
  tmp-=0x80;            // unsigned => signed
  buffer[repeat] = tmp; // speichern
  *SampleStrobe = 0;    // Dieses Register zu 0 setzen
  repeat++;
}

---

[ - Antworten - Zitieren - Direktlink - ]

C code:

---

/* Local I/O addresses */
#define	DUSCC_BASE_ADRS	((char *) 0x02000000) /* m68562 DUSCC */
#define	QUART_BASE_ADRS	((char *) 0x02010000) /* XR-82C684 QUART */
#define	CAN_BASE_ADRS	((char *) 0x02070000) /* AN 82C527 CAN */

---

C code:

---

volatile char * duscc;
volatile char * quart;
volatile char * can;

---

C code:

---

duscc    = DUSCC_BASE_ADRS;  /* base pointer to DUSCC    */
quart    = QUART_BASE_ADRS;  /* base pointer to QUART    */
can      = CAN_BASE_ADRS;    /* base pointer to CAN      */

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
Wollte grade nochmal das eclock teil in C mit einem Sampling
code ausstatten um zu sehen wie weit C da kommt.

Ich bräuchte den Wert aus 0xBFE101 um 127 reduziert und per
copymem kopierbar.
Und eine Möglichkeit 0xBFE301 zu 0 zu setzten.

code:

---

ULONG *buffer;
  ULONG handle;
  WORD tmp;

 buffer=AllocVec(120000,MEMF_FAST);

 tmp=&0xBFE101;
 tmp=tmp-127;
 CopyMem(*tmp,buffer+repeat,1);

---

---

code:

---

include <hardware/cia.h>

   UBYTE *buffer; // du willst keine ULONGs, oder?

   // hardware register sind unbedingt als volatile zu kennzeichnen,
   // sonst optimiert der compiler dir den zugriff weg!
   volatile struct CIA *ciaa = (volatile struct CIA *) 0xbfe001;

   // das ist ne optimierung... aber prinzipiell könntest 
   // Du unten auch mit x = ciaa->ciaprb arbeiten
   volatile UBYTE *ciaaportb = &ciaa->ciaprb; 
   ULONG cnt = 120000;
   UBYTE *targetptr;

   // wenn du nicht im interrupt läufst. Wenn Du später mal deine
   // Auslese mit exaktem Timing brauchst, wirst Du das sicher in
   // einen Interrupt auslagern, dann sollte MEMF_PUBLIC gesetzt sein

   targetptr = buffer = (UBYTE *) AllocVec(120000, 0);

   do
   {
       *targetptr++ = *ciaaportb - 127; // -127? Thilo hatte bei sich -128 (0x80) stehen.

       // do while(), nur wenn du weißt, dass cnt sicher größer als 0
       // ist (wie in diesem Fall); eine while() {} schleife erzeugt
       // teilweise schlechteren code, ebenso eine "vorwärtsschleife"
       // mit cnt = 0; cnt < 120000; cnt++)
   } while(--cnt); 
   ciaa->ciaddrb = 0x55; // 0xbfe301 beschreiben

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
>richtigerweise sollte das eher so aussehen:

ich glaubt SASC verkraftet da so einige neuere sachen nicht.

---

Zitat:

---

// wenn du nicht im interrupt läufst. Wenn Du später mal deine
// Auslese mit exaktem Timing brauchst, wirst Du das sicher in
// einen Interrupt auslagern, dann sollte MEMF_PUBLIC gesetzt sein

Von Interrupts habe ich fast 0 Ahnung, ich würde ja gerne.
Das timer.device bringt keine aktzeptablen Frequenzen.

---

Zitat:

---

> Ergebniss: Ernüchternd ab 12000 HZ gibts Mikimaus stimmen,
> wird also weniger gesampelt als erforderlich.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

code:

---

UBYTE *SampleData   = (UBYTE*)0xBFE101;
UBYTE *SampleStrobe = (UBYTE*)0xBFE301;
...

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Der_Wanderer:
Es liegt NICHT an C und auch nicht am timer.device.
Wenn es nicht klappt, dann machst du was falsch.

---

Zitat:

---

In Amiblitz könntest du das auch einfach zusammencoden.
Früher hatte ich z.B. einen CIA Chip getriebenen Audio
Treiber in HD-Rec gecoded, um mit 44.1kHz/14bit Paula
abspielen zu können. Ging auch ohne Probleme und hat nicht
geleiert.

---

[ - Antworten - Zitieren - Direktlink - ]

code:

---

#include <stdio.h>  
    #include <exec/exec.h>
    #include <exec/ports.h>
    #include <exec/libraries.h>
    #include <dos/dos.h>
    #include <devices/timer.h>

    #include "parallel.h"
    #include <proto/all.h>
    #include <proto/dos.h>
    #include <proto/exec.h>


    struct timerequest *TimerIO;
    struct MsgPort *TimerMP;
    struct Message *TimerMsg;
    struct Library *TimerBase;

    int main(void)
    {
        struct timeval ref1, ref2;
        struct EClockVal eclockval;
        unsigned long intervall, ticks;
        long diff;
        LONG error;
        ULONG handle;
        UBYTE *buffer;
        unsigned int repeat = 0;
        unsigned int sekunden = 5;
        buffer = AllocVec(120000, MEMF_PUBLIC);

        TimerMP = (struct MsgPort *)CreatePort(NULL, 0);
        if(!TimerMP)
        {
            printf("Konnte Timer-Port nicht anlegen!n");
            return(RETURN_FAIL);
        }

        TimerIO = (struct timerequest *)CreateExtIO(TimerMP, sizeof(struct timerequest));
        if(!TimerIO)
        {
            printf("Konnte Timer-IORequest nicht anlegen!n");
            return(RETURN_FAIL);
        }

        error = OpenDevice(TIMERNAME, UNIT_WAITECLOCK, (struct IORequest *)TimerIO, 0L);
        if(error)
        {
            printf("Konnte timer.device nicht öffnen!n");
            return(RETURN_FAIL);
        }
        
        TimerBase = (struct Library *)TimerIO->tr_node.io_Device;
        SET_PARALLEL_PORT_READ;

        printf("Gewünschtes Intervall in Hz: ");
        scanf("%lu", &intervall);

        ticks = ReadEClock(&eclockval);
        diff = ticks / intervall; /* Normal müßte man auf - testen */

        printf("Hi: %lu Lo: %lun", eclockval.ev_hi, eclockval.ev_lo);

        /* sehr simpler Überlauf-Test */
        if( ((eclockval.ev_lo) + diff) < eclockval.ev_lo)
        {
            eclockval.ev_hi++;
        }
        else
        {
            eclockval.ev_lo += diff;
        }


        TimerIO->tr_node.io_Command = TR_ADDREQUEST;
        TimerIO->tr_time.tv_secs = eclockval.ev_hi;
        TimerIO->tr_time.tv_micro = eclockval.ev_lo;

        SendIO((struct IORequest *)TimerIO);

        GetSysTime(&ref1);

        while(repeat < intervall*sekunden)
        {
            TimerMsg = WaitPort(TimerMP);
            
            /* Vorsicht, wilde Überläufe   */
            if( ((eclockval.ev_lo) + diff) < eclockval.ev_lo)
            {
                eclockval.ev_hi++;
            }
            else
            {
                eclockval.ev_lo += diff;
            }
            TimerIO->tr_node.io_Command = TR_ADDREQUEST;
            TimerIO->tr_time.tv_secs = eclockval.ev_hi;
            TimerIO->tr_time.tv_micro = eclockval.ev_lo;
            SendIO((struct IORequest *)TimerIO);
            READ_PAR(*buffer+repeat);  // Wert vom Parallelport kopieren
            repeat++;
        }    

        GetSysTime(&ref2);


        AbortIO((struct IORequest *)TimerIO);
        WaitIO((struct IORequest *)TimerIO);  

handle=Open("t:sample",1006);
if(handle) {
    Write(handle,buffer,120000);
    Close(handle);
}

        FreeVec(buffer); 

        CloseDevice((struct IORequest *)TimerIO);
        DeleteExtIO((struct IORequest *)TimerIO);
        DeletePort(TimerMP);

        printf("n");
        printf("Intervall(EClock-ticks): %ldn", ticks / intervall);
        printf("Referenz 1: %ld %ldn", ref1.tv_secs, ref1.tv_micro);
        printf("Referenz 2: %ld %ldn", ref2.tv_secs, ref2.tv_micro);
        SubTime(&ref2, &ref1);
        printf("Differenz:  %9ld %ldn", ref2.tv_secs, ref2.tv_micro);
        
        return(RETURN_OK);
    }

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

code:

---

Forbid
 WHILE repeat1&<120001 
        FOR i%=1 TO 370
        NEXT i%
        POKEB MySample&+repeat1&, PEEKB(&hBFE101)-127
        INCR repeat1&
 WEND
Permit

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

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;
}

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

code:

---

XINCLUDE "ciatimer.include.bb2"

*SampleData.b = $BFE101
Samplerate.l  = 16000
TPM.l         = Samplerate * 60 ; Ticks-Per-Minute
BufferSize.l  = 120000
BufferIndex.l = 0

Dim MyBuffer.b(BufferSize)

; setze unsere eigene Funktion in den Interrupt
timer_SetInterruptCode{?ciainterrupt,0}

; timer öffnen
If timer_Open{-1,-1,TPM}

  ; los geht's!
  timer_Start{} 

  ; wir warten bis der Puffer voll ist...
  While BufferIndex<BufferSize: Delay_ 1 : Wend

  ; stop!
  timer_Stop{}

  ; jetzt ist unser Array voll mit sample daten
  ; wir können es auch einfach speichern...
  fid.l = ffa_WriteHeader{"Ram:MySound.wav",@"WAVE",16000,8,1}
  If fid>=0
    ffa_WriteMem{fid,&MyBuffer(0),BufferSize}
    ffa_Close{fid}
  End If
End If
End

ciainterrupt:
!basica7
If (BufferIndex<BufferSize) {
  tmp=Peek.b(*SampleData);       // Register auslesen
  tmp-=0x80;            // unsigned => signed
  MyBuffer(BufferIndex) = tmp; // speichern
  BufferIndex+1;
End If
!asma7
RTS

---

[ - Antworten - Zitieren - Direktlink - ]

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.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

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?

---

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

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.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

@jolo:

Also, ich hab das 1. AudioGrabber gerade mal durch den vbcc gescheucht (Cubic-Installation), Compilerlauf war völlig problemlos (keine Warnungen oder Fehler). Groß auf Funktion testen konnte ich es mangels Sampler allerdings nicht ;-)

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

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

Grüße

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?

--
---

µA1 PPC 750GX-800
A4000 PPC 604e-233


[ Dieser Beitrag wurde von whose am 25.10.2007 um 23:14 Uhr geändert. ]

[ - Antworten - Zitieren - Direktlink - ]

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

---

[ - Antworten - Zitieren - Direktlink - ]