Ordnerstruktur geändert

2026-01-16 10:37:53 +01:00
parent bd94b0e79f
commit 03fba24d27
3 changed files with 0 additions and 0 deletions
--- a/code_phangl/main.c
+++ b/code_phangl/main.c
@@ -0,0 +1,113 @@
+// 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
+}