// BLOCK LEN 1 und MAX_FIR_COEFFS 64 werden vom Compiler mitgegeben

//#define SIMULATE

#ifdef SIMULATE
    #include <stdio.h>
#endif

#include <stdint.h>
#include "signal_processing/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
}