code:

---

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

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h> 
    #include <exec/exec.h>
    #include <exec/ports.h>
    #include <exec/libraries.h>
    #include <exec/io.h>
    #include <dos/dos.h>

    #include <proto/dos.h>
    #include <proto/exec.h>
    #include <proto/timer.h>
    #include <devices/timer.h>
    #include <stdint.h>
    #include <math.h>

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

#define SAMPLING_RATE       8000
#define MAX_BINS            8
#define GOERTZEL_N          92

int    sample_count;
double q1[ MAX_BINS ];
double q2[ MAX_BINS ];
double r[ MAX_BINS ];

double      freqs[ MAX_BINS] = 
{
    697,
    770,
    852,
    941,
    1209,
    1336,
    1477,
    1633
};

double      coefs[ MAX_BINS ] ;


void
post_testing()
{
int         row, col, see_digit;
int         peak_count, max_index;
double      maxval, t;
int         i;
char *  row_col_ascii_codes[4][4] = {
        {"1", "2", "3", "A"},
        {"4", "5", "6", "B"},
        {"7", "8", "9", "C"},
        {"*", "0", "#", "D"}};


    /* Find the largest in the row group. */
    row = 0;
    maxval = 0.0;
    for ( i=0; i<4; i++ )
    {
        if ( r[i] > maxval )
        {
            maxval = r[i];
            row = i;
        }
    }

    /* Find the largest in the column group. */
    col = 4;
    maxval = 0.0;
    for ( i=4; i<8; i++ )
    {
        if ( r[i] > maxval )
        {
            maxval = r[i];
            col = i;
        }
    }


    /* Check for minimum energy */

    if ( r[row] < 4.0e5 )   /* 2.0e5 ... 1.0e8 no change */
    {
        /* energy not high enough */
    }
    else if ( r[col] < 4.0e5 )
    {
        /* energy not high enough */
    }
    else
    {
        see_digit = TRUE;
     
        if ( r[col] > r[row] )
        {
            /* Normal twist */
            max_index = col;
            if ( r[row] < (r[col] * 0.398) )    /* twist > 4dB, error */
                see_digit = FALSE;
        }
        else /* if ( r[row] > r[col] ) */
        {
            /* Reverse twist */
            max_index = row;
            if ( r[col] < (r[row] * 0.158) )    /* twist > 8db, error */
                see_digit = FALSE;
        }


        if ( r[max_index] > 1.0e9 )
            t = r[max_index] * 0.158;
        else
            t = r[max_index] * 0.010;

        peak_count = 0;
        for ( i=0; i<8; i++ )
        {
            if ( r[i] > t )
                peak_count++;
        }
        if ( peak_count > 2 )
            see_digit = FALSE;

        if ( see_digit )
        {
            Printf( "%s n", row_col_ascii_codes[row][col-4]);
        }
    }
}

void
goertzel( int sample )
{
double      q0;
int        i;

    if ( sample_count < GOERTZEL_N )
    {
        sample_count++;
        for ( i=0; i<MAX_BINS; i++ )
        {
            q0 = coefs[i] * q1[i] - q2[i] + sample;
            q2[i] = q1[i];
            q1[i] = q0;
        }
    }
    else
    {
        for ( i=0; i<MAX_BINS; i++ )
        {
            r[i] = (q1[i] * q1[i]) + (q2[i] * q2[i]) - (coefs[i] * q1[i] * q2[i]);
            q1[i] = 0.0;
            q2[i] = 0.0;
        }
        post_testing();
        sample_count = 0;
    }
}


int main(void)
{
int n;
         ULONG Loops;
         Loops=160000;
         struct timeval ref1, ref2;
        struct EClockVal eclockval;
        unsigned long intervall, ticks;
        long diff;
        LONG error;

        unsigned int repeat = 0;

  for(n = 0; n < MAX_BINS; n++)
  {
    coefs[n] = 2.0 * cos(2.0 * 3.141592654 * freqs[n] / SAMPLING_RATE);
  }

        memset((void *)0xBFE301,0x0,1);

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

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

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

        Printf("Gewünschtes Intervall in Hz: n ");
        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;
        }

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

        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 < Loops)
        {
            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);
            /* hier was sinnvolles tun, sofern vorhanden */

        volatile uint8_t *parallel=(uint8_t*)0xBFE101;
        signed int sample=*parallel;
        goertzel((sample-127)<<8);

            repeat++;
        }    

        GetSysTime(&ref2);

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

        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);
        
        exit(RETURN_OK);

}

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

