113 lines
5.2 KiB
C
113 lines
5.2 KiB
C
// BLOCK LEN 1 und MAX_FIR_COEFFS 64 werden vom Compiler mitgegeben
|
|
|
|
//#define SIMULATE
|
|
|
|
#ifdef SIMULATE
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
#include "signalProcessing/include/signal_path.h"
|
|
|
|
// Register und Bitmasken für Interrupts zwischen ARM und LPDSP Prozessor
|
|
#define CSS_CMD 0xC00004
|
|
#define CSS_CMD_0 (1<<0)
|
|
#define CSS_CMD_1 (1<<1)
|
|
|
|
// Shared Memory von ARM und DSP definieren
|
|
#define INPUT_PORT0_ADD 0x800000 // Feste Adressen für Eingangsdaten im Shared Memory
|
|
#define OUTPUT_PORT_ADD (INPUT_PORT0_ADD + 16) // Feste Adressen für Ausgangsdatensdaten im Shared Memory, 16 Byte von Eingangsadresse Weg
|
|
|
|
//Chess Compiler spezifisch: Interrupt-Register festlegen um ARM zu kontaktieren nach fertiger Berechnung
|
|
volatile static unsigned char chess_storage(DMIO:CSS_CMD) css_cmd_flag;
|
|
|
|
// Interrupt-Flag, welche von ARM gesetzt wird, wenn eine Berechnung gewünscht ist
|
|
static volatile int action_required;
|
|
|
|
// Structs anlegen für die Signalpfade - hier werden Konfigurationen abgelegt(signal_path.h)
|
|
static SingleSignalPath corrupted_signal;
|
|
static SingleSignalPath reference_noise_signal;
|
|
|
|
static volatile int16_t chess_storage(DMB:INPUT_PORT0_ADD) input_port[4]; //Array mit 4x16 Bit Einträgen auf 2x32 Bit Registern - nur die ersten 2 werden genutzt
|
|
static volatile int16_t chess_storage(DMB:OUTPUT_PORT_ADD) output_port[4]; //Array mit 4x16 Bit Einträgen auf 2x32 Bit Registern - alle werden genutzt
|
|
static volatile int16_t chess_storage(DMB) *input_pointer_0;
|
|
static volatile int16_t chess_storage(DMB) *input_pointer_1;
|
|
static volatile int16_t chess_storage(DMB) *output_pointer;
|
|
static volatile int16_t chess_storage(DMB) *sample_pointer;
|
|
static volatile int16_t chess_storage(DMB) sample; //Speicherplatz für Ergebnis der calc()-Funktion
|
|
|
|
//void isr0() ist eine Interrupt Service Routine Funktion, welche als C Funktion deklariert wird
|
|
// property (isr) ist Chess Compiler spezifisch und kennzeichnet eine Funktion als Interrupt Service Routine
|
|
//wird Interrupt getriggert, wird action_required auf 1 gesetzt - etwas muss dannpassieren
|
|
extern "C" void isr0() property (isr) {
|
|
action_required = 1;
|
|
}
|
|
|
|
int main(void) {
|
|
// Enum, welcher den Ausgabemodus definiert - wird in calc()-Funktion verwendet
|
|
static OutputMode mode = OUTPUT_MODE_FIR_LMS;
|
|
// Biquad Filter für C-Sensor und Acc-Sensor anlegen
|
|
// Alle 0 bis auf b[0] -> einfacher Gain auf 0,75
|
|
double b0[5]={0.75, 0., 0., 0., 0.};
|
|
double b1[5]={0.75, 0., 0., 0., 0.};
|
|
int coefficients = MAX_FIR_COEFFS; // 64 Koeffizienten für ANR
|
|
|
|
// Signale initialisieren, oben angelegte Structs mit Parametern füllen
|
|
init(
|
|
&corrupted_signal, &reference_noise_signal, //Signal-Structs
|
|
b0, // Biqquad Koeffizienten C-Sensor
|
|
b1, // Biqquad Koeffizienten Acc-Sensor
|
|
2, // Sample Delay C-Sensor
|
|
2, // Sample Delay Acc-Sensor
|
|
0.9, //Gewichtung C-Sensor
|
|
0.9, //Gewichtung Acc-Sensor
|
|
0.01, // Mu
|
|
coefficients // Anzahl Filterkoeffizienten
|
|
);
|
|
|
|
//Simulationsmodus mit File I/O
|
|
#ifdef SIMULATE
|
|
FILE *fp1 = fopen("./test/testdata/input/chirp_disturber.txt", "r");
|
|
FILE *fp2 = fopen("./test/testdata/input/disturber.txt", "r");
|
|
FILE *fp3 = fopen("./test/testdata/output/out_simulated.txt", "w");
|
|
|
|
int d0, d1;
|
|
|
|
while (!(feof(fp1) || feof(fp2))){
|
|
for (int i=0; i<BLOCK_LEN; i++){
|
|
fscanf(fp1, "%d", &d0); //load blocks
|
|
fscanf(fp2, "%d", &d1);
|
|
input_port[i] = (int16_t) d0;
|
|
input_port[i+1] = (int16_t) d1;
|
|
}
|
|
calc(
|
|
&corrupted_signal, &reference_noise_signal, mode, &input_port[0], &input_port[1], output_port);
|
|
for (int i=0; i<BLOCK_LEN; i++){
|
|
fprintf(fp3, "%d\n", output_port[i]);
|
|
}
|
|
}
|
|
fclose(fp1);
|
|
fclose(fp2);
|
|
fclose(fp3);
|
|
|
|
// Hardwaremodus mit Interrupts
|
|
#else
|
|
enable_interrupts(); //Interrupts aktivieren
|
|
output_pointer = &output_port[1]; // Zweite Hälfte des Ausgangspuffers zuerst füllen - warum 1 statt 2? Warum generell nicht 0?
|
|
sample_pointer = &sample; //Sample-Pointer wird auf Adresse des Sample-Speicherplatzes gesetzt
|
|
|
|
//Endlosschleife für Interrupt-gesteuerte Verarbeitung
|
|
action_required = 0;
|
|
while (1){
|
|
css_cmd_flag = CSS_CMD_1; // Interrupt Bit setzen um ARM zu signalisieren, dass der DSP schläft
|
|
core_halt();
|
|
if (action_required == 1) {
|
|
css_cmd_flag = CSS_CMD_0; // Interrupt Bit setzen um ARM zu signalisieren, dass der DSP arbeitet
|
|
action_required = 0; // Action-Flag setzen, damit Loop nicht automatisch startet
|
|
output_pointer = cyclic_add(output_pointer, 2, output_port, 4); //Output Buffer um 2 Byte inkrementieren, hat insgesamt 4 Byte - Reset wenn Ende erreicht
|
|
*output_pointer = *sample_pointer; //Inhalt des Sample-Pointer Ziels (Ergenis der vorherigen Berechnung) in Output-Pointer schreiben
|
|
calc(&corrupted_signal, &reference_noise_signal, mode, &input_port[1], &input_port[0], sample_pointer); //16 Bit Output Sample aus 2 16 Bit Input Samples berechnen
|
|
}
|
|
}
|
|
#endif
|
|
} |