Initial import

arphy.c

@@ -0,0 +1,92 @@
+/* the arPhy physical layer */
+
+#include <string.h>
+#include <stdint.h>
+
+#include "../../net/net.h" // necessario? vedi net_generate_block
+
+#include "../phy.h"
+#include "arphy.h"
+
+#include "../../modem/modem_types.h"
+
+
+// encoda un po di data in un buffer di simboli, torna il numero di simboli encodati
+
+uint8_t arphy_data2symbol(uint8_t *InData, uint8_t *ModulationSymbolsBuffer) {
+    uint8_t FEC_index = 0, data_chunk = 0;
+    uint8_t i;
+    uint16_t bit_index;
+
+    // pulisci buffer simboli - necessario
+    memset(ModulationSymbolsBuffer, 0, interleaver.size);
+
+    // cicla i fec contenuti in un blocco di interleave
+    for (FEC_index = 0; FEC_index < interleaver.fec_blocks_size; FEC_index++) {
+        // spezza dati in pezzi grandi come il netto di un FEC
+        data_chunk = phy_data_to_chunk(InData, FEC_index, fec.in_bit_size, 0);
+
+        // pulisci buffer matrice di hadamard
+        memset(tx_FHT_Buffer, 0, MAX_FEC_OUTPUT_SIZE);
+
+        // encoda chunk in matrice FEC
+        arphy_FEC_encode(data_chunk, fec.in_bit_size, tx_FHT_Buffer);
+
+        // dispone matrice FEC nella costellazione
+        for (i = 0; i < fec.out_bit_size; i++) {
+            bit_index = (FEC_index * fec.out_bit_size) + i;
+
+            // rimappa
+            if (interleaver.type == ARPHY_INTERLEAVER_TYPE_HELIX) {
+                bit_index = arphy_index_interleave(bit_index, mod.bits_per_symbol, interleaver.symbols_size);
+            } else if (interleaver.type == ARPHY_INTERLEAVER_TYPE_NONE) {
+                // nulla
+            }
+
+
+            phy_bit_to_constellation(tx_FHT_Buffer[i], bit_index, ModulationSymbolsBuffer, mod.bits_per_symbol, interleaver.symbols_size);
+        }
+    }
+    return interleaver.symbols_size;
+}
+
+// torna bytes dati encodati
+
+uint8_t arphy_symbol2data(uint8_t *OutData, uint8_t *ModulationSymbolsBuffer) {
+    uint8_t FECIndex = 0, Chunk = 0;
+    uint8_t i;
+    uint16_t bit_index;
+    for (FECIndex = 0; FECIndex < interleaver.fec_blocks_size; FECIndex++) {
+        // pulisci buffer matrice
+        memset(rx_FHT_Buffer, 0, MAX_FEC_OUTPUT_SIZE);
+
+        // estrae il binario dalla costellazione e lo mette in matrice
+        for (i = 0; i < fec.out_bit_size; i++) {
+            bit_index = (FECIndex * fec.out_bit_size) + i;
+            // interfoglia!
+            if (interleaver.type == ARPHY_INTERLEAVER_TYPE_HELIX) {
+                bit_index = arphy_index_deinterleave(bit_index, mod.bits_per_symbol, interleaver.symbols_size);
+            } else if (interleaver.type == ARPHY_INTERLEAVER_TYPE_NONE) {
+                // nulla
+            }
+
+            rx_FHT_Buffer[i] = phy_constellation_to_bit(bit_index, ModulationSymbolsBuffer, mod.bits_per_symbol, interleaver.symbols_size);
+        }
+
+        // decodifica il FEC in-place e torna i dati puliti
+        Chunk = arphy_FEC_decode(rx_FHT_Buffer);
+
+        // aggrega i chunk su OutData
+        phy_chunk_to_data(OutData, FECIndex, fec.in_bit_size, 0, Chunk);
+    }
+    return interleaver.net_bit_size / 8;
+}
+
+uint8_t arphy_generate_symbol_buffer(uint8_t *SymbolBuffer) {
+    uint8_t out_symbols = 0;
+    uint8_t BlockBuffer[4];
+    net_generate_block(BlockBuffer, phy_block_buffer_size);
+    out_symbols = arphy_data2symbol(BlockBuffer, SymbolBuffer);
+
+    return out_symbols;
+}