code:

---

/* Vorsicht, wilde Überläufe   */
            if( ((eclockval.ev_lo) + diff) < eclockval.ev_lo)
            {
                eclockval.ev_hi++;
            }
            else
            {
                eclockval.ev_lo += diff;
            }

---

---

code:

---

old_ev_lo = eclockval.ev_lo;
eclockval.ev_lo += diff;
if (eclockval.ev_lo < old_ev_lo)
    eclockval.ev_hi ++;

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von thomas:
@MaikG:

Wild ist gar kein Ausdruck. Überleg dir mal, was dieser Abschnitt macht, wenn ein Überlauf stattfindet. Und vor allem, was beim nächsten Durchlauf nach einem Überlauf passiert. Bei dir kommt nach dem ersten Überlauf nämlich immer ein Überlauf, weil du das Kriterium, an dem du den Überlauf erkennst, gar nicht veränderst.

Richtig müßte es heißen:

code:

---

old_ev_lo = eclockval.ev_lo;
eclockval.ev_lo += diff;
if (eclockval.ev_lo < old_ev_lo)
    eclockval.ev_hi ++;

---

---

Das hat er aus meinem Beispiel aus einem anderen Thread, das ich auf die Schnelle zusammengehackt hatte. Mir ist da der Fehler unterlaufen, die Bewertungsstrategie von Cobol mit der von C zu vertauschen, daher danke für die Korrektur.

Trotzdem raff ich nicht, weshalb bei ihm nahezu das gleiche Programm ständig länger läuft als bei mir...

Grüße

--
---

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

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
> old_ev_lo = eclockval.ev_lo;
> eclockval.ev_lo += diff;
> if (eclockval.ev_lo < old_ev_lo)
> eclockval.ev_hi ++;


Okay hab ich 2x so eingefügt und old_ev_lo als LONG definiert.
Jetzt dauerts noch länger 27 Sekunden.

---

Zitat:

---

>Trotzdem raff ich nicht, weshalb bei ihm nahezu das gleiche
>Programm ständig länger läuft als bei mir...

Weil keiner bissher einen Timing Code inklusive DTMF ausprobiert
hat. Timing lief unter Basic auch schon korrekt, görtzel rannte
nur so durch aber beides zusammen geht ebend nicht.

---

Na, eben doch. Das hatte ich in dem ersten Thread auch geschrieben. Da habe ich nichts anderes gemacht wie Du, den goertzel einfach platt reinkopiert. Hier bei mir lief das auch ordentlich, sogar auf dem 4000er.

Deswegen wundere ich mich ja so, daß das bei Dir immer im Bereich von mehreren Sekunden langsamer läuft, sobald Du da Timing einsetzt, egal ob MB oder C. Zeit genug ist zwischen den SendIO() bei 8000Hz auf jeden Fall, würde mich arg wundern, wenn das Timing nur bei mir ordentlich läuft. Noch dazu auf WinUAE und 4000er nahezu gleich.

Grüße

--
---

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

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

@bubblebobble:

Der Gag bei der Geschichte ist ja, daß er das bereits einmal als Programm in MaxonBASIC implementiert hatte. Da gabs diese Mehrlaufzeiten auch ohne Goertzel.

Ich hatte dann das C-Programm mit UNIT_WAITECLOCK aufgesetzt, da läuft das Timing ordentlich, sogar in der BASIC-Fassung. Die Ungenauigkeiten des Timers kamen da auch mehr von der UNIT_MICROHZ bzw. GetSysTime(), die zum Messen benutzt wurden und etwas ungeschickt angelegter Start- und Endpunkte für die Messung meinerseits. Das Verhalten des Programms in Bezug auf die Timer-Ungenauigkeiten war aber ok, selbst über 30 Sekunden Dauer.

