K
#include <alloc.h> /* Microsoft: #include <malloc.h> */
#include <ctype.h>
#include <conio.h>
#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
* x_n_re
*
* This array will store the FFT input samples, x(n),
* and the real part of the spectrum, X(n).
*/
short x_n_re[N];
/* ----------------------------------------- */
/* Fließkommawerte aus der Datei "ekg60.txt" */
/* in das Feld g_fArray[] einlesen */
/* ----------------------------------------- */
float *g_fArray; /* Das Feld selber */
int g_iArrayCount; /* Anzahl der gespeicherten Werte */
float g_fmin; /* negativster Wert */
float g_fmax; /* positivster Wert */
float g_fdiff; /* Differenz zwischen g_fmin und g_fmax */
int g_iArrayIndex; /* Laufvariable für das kontinuierliche */
/* Auslesen der Werte aus g_fArray[] */
int ReadIn(char *file)
{
FILE *fp;
int ifilelen;
char *pcbuf, *s;
int i;
if ((fp = fopen(file, "rt")) == 0) /* Datei öffnen */
{ printf("Datei konnte nicht geöffnet werden");
getch(); /* Auf Tastendruck warten */
return 0; /* Fehler zurückgeben */
}
ifilelen = filelength(fileno(fp)); /* Größe der Datei "ekg60.txt" */
pcbuf = malloc(ifilelen+1); /* Speicherplatz reservieren */
fread(pcbuf, 1, ifilelen, fp); /* ekg60.txt als Text einlesen */
pcbuf[ifilelen] = 0; /* Ende mit 0 kennzeichnen */
fclose(fp); /* Datei schließen */
/* mit Zeiger s den Text durchwandern */
for (s = pcbuf; isprint(s[0]) && isprint(s[1]) && isprint(s[2]); )
{ /* Array um einen Platz vergrößern */
g_fArray = realloc(g_fArray, (g_iArrayCount+1)*sizeof(float));
g_fArray[g_iArrayCount] = strtod(s, &s);
/* Zeichenkette in Fließkomma- */
/* zahl umwandeln und speichern */
g_iArrayCount++; /* Anzahl der Werte um 1 erhöhen */
}
free(pcbuf); /* Speicher für den Text */
/* wieder freigeben */
/* Höchsten und niedrigsten */
/* Kurvenwert ermitteln */
g_fmin = +10.0;
g_fmax = -10.0;
for (i = 0; i < g_iArrayCount; i++)
{ if (g_fmin > g_fArray[i])
g_fmin = g_fArray[i];
if (g_fmax < g_fArray[i])
g_fmax = g_fArray[i];
}
/* Differenz zwischen g_fmin und g_fmax */
g_fdiff = g_fmax-g_fmin;
return 1; /* Werte erfolgreich geladen */
}
void Remove(void)
{
/* Aufräumen */
free(g_fArray);
}
/* ---------------- */
/* "Grafik"-Ausgabe */
/* ---------------- */
void Saeule(int x, int y, int hoehe)
{
int idx;
if (hoehe == 0)
return;
hoehe /= 22;
for (idx = 0; idx < hoehe; idx++)
{ gotoxy(1+x, 1+y-idx);
printf("^");
}
}
void Graph(void)
{
int idx;
clrscr();
for (idx = 0; idx < 64; idx++)
{ gotoxy(1+idx, 1+12);
printf("-");
}
for (idx = 0; idx < 64; idx++)
{ gotoxy(1+idx, 1+24);
printf("-");
}
for (idx = 0; idx < 128; idx++)
Saeule(idx%64, 12+12*(idx/64), x_n_re[idx]);
}
/* ========================= */
/* B Der Algorithmus himself */
/* ========================= */
#define N 256
#define N_DIV_2 128
#define N_DIV_2_PLUS_1 129
#define N_MINUS_1 255
#define LOG_2_N 8
/* einige vorberechnete Tabellen aus "3722Firmware.zip" */
const char hammingLUT[N] =
{
+10, +10, +10, +10, +10, +10, +10, +11, +11, +11, +12, +12, +12, +13, +13, +14,
+14, +15, +15, +16, +17, +17, +18, +19, +20, +21, +21, +22, +23, +24, +25, +26,
+27, +28, +29, +30, +31, +33, +34, +35, +36, +37, +39, +40, +41, +42, +44, +45,
+46, +48, +49, +50, +52, +53, +55, +56, +57, +59, +60, +62, +63, +65, +66, +68,
+69, +70, +72, +73, +75, +76, +78, +79, +81, +82, +83, +85, +86, +88, +89, +90,
+92, +93, +94, +96, +97, +98, +99,+101,+102,+103,+104,+105,+106,+107,+109,+110,
+111,+112,+113,+114,+114,+115,+116,+117,+118,+119,+119,+120,+121,+121,+122,+123,
+123,+124,+124,+125,+125,+126,+126,+126,+126,+127,+127,+127,+127,+127,+127,+127,
+127,+127,+127,+127,+127,+127,+127,+126,+126,+126,+126,+125,+125,+124,+124,+123,
+123,+122,+121,+121,+120,+119,+119,+118,+117,+116,+115,+114,+114,+113,+112,+111,
+110,+109,+107,+106,+105,+104,+103,+102,+101, +99, +98, +97, +96, +94, +93, +92,
+90, +89, +88, +86, +85, +83, +82, +81, +79, +78, +76, +75, +73, +72, +70, +69,
+68, +66, +65, +63, +62, +60, +59, +57, +56, +55, +53, +52, +50, +49, +48, +46,
+45, +44, +42, +41, +40, +39, +37, +36, +35, +34, +33, +31, +30, +29, +28, +27,
+26, +25, +24, +23, +22, +21, +21, +20, +19, +18, +17, +17, +16, +15, +15, +14,
+14, +13, +13, +12, +12, +12, +11, +11, +11, +10, +10, +10, +10, +10, +10, +10
};
const char hannLUT[N] =
{
+0, +0, +0, +0, +0, +0, +0, +0, +1, +1, +1, +2, +2, +3, +3, +4,
+4, +5, +6, +6, +7, +8, +9, +10, +10, +11, +12, +13, +14, +15, +16, +17,
+18, +20, +21, +22, +23, +24, +26, +27, +28, +29, +31, +32, +34, +35, +36, +38,
+39, +41, +42, +44, +45, +47, +48, +50, +51, +53, +54, +56, +58, +59, +61, +62,
+64, +65, +67, +69, +70, +72, +73, +75, +76, +78, +79, +81, +83, +84, +86, +87,
+88, +90, +91, +93, +94, +95, +97, +98,+100,+101,+102,+103,+105,+106,+107,+108,
+109,+110,+111,+112,+113,+114,+115,+116,+117,+118,+119,+120,+120,+121,+122,+122,
+123,+123,+124,+124,+125,+125,+126,+126,+126,+127,+127,+127,+127,+127,+127,+127,
+127,+127,+127,+127,+127,+127,+127,+126,+126,+126,+125,+125,+124,+124,+123,+123,
+122,+122,+121,+120,+120,+119,+118,+117,+116,+115,+114,+113,+112,+111,+110,+109,
+108,+107,+106,+105,+103,+102,+101,+100, +98, +97, +96, +94, +93, +91, +90, +88,
+87, +86, +84, +83, +81, +79, +78, +76, +75, +73, +72, +70, +69, +67, +65, +64,
+62, +61, +59, +58, +56, +54, +53, +51, +50, +48, +47, +45, +44, +42, +41, +39,
+38, +36, +35, +34, +32, +31, +29, +28, +27, +26, +24, +23, +22, +21, +20, +18,
+17, +16, +15, +14, +13, +12, +11, +10, +10, +9, +8, +7, +6, +6, +5, +4,
+4, +3, +3, +2, +2, +1, +1, +1, +0, +0, +0, +0, +0, +0, +0, +0
};
const short cosLUT[N_DIV_2] =
{
+128,+127,+127,+127,+127,+127,+126,+126,+125,+124,+124,+123,+122,+121,+120,+119,
+118,+117,+115,+114,+112,+111,+109,+108,+106,+104,+102,+100, +98, +96, +94, +92,
+90, +88, +85, +83, +81, +78, +76, +73, +71, +68, +65, +63, +60, +57, +54, +51,
+48, +46, +43, +40, +37, +34, +31, +28, +24, +21, +18, +15, +12, +9, +6, +3,
+0, -3, -6, -9, -12, -15, -18, -21, -24, -28, -31, -34, -37, -40, -43, -46,
-48, -51, -54, -57, -60, -63, -65, -68, -71, -73, -76, -78, -81, -83, -85, -88,
-90, -92, -94, -96, -98,-100,-102,-104,-106,-108,-109,-111,-112,-114,-115,-117,
-118,-119,-120,-121,-122,-123,-124,-124,-125,-126,-126,-127,-127,-127,-127,-127
};
const short sinLUT[N_DIV_2] =
{
+0, +3, +6, +9, +12, +15, +18, +21, +24, +28, +31, +34, +37, +40, +43, +46,
+48, +51, +54, +57, +60, +63, +65, +68, +71, +73, +76, +78, +81, +83, +85, +88,
+90, +92, +94, +96, +98,+100,+102,+104,+106,+108,+109,+111,+112,+114,+115,+117,
+118,+119,+120,+121,+122,+123,+124,+124,+125,+126,+126,+127,+127,+127,+127,+127,
+128,+127,+127,+127,+127,+127,+126,+126,+125,+124,+124,+123,+122,+121,+120,+119,
+118,+117,+115,+114,+112,+111,+109,+108,+106,+104,+102,+100, +98, +96, +94, +92,
+90, +88, +85, +83, +81, +78, +76, +73, +71, +68, +65, +63, +60, +57, +54, +51,
+48, +46, +43, +40, +37, +34, +31, +28, +24, +21, +18, +15, +12, +9, +6, +3
};
const unsigned char magnLUT[16][16] =
{
{0x00,0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x80,0x90,0xa0,0xb0,0xc0,0xd0,0xe0,0xf0},
{0x10,0x16,0x23,0x32,0x41,0x51,0x61,0x71,0x80,0x90,0xa0,0xb0,0xc0,0xd0,0xe0,0xf0},
{0x20,0x23,0x2d,0x39,0x47,0x56,0x65,0x74,0x83,0x93,0xa3,0xb2,0xc2,0xd2,0xe2,0xf2},
{0x30,0x32,0x39,0x43,0x50,0x5d,0x6b,0x79,0x88,0x97,0xa7,0xb6,0xc5,0xd5,0xe5,0xf4},
{0x40,0x41,0x47,0x50,0x5a,0x66,0x73,0x80,0x8f,0x9d,0xac,0xbb,0xca,0xd9,0xe8,0xf8},
{0x50,0x51,0x56,0x5d,0x66,0x71,0x7c,0x89,0x96,0xa4,0xb2,0xc1,0xd0,0xde,0xed,0xfc},
{0x60,0x61,0x65,0x6b,0x73,0x7c,0x87,0x93,0xa0,0xad,0xba,0xc8,0xd6,0xe5,0xf3,0xff},
{0x70,0x71,0x74,0x79,0x80,0x89,0x93,0x9e,0xaa,0xb6,0xc3,0xd0,0xde,0xec,0xfa,0xff},
{0x80,0x80,0x83,0x88,0x8f,0x96,0xa0,0xaa,0xb5,0xc0,0xcc,0xd9,0xe6,0xf4,0xff,0xff},
{0x90,0x90,0x93,0x97,0x9d,0xa4,0xad,0xb6,0xc0,0xcb,0xd7,0xe3,0xf0,0xfc,0xff,0xff},
{0xa0,0xa0,0xa3,0xa7,0xac,0xb2,0xba,0xc3,0xcc,0xd7,0xe2,0xed,0xf9,0xff,0xff,0xff},
{0xb0,0xb0,0xb2,0xb6,0xbb,0xc1,0xc8,0xd0,0xd9,0xe3,0xed,0xf8,0xff,0xff,0xff,0xff},
{0xc0,0xc0,0xc2,0xc5,0xca,0xd0,0xd6,0xde,0xe6,0xf0,0xf9,0xff,0xff,0xff,0xff,0xff},
{0xd0,0xd0,0xd2,0xd5,0xd9,0xde,0xe5,0xec,0xf4,0xfc,0xff,0xff,0xff,0xff,0xff,0xff},
{0xe0,0xe0,0xe2,0xe5,0xe8,0xed,0xf3,0xfa,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff},
{0xf0,0xf0,0xf2,0xf4,0xf8,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}
};
/*
* Windowing: Uncomment one of the following define
* statements to enable the corresponding windowing
* function on input samples. Comment all to disable
* windowing.
*/
//#define WINDOWING_HAMMING
//#define WINDOWING_HANN
/* ----------------------------- */
/* Hier: Fließkommawerte aus der */
/* Textdatei "ekg60.txt" durch */
/* g_fArray[] übernehmen */
/* ----------------------------- */
/*
* getSamplesFromADC()
*
* Captures N 8-bit samples (in 2's complement format) from
* the ADC and stores them in the array x_n_re. If windowing
* is enabled, the data will be multiplied by the
* appropriate function.
*/
int getSamplesFromADC(void)
{
unsigned int i;
short *ptr_x_n_re = x_n_re;
/* 3.3. Read the sample from the ADC. Pointer notation instead
of array notation is used for x_n_re to increase sampling
speed.
*/
/* EKG-Werte auf den Zahlenbereich von -128 bis +127 abbilden */
/* Berechnung: (Wert - g_fmin) / g_fdiff * 256 - 128 */
for (i = 0; i < 256 && g_iArrayIndex < g_iArrayCount; i++)
*(ptr_x_n_re++) =
-128+((short)(((g_fArray[g_iArrayIndex++]-g_fmin)/g_fdiff)*256.0));
// Read sample
/* den letzten unvollständigen Abschnitt verwerfen */
if (i < 256 && g_iArrayIndex >= g_iArrayCount)
return 0; /* Programm-Ende */
/* 5. Perform adjustments to samples:
- If the sample is negative (sign bit is 1), convert the
sampled byte to the corresponding negative 16-bit word
- Multiply sample by windowing function if enabled
*/
for (i = 0; i < 256; i++)
{ if (x_n_re[i] & 0x80)
x_n_re[i] += (short)0xFF00; // Convert to negative 16-bit word (2's comp)
#ifdef WINDOWING_HAMMING
x_n_re[i] *= hammingLUT[i];
#endif
#ifdef WINDOWING_HANN
x_n_re[i] *= hannLUT[i];
#endif
}
return 1; /* 256 Werte sind vollständig */
}
/* =============== */
/* D Hauptprogramm */
/* =============== */
int main()
{
unsigned short i;
int n_of_b;
int s_of_b;
int a_index;
int a_index_ref;
char stage;
int nb_index;
int sb_index;
int tf_index;
int b_index;
int resultMulReCos;
int resultMulImCos;
int resultMulReSin;
int resultMulImSin;
short x_n_im[N]; // Imaginary part of x(n) and X(n),
// initialized to 0 before every fft
/* Daten in g_fArray[] einlesen */
if (ReadIn("ekg60.txt") == 0)
{ Remove();
return 0;
}
/* 4. FFT Loop */
while(1)
{
/* 4.0. Variable Initializations */
n_of_b = N_DIV_2; // Number of butterflies
s_of_b = 1; // Size of butterflies
a_index = 0; // fft data index
a_index_ref = 0; // fft data index reference
memset(x_n_im, 0, sizeof(x_n_im)); /* Imaginärteil auf 0 setzen */
/* 4.1. Get Input Samples from the ADC: */
/* Data will be stored in x_n_re */
if (getSamplesFromADC() == 0)
break; /* weniger als 256 Werte -> abbrechen */
/* 4.2. Perform Bit-Reversal: Uses an unrolled loop */
i=x_n_re[ 1]; x_n_re[ 1]=x_n_re[128]; x_n_re[128]=i;
i=x_n_re[ 2]; x_n_re[ 2]=x_n_re[ 64]; x_n_re[ 64]=i;
i=x_n_re[ 3]; x_n_re[ 3]=x_n_re[192]; x_n_re[192]=i;
i=x_n_re[ 4]; x_n_re[ 4]=x_n_re[ 32]; x_n_re[ 32]=i;
i=x_n_re[ 5]; x_n_re[ 5]=x_n_re[160]; x_n_re[160]=i;
i=x_n_re[ 6]; x_n_re[ 6]=x_n_re[ 96]; x_n_re[ 96]=i;
i=x_n_re[ 7]; x_n_re[ 7]=x_n_re[224]; x_n_re[224]=i;
i=x_n_re[ 8]; x_n_re[ 8]=x_n_re[ 16]; x_n_re[ 16]=i;
i=x_n_re[ 9]; x_n_re[ 9]=x_n_re[144]; x_n_re[144]=i;
i=x_n_re[ 10]; x_n_re[ 10]=x_n_re[ 80]; x_n_re[ 80]=i;
i=x_n_re[ 11]; x_n_re[ 11]=x_n_re[208]; x_n_re[208]=i;
i=x_n_re[ 12]; x_n_re[ 12]=x_n_re[ 48]; x_n_re[ 48]=i;
i=x_n_re[ 13]; x_n_re[ 13]=x_n_re[176]; x_n_re[176]=i;
i=x_n_re[ 14]; x_n_re[ 14]=x_n_re[112]; x_n_re[112]=i;
i=x_n_re[ 15]; x_n_re[ 15]=x_n_re[240]; x_n_re[240]=i;
i=x_n_re[ 17]; x_n_re[ 17]=x_n_re[136]; x_n_re[136]=i;
i=x_n_re[ 18]; x_n_re[ 18]=x_n_re[ 72]; x_n_re[ 72]=i;
i=x_n_re[ 19]; x_n_re[ 19]=x_n_re[200]; x_n_re[200]=i;
i=x_n_re[ 20]; x_n_re[ 20]=x_n_re[ 40]; x_n_re[ 40]=i;
i=x_n_re[ 21]; x_n_re[ 21]=x_n_re[168]; x_n_re[168]=i;
i=x_n_re[ 22]; x_n_re[ 22]=x_n_re[104]; x_n_re[104]=i;
i=x_n_re[ 23]; x_n_re[ 23]=x_n_re[232]; x_n_re[232]=i;
i=x_n_re[ 25]; x_n_re[ 25]=x_n_re[152]; x_n_re[152]=i;
i=x_n_re[ 26]; x_n_re[ 26]=x_n_re[ 88]; x_n_re[ 88]=i;
i=x_n_re[ 27]; x_n_re[ 27]=x_n_re[216]; x_n_re[216]=i;
i=x_n_re[ 28]; x_n_re[ 28]=x_n_re[ 56]; x_n_re[ 56]=i;
i=x_n_re[ 29]; x_n_re[ 29]=x_n_re[184]; x_n_re[184]=i;
i=x_n_re[ 30]; x_n_re[ 30]=x_n_re[120]; x_n_re[120]=i;
i=x_n_re[ 31]; x_n_re[ 31]=x_n_re[248]; x_n_re[248]=i;
i=x_n_re[ 33]; x_n_re[ 33]=x_n_re[132]; x_n_re[132]=i;
i=x_n_re[ 34]; x_n_re[ 34]=x_n_re[ 68]; x_n_re[ 68]=i;
i=x_n_re[ 35]; x_n_re[ 35]=x_n_re[196]; x_n_re[196]=i;
i=x_n_re[ 37]; x_n_re[ 37]=x_n_re[164]; x_n_re[164]=i;
i=x_n_re[ 38]; x_n_re[ 38]=x_n_re[100]; x_n_re[100]=i;
i=x_n_re[ 39]; x_n_re[ 39]=x_n_re[228]; x_n_re[228]=i;
i=x_n_re[ 41]; x_n_re[ 41]=x_n_re[148]; x_n_re[148]=i;
i=x_n_re[ 42]; x_n_re[ 42]=x_n_re[ 84]; x_n_re[ 84]=i;
i=x_n_re[ 43]; x_n_re[ 43]=x_n_re[212]; x_n_re[212]=i;
i=x_n_re[ 44]; x_n_re[ 44]=x_n_re[ 52]; x_n_re[ 52]=i;
i=x_n_re[ 45]; x_n_re[ 45]=x_n_re[180]; x_n_re[180]=i;
i=x_n_re[ 46]; x_n_re[ 46]=x_n_re[116]; x_n_re[116]=i;
i=x_n_re[ 47]; x_n_re[ 47]=x_n_re[244]; x_n_re[244]=i;
i=x_n_re[ 49]; x_n_re[ 49]=x_n_re[140]; x_n_re[140]=i;
i=x_n_re[ 50]; x_n_re[ 50]=x_n_re[ 76]; x_n_re[ 76]=i;
i=x_n_re[ 51]; x_n_re[ 51]=x_n_re[204]; x_n_re[204]=i;
i=x_n_re[ 53]; x_n_re[ 53]=x_n_re[172]; x_n_re[172]=i;
i=x_n_re[ 54]; x_n_re[ 54]=x_n_re[108]; x_n_re[108]=i;
i=x_n_re[ 55]; x_n_re[ 55]=x_n_re[236]; x_n_re[236]=i;
i=x_n_re[ 57]; x_n_re[ 57]=x_n_re[156]; x_n_re[156]=i;
i=x_n_re[ 58]; x_n_re[ 58]=x_n_re[ 92]; x_n_re[ 92]=i;
i=x_n_re[ 59]; x_n_re[ 59]=x_n_re[220]; x_n_re[220]=i;
i=x_n_re[ 61]; x_n_re[ 61]=x_n_re[188]; x_n_re[188]=i;
i=x_n_re[ 62]; x_n_re[ 62]=x_n_re[124]; x_n_re[124]=i;
i=x_n_re[ 63]; x_n_re[ 63]=x_n_re[252]; x_n_re[252]=i;
i=x_n_re[ 65]; x_n_re[ 65]=x_n_re[130]; x_n_re[130]=i;
i=x_n_re[ 67]; x_n_re[ 67]=x_n_re[194]; x_n_re[194]=i;
i=x_n_re[ 69]; x_n_re[ 69]=x_n_re[162]; x_n_re[162]=i;
i=x_n_re[ 70]; x_n_re[ 70]=x_n_re[ 98]; x_n_re[ 98]=i;
i=x_n_re[ 71]; x_n_re[ 71]=x_n_re[226]; x_n_re[226]=i;
i=x_n_re[ 73]; x_n_re[ 73]=x_n_re[146]; x_n_re[146]=i;
i=x_n_re[ 74]; x_n_re[ 74]=x_n_re[ 82]; x_n_re[ 82]=i;
i=x_n_re[ 75]; x_n_re[ 75]=x_n_re[210]; x_n_re[210]=i;
i=x_n_re[ 77]; x_n_re[ 77]=x_n_re[178]; x_n_re[178]=i;
i=x_n_re[ 78]; x_n_re[ 78]=x_n_re[114]; x_n_re[114]=i;
i=x_n_re[ 79]; x_n_re[ 79]=x_n_re[242]; x_n_re[242]=i;
i=x_n_re[ 81]; x_n_re[ 81]=x_n_re[138]; x_n_re[138]=i;
i=x_n_re[ 83]; x_n_re[ 83]=x_n_re[202]; x_n_re[202]=i;
i=x_n_re[ 85]; x_n_re[ 85]=x_n_re[170]; x_n_re[170]=i;
i=x_n_re[ 86]; x_n_re[ 86]=x_n_re[106]; x_n_re[106]=i;
i=x_n_re[ 87]; x_n_re[ 87]=x_n_re[234]; x_n_re[234]=i;
i=x_n_re[ 89]; x_n_re[ 89]=x_n_re[154]; x_n_re[154]=i;
i=x_n_re[ 91]; x_n_re[ 91]=x_n_re[218]; x_n_re[218]=i;
i=x_n_re[ 93]; x_n_re[ 93]=x_n_re[186]; x_n_re[186]=i;
i=x_n_re[ 94]; x_n_re[ 94]=x_n_re[122]; x_n_re[122]=i;
i=x_n_re[ 95]; x_n_re[ 95]=x_n_re[250]; x_n_re[250]=i;
i=x_n_re[ 97]; x_n_re[ 97]=x_n_re[134]; x_n_re[134]=i;
i=x_n_re[ 99]; x_n_re[ 99]=x_n_re[198]; x_n_re[198]=i;
i=x_n_re[101]; x_n_re[101]=x_n_re[166]; x_n_re[166]=i;
i=x_n_re[103]; x_n_re[103]=x_n_re[230]; x_n_re[230]=i;
i=x_n_re[105]; x_n_re[105]=x_n_re[150]; x_n_re[150]=i;
i=x_n_re[107]; x_n_re[107]=x_n_re[214]; x_n_re[214]=i;
i=x_n_re[109]; x_n_re[109]=x_n_re[182]; x_n_re[182]=i;
i=x_n_re[110]; x_n_re[110]=x_n_re[118]; x_n_re[118]=i;
i=x_n_re[111]; x_n_re[111]=x_n_re[246]; x_n_re[246]=i;
i=x_n_re[113]; x_n_re[113]=x_n_re[142]; x_n_re[142]=i;
i=x_n_re[115]; x_n_re[115]=x_n_re[206]; x_n_re[206]=i;
i=x_n_re[117]; x_n_re[117]=x_n_re[174]; x_n_re[174]=i;
i=x_n_re[119]; x_n_re[119]=x_n_re[238]; x_n_re[238]=i;
i=x_n_re[121]; x_n_re[121]=x_n_re[158]; x_n_re[158]=i;
i=x_n_re[123]; x_n_re[123]=x_n_re[222]; x_n_re[222]=i;
i=x_n_re[125]; x_n_re[125]=x_n_re[190]; x_n_re[190]=i;
i=x_n_re[127]; x_n_re[127]=x_n_re[254]; x_n_re[254]=i;
i=x_n_re[131]; x_n_re[131]=x_n_re[193]; x_n_re[193]=i;
i=x_n_re[133]; x_n_re[133]=x_n_re[161]; x_n_re[161]=i;
i=x_n_re[135]; x_n_re[135]=x_n_re[225]; x_n_re[225]=i;
i=x_n_re[137]; x_n_re[137]=x_n_re[145]; x_n_re[145]=i;
i=x_n_re[139]; x_n_re[139]=x_n_re[209]; x_n_re[209]=i;
i=x_n_re[141]; x_n_re[141]=x_n_re[177]; x_n_re[177]=i;
i=x_n_re[143]; x_n_re[143]=x_n_re[241]; x_n_re[241]=i;
i=x_n_re[147]; x_n_re[147]=x_n_re[201]; x_n_re[201]=i;
i=x_n_re[149]; x_n_re[149]=x_n_re[169]; x_n_re[169]=i;
i=x_n_re[151]; x_n_re[151]=x_n_re[233]; x_n_re[233]=i;
i=x_n_re[155]; x_n_re[155]=x_n_re[217]; x_n_re[217]=i;
i=x_n_re[157]; x_n_re[157]=x_n_re[185]; x_n_re[185]=i;
i=x_n_re[159]; x_n_re[159]=x_n_re[249]; x_n_re[249]=i;
i=x_n_re[163]; x_n_re[163]=x_n_re[197]; x_n_re[197]=i;
i=x_n_re[167]; x_n_re[167]=x_n_re[229]; x_n_re[229]=i;
i=x_n_re[171]; x_n_re[171]=x_n_re[213]; x_n_re[213]=i;
i=x_n_re[173]; x_n_re[173]=x_n_re[181]; x_n_re[181]=i;
i=x_n_re[175]; x_n_re[175]=x_n_re[245]; x_n_re[245]=i;
i=x_n_re[179]; x_n_re[179]=x_n_re[205]; x_n_re[205]=i;
i=x_n_re[183]; x_n_re[183]=x_n_re[237]; x_n_re[237]=i;
i=x_n_re[187]; x_n_re[187]=x_n_re[221]; x_n_re[221]=i;
i=x_n_re[191]; x_n_re[191]=x_n_re[253]; x_n_re[253]=i;
i=x_n_re[199]; x_n_re[199]=x_n_re[227]; x_n_re[227]=i;
i=x_n_re[203]; x_n_re[203]=x_n_re[211]; x_n_re[211]=i;
i=x_n_re[207]; x_n_re[207]=x_n_re[243]; x_n_re[243]=i;
i=x_n_re[215]; x_n_re[215]=x_n_re[235]; x_n_re[235]=i;
i=x_n_re[223]; x_n_re[223]=x_n_re[251]; x_n_re[251]=i;
i=x_n_re[239]; x_n_re[239]=x_n_re[247]; x_n_re[247]=i;
/* 4.3. FFT: loop through the 0 to log2(N) stages of
the butterfly computations. When the FFT
begins, the input samples (x(n)) are stored
in x_n_re/x_n_im. When the FFT is done,
the spectrum (X(n)) has replaced the input
stored in x_n_re/x_n_im.
*/
for (stage = 0; stage < LOG_2_N; stage++)
{
for (nb_index = 0; nb_index < n_of_b; nb_index++)
{
tf_index = 0; /* The twiddle factor index */
for (sb_index = 0; sb_index < s_of_b; sb_index++)
{
b_index = a_index+s_of_b;
/* Das hier ist sonst Aufgabe des festverdrahteten */
/* Multiplizierers auf dem Microcontroller */
resultMulReCos = cosLUT[tf_index]*x_n_re[b_index]; resultMulReCos >>= 7;
resultMulReSin = sinLUT[tf_index]*x_n_re[b_index]; resultMulReSin >>= 7;
resultMulImCos = cosLUT[tf_index]*x_n_im[b_index]; resultMulImCos >>= 7;
resultMulImSin = sinLUT[tf_index]*x_n_im[b_index]; resultMulImSin >>= 7;
x_n_re[b_index] = (short)(x_n_re[a_index]-resultMulReCos+resultMulImSin);
x_n_im[b_index] = (short)(x_n_im[a_index]-resultMulReSin-resultMulImCos);
x_n_re[a_index] = (short)(x_n_re[a_index]+resultMulReCos-resultMulImSin);
x_n_im[a_index] = (short)(x_n_im[a_index]+resultMulReSin+resultMulImCos);
if (((sb_index+1) & (s_of_b-1)) == 0)
a_index = a_index_ref;
else
a_index++;
tf_index += n_of_b;
}
a_index = ((s_of_b<<1) + a_index) & N_MINUS_1;
a_index_ref = a_index;
}
n_of_b >>= 1;
s_of_b <<= 1;
}
/* 4.4. abs(X(n)): Loop through N/2+1 (0 to N/2) FFT results (stored in
x_n_re and x_n_im) and make all the values positive.
This will be needed for the algorithm used to compute
the magnitude of X(n).
*/
for (i = 0; i < N_DIV_2_PLUS_1; i++)
{
if ((x_n_re[i] & 0x8000) != 0)
x_n_re[i] *= (short)-1; /* If negative, multiply by -1 */
if ((x_n_im[i] & 0x8000) != 0)
x_n_im[i] *= (short)-1; /* If negative, multiply by -1 */
}
/* 4.5. |X(n)|: Compute the magniture of X(n) using a LUT. This is
possible only because the values of Re{X(n)} and
Im{X(n)} are all positive. Note that Im{X(0)} and
Im{X(N/2)} contain no data and therefore computing
|X(0)| and |X(N/2)| requires only the real part
of X(n).
The magniture LUT is declared as:
const unsigned char magnLUT[16][16] = {...};
where the first index is abs(Re{X(n)}) and the second
index is abs(Im{X(n)}). Since X(n) is stored as Q8.7,
and the 4 most significant bits (2^4=16) are to be used
as the indexes, the Re{X(n)} and Im{X(n)} must be right
shifted 11 positions.
*/
x_n_re[0] = magnLUT[x_n_re[0]>>11][0];
for (i = 1; i < N_DIV_2; i++)
x_n_re[i] = magnLUT[x_n_re[i]>>11][x_n_im[i]>>11];
x_n_re[N_DIV_2] = magnLUT[x_n_re[N_DIV_2]>>11][0];
/* --- Daten weiterreichen --- */
/*for (i = 0; i < N_DIV_2_PLUS_1; i++)
printf(">%i", (unsigned char)x_n_re[i]);*/
Graph(); /* oder selber darstellen */
getch(); /* Auf Tastendruck warten */
/* --------------------------- */
/* 4.6. Xmit |X(n)|: Transmits the magnitude of X(n) using UART0 */
/*for(i=0; i<N_DIV_2_PLUS_1; i++)
{
while(!SCON0_bit.TI); // Wait for empty buffer
SCON0_bit.TI = 0; // Reset empty buffer flag
SBUF0 = x_n_re[i]; // Send magn
}*/
}
Remove(); /* Zwischenspeicherung g_fArray[] wieder freigeben */
printf("fertich");
getch(); /* Auf Tastendruck warten */
return 0;
}