Später hatte ich dann mal den Goertzel eingesetzt, auf den Holger per Link verwiesen hatte, das Timing blieb weiterhin in den Grenzen wie ohne Goertzel, bei Maik allerdings nicht. Sobald der den Goertzel in seinem BASIC-Programm aktivierte, riß das Teil aus.

Und jetzt halt schon wieder, nur diesmal in C. Und das raffe ich einfach im Moment nicht. Die letzte Möglichkeit, die sich mir noch anbietet, wäre, tatsächlich auf Ungenauigkeiten bei der Referenzmessung zu tippen. Ist ja nicht soooo arg unwahrscheinlich. Dann hätte die ganze Diskussion hier aber keinen Wert, weil er halt nur meint, es würde "falsch" laufen.

Da müßte man dann evtl. mal die aufgenommenen Samples sehen und das Originalsignal dazu, um die Korrektheit des Sample-Timings einwandfrei überprüfen zu können.

Schwierige Kiste irgendwie...

Grüße

--
---

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

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
> old_ev_lo = eclockval.ev_lo;
> eclockval.ev_lo += diff;
> if (eclockval.ev_lo < old_ev_lo)
> eclockval.ev_hi ++;


Okay hab ich 2x so eingefügt und old_ev_lo als LONG definiert.
Jetzt dauerts noch länger 27 Sekunden.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
Ich verstehe nicht viel von C, das müsstest du genauer erklären.
Ich soll für irgendwas eine Variable nehmen die Doppelt so lang
ist wie eine Long?

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
>Da kannst Du, ohne drüber nachdenken zu müssen, 64-Bit Arithmetik
>benutzen, und wie der Code dafür aussehen muss, weißt Du ja. Der
>steht in dem anderen Programm.

Ich verstehe nicht viel von C, das müsstest du genauer erklären.
Ich soll für irgendwas eine Variable nehmen die Doppelt so lang
ist wie eine Long?

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Mad_Dog:
Guckst Du hier:

http://www.norman-interactive.com/C-Kurs_Datentypen.html

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
>Doppelt so lang klingt etwas schräg. Eine Variable, die doppelt so
>genau ist.

Verstehe ich nicht dafür gibts doch dann double(# in Basic).

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Holger:
Doppelt heißt auch weiterhin >zweifach< und nicht >Fließkomma< und abstrakte Dinge wie >Integerzahlen< haben keine Länge.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von NoImag:
Das Wort "genau" im Zusammenhang mit ganzen Zahlen halte ich für genauso unglücklich.

---

Zitat:

---

Außerdem können abstrakte Dinge wie Zahlen in ihrer konkreten Verwendung sehr wohl eine Länge haben. Bei ganzen Zahlen z.B. die Anzahl der Dezimalstellen oder meinetwegen auch die Anzahl der Binärstellen.

---

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von Holger:
Wieso?
Genauigkeit ist nunmal relativ. Und ganze Zahlen besitzen deshalb auch eine Genauigkeit, die man vergleichen kann.
Und jeder von einem Computer verarbeitbarer Datentyp besitzt eine begrenzte Genauigkeit.

---

Zitat:

---

Oder Anzahl der Buchstaben in C, int ist kürzer als long, welches wiederum kürzer als double ist, wobei char allerdings länger als int ist. Oder Anzahl der Erwähnungen in einem Programmierhandbuch für Anfänger.

Irgendwie scheint es nicht wirklich sinnvoll zu sein, eine Anzahl als Länge zu bezeichnen, oder?

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]

Zitat:

---

Original von MaikG:
>So wie in diesem Beispielcode benutzt:
>http://amiga-news.de/forum/thread.php?id=23479&start=211&BoardID=7#241727

Ah, und da muss ich dann nichts mehr modifizieren?

Edit: hab das eingesetzt und bekomme nur Enforcer hits, wie bei
den einen schon vollständigen Programm.

---

[ - Antworten - Zitieren - Direktlink - ]

[ - Antworten - Zitieren - Direktlink - ]