public void Init() { SyncCorr = new Correlator(CORR_TYPE.DELTA_DIFF, 15 * 32, 9 * 32, 6 * 32, CorrTargetThreshold, CorrAverageThreshold, CorrEnergyThreshold); Demodulator = new IQDemodulator(CARRIER_FREQ - 15, CARRIER_FREQ - 15, NUM_FREQ, ProcessingFrequency, SYMBOLRATE, SymbolFilterCoeffs); ProbeEncoder = new IQEncoder(BITS_PER_SYMBOL, Constellation.Table_1_to_1, Constellation.ITable_8PSK, Constellation.QTable_8PSK, EncodingType.SCRAMBLE_ADD); SymbDetector = new SymbolDetector(); EOMDetector = new BitCorrelator(); FillSyncPatterns(); SyncCorr.AddTarget(PreamblePattern); int FlipEOM = MILSTD_188.MSBFirst(MILSTD_188.EOM); EOMDetector.AddTarget(FlipEOM, 32); OutputData.Clear(); InputFilter.Clear(); PrevFunction = null; NextFunction = Idle; }
public void Run() { #region "Test of Frequency Detector" { IQModulator iqm = new IQModulator(1200 + 13, 1200 + 13, 1, 7200, 36, null); iqm.Init(); for (int i = 0; i < 243; i++) { iqm.Process(IQ.UNITY); } iqm.Finish(); float[] fa = new float[iqm.Count]; iqm.GetData(fa); IQDetector iqd = new IQDetector(1200, 7200, 36, 0, 1, -10, false); iqd.Init(); iqd.Process(fa, 0, fa.Length); } #endregion #region Test of the FFT Modulator and Demodulator { float BlockSize; BlockSize = ((7200.0f / MILSTD188_110B_39.SYMBOLRATE) + 0.5f); float[] Filter = new float[(int)BlockSize]; for (int i = 0; i < Filter.Length; i++) { Filter[i] = 2.0f / Filter.Length; } OFDMFFTModulator fftm = new OFDMFFTModulator(MILSTD188_110B_39.CARRIER_FREQ_LO, MILSTD188_110B_39.CARRIER_FREQ_HI, 39, 7200, MILSTD188_110B_39.SYMBOLRATE); OFDMFFTDemodulator fftd = new OFDMFFTDemodulator(MILSTD188_110B_39.CARRIER_FREQ_LO, MILSTD188_110B_39.CARRIER_FREQ_HI, 39, 7200, MILSTD188_110B_39.SYMBOLRATE); IQModulator regularm = new IQModulator(MILSTD188_110B_39.CARRIER_FREQ_LO, MILSTD188_110B_39.CARRIER_FREQ_HI, 39, 7200, MILSTD188_110B_39.SYMBOLRATE, null); IQDemodulator regulard = new IQDemodulator(MILSTD188_110B_39.CARRIER_FREQ_LO, MILSTD188_110B_39.CARRIER_FREQ_HI, 39, 7200, MILSTD188_110B_39.SYMBOLRATE, Filter); OFDMDemodulator ofdmd = new OFDMDemodulator(MILSTD188_110B_39.CARRIER_FREQ_LO, MILSTD188_110B_39.CARRIER_FREQ_HI, 39, 7200, MILSTD188_110B_39.SYMBOLRATE, 64f / 81f); IQDetector regdet = new IQDetector(MILSTD188_110B_39.CARRIER_FREQ_LO, 7200, MILSTD188_110B_39.SYMBOLRATE); fftm.Init(); fftd.Init(); ofdmd.Init(); regulard.Init(); fftm[0].Process(new IQ(1, 0)); fftm[1].Process(new IQ(0.7071f, 0.7071f)); fftm[2].Process(new IQ(0, -1)); fftm[3].Process(new IQ(-0.7071f, -0.7071f)); fftm[4].Process(new IQ(0, 1)); fftm[12].Process(new IQ(0, -1)); fftm[22].Process(new IQ(-1, 0)); fftm[0].Process(new IQ(-1, 0)); fftm[1].Process(new IQ(-0.7071f, -0.7071f)); fftm[2].Process(new IQ(0, 1)); fftm[3].Process(new IQ(0.7071f, -0.7071f)); fftm[4].Process(new IQ(0, -1)); fftm[12].Process(new IQ(-1, 0)); fftm[22].Process(new IQ(0, -1)); fftm[0].Process(new IQ(0, -1)); fftm[1].Process(new IQ(-0.7071f, 0.7071f)); fftm[2].Process(new IQ(-0.7071f, -0.7071f)); fftm[3].Process(new IQ(0, 1)); fftm[4].Process(new IQ(0.7071f, 0.7071f)); fftm[12].Process(new IQ(0.7071f, -0.7071f)); fftm[22].Process(new IQ(0, -1)); fftm[0].Process(new IQ(1, 0)); fftm[1].Process(new IQ(0.7071f, 0.7071f)); fftm[2].Process(new IQ(0, -1)); fftm[3].Process(new IQ(-0.7071f, -0.7071f)); fftm[4].Process(new IQ(0, 1)); fftm[12].Process(new IQ(0, -1)); fftm[22].Process(new IQ(-1, 0)); fftm.Finish(); regularm[0].Process(new IQ(1, 0)); regularm[1].Process(new IQ(0.7071f, 0.7071f)); regularm[2].Process(new IQ(0, -1)); regularm[3].Process(new IQ(-0.7071f, -0.7071f)); regularm[4].Process(new IQ(0, 1)); regularm[12].Process(new IQ(0, -1)); regularm[22].Process(new IQ(-1, 0)); regularm.Finish(); float[] ffr = new float[fftm.Count]; OFDMSync os = new OFDMSync((int)BlockSize); fftm.GetData(ffr); fftd.Process(ffr, 0, ffr.Length); regulard.Process(ffr, 0, ffr.Length); ofdmd.Process(ffr, 0, ffr.Length); regdet.Process(ffr, 0, ffr.Length); IQ[] ffriq = new IQ[ffr.Length]; for (int i = 0; i < ffriq.Length; i++) { ffriq[i] = new IQ(ffr[i], 0); } int SymbOffset = 18; os.Process(ffriq, SymbOffset, ffriq.Length - SymbOffset); regularm.GetData(ffr); fftd.Init(); ofdmd.Init(); regulard.Init(); fftd.Process(ffr, 0, ffr.Length); regulard.Process(ffr, 0, ffr.Length); ofdmd.Process(ffr, 0, ffr.Length); } #endregion #region Test of Generator and Quad double delta = (2 * Math.PI * 500) / 8000; double initialphase = 0.123456; // Generator tgSin = new Generator(); // Generator tgCos = new Generator(); // tgSin.Init(500, 8000, (float)(0 + initialphase)); // tgCos.Init(500, 8000, (float)(Math.PI / 2 + initialphase)); Quad tq = new Quad(500, 8000, initialphase); float maxError = 0; float tgdataSin; float tgdataCos; IQ tqData; for (int i = 0; i < 100000; i++) { float idealdataSin = (float)Math.Sin(initialphase + i * delta); float idealdataCos = (float)Math.Cos(initialphase + i * delta); // tqData = tq.Value; tq.Process(1, out tqData); tgdataSin = tqData.I; tgdataCos = tqData.Q; // tgSin.Process(1, out tgdataSin); // tgCos.Process(1, out tgdataCos); float error = Math.Abs(tgdataCos - idealdataCos); error += Math.Abs(tgdataSin - idealdataSin); if (error > maxError) { maxError = error; } } #endregion #region Test of Quad Modulators/Demodulators { IQModulator tm = new IQModulator(1000, 1000, 1, 8000, 250, null); IQEncoder te = new IQEncoder(2, Constellation.BitsToPhase_39, Constellation.IQTable_QPSK45, EncodingType.DIFF_IQ); OFDMDemodulator tt = new OFDMDemodulator(1000, 1000, 1, 8000, 250, 1); IQDecoder td = new IQDecoder(2, Constellation.BitsToPhase_39, Constellation.IQTable_QPSK45, EncodingType.DIFF_IQ); int[] EncData = new int[] { 0, 1, 2, 3, 0, 0, 1, 1, 2, 2, 3, 3, 2, 1, 0 }; IQ IQData; // Send reference signal tm.Process(IQ.UNITY); foreach (int symbol in EncData) { te.Process(symbol, out IQData); tm.Process(IQData); } Samples outputTestSamples = new Samples(@"C:\TestMod.raw", 1.0f); float[] TestSamplesOut = new float[tm.Count]; tm.GetData(TestSamplesOut); outputTestSamples.ToByte(TestSamplesOut); outputTestSamples.Close(); tt.Process(TestSamplesOut, 0, TestSamplesOut.Length); List <int> TestOut = new List <int>(); int Symb; while (tt.Count > 0) { td.Process(tt.GetData(), out Symb); TestOut.Add(Symb); } TestOut.Clear(); } #endregion #region Test SoftConvolutional Encoder { int[] Poly = { 0x7, 0x5, 0x3, 0x6 }; int[] PolyMIL = { 0x5B, 0x79 }; int[] input = { 0xF7, 0x45, 0x12, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0xFF, 0xA5 }; BitArray sba = new BitArray(8); sba.Add(input); ConvEncoder sce = new ConvEncoder(ConvEncoderType.TailBiting_Head, 2, 7, PolyMIL, 0x7, 4); byte[] ddd = new byte[sba.BitsCount]; sba.GetData(ddd); sce.Process(ddd, 0, ddd.Length); sce.Finish(); ddd = new byte[sce.Count]; sce.GetData(ddd); // ddd has all databits VitDecoder svd = new VitDecoder(ConvEncoderType.TailBiting_Head, 2, 7, PolyMIL, 0x7, 4, 3); svd.Process(ddd, 0, ddd.Length); svd.Finish(); ddd = new byte[svd.Count]; svd.GetData(ddd); BitArray res = new BitArray(8); res.Add(ddd); int[] ttt = new int[res.SymbolsCount]; res.GetData(ttt); } #endregion // Test of the 39-tone codec MILSTD188_110B_39 m = new MILSTD188_110B_39(MILSTD_188.Mode.D_2400S, 7200, 7200, null, null); BitArray ba = new BitArray(12); for (int i = 0; i < 800; i++) { ba.Add(i); } byte[] da = new byte[ba.BitsCount]; ba.GetData(da); m.Tx.Start(); m.Tx.Process(da, 0, da.Length); m.Tx.Finish(); Samples outputSamples = new Samples(@"C:\test39.raw", 1.5f); float[] SamplesOut = new float[m.Tx.SampleCount]; m.Tx.GetData(SamplesOut, 0); outputSamples.ToByte(SamplesOut); outputSamples.Close(); string FileName = @"C:\test39"; Samples InputSamples = new Samples(FileName + ".raw"); float[] SamplesIn = new float[100]; List <float> Test39Samples = new List <float>(); int n; do { n = InputSamples.ToFloat(SamplesIn); for (int i = 0; i < n; i++) { Test39Samples.Add(SamplesIn[i]); } } while (n > 0); InputSamples.Close(); m.Rx.pd1.Init(); m.Rx.pd2.Init(0); // foreach (float sample in SamplesOut) // { // m.Rx.pd3.Process(sample); // } foreach (float sample in Test39Samples) { if (!m.Rx.pd1.IsSyncFound) { m.Rx.pd1.Process(sample); if (m.Rx.pd1.IsSyncFound) { m.Rx.pd2.Init(m.Rx.pd1.FrequencyOffset); } } else { if (!m.Rx.pd2.IsSyncFound) { m.Rx.pd2.Process(sample); if (m.Rx.pd2.IsErrorFound) { m.Rx.pd2.Init(0); m.Rx.pd1.Init(); } if (m.Rx.pd2.IsSyncFound) { m.Rx.pd3.Init(m.Rx.pd2.FrequencyOffset); } } else { m.Rx.pd3.Process(sample); } } } List <byte> RegenData = new List <byte>(); System.IO.FileStream File = System.IO.File.Open(FileName + ".asc", System.IO.FileMode.Create); while (m.Rx.pd3.Count > 0) { byte dbyte = m.Rx.pd3.GetData(); RegenData.Add(dbyte); File.WriteByte((byte)(dbyte + 0x30)); } File.Close(); da = new byte[RegenData.Count]; IQ[] iqda = new IQ[m.Rx.pd3.RawCount]; RegenData.CopyTo(da); m.Rx.pd3.GetRawData(iqda); m = new MILSTD188_110B_39(MILSTD_188.Mode.D_2400S, 7200, 7200, null, null); m.Tx.Start(); m.Tx.ProcessRaw(da, 0, da.Length); // m.Tx.ProcessRaw(iqda, 0, iqda.Length); m.Tx.Finish(); outputSamples = new Samples(FileName + "-regen.raw", 1.0f); SamplesOut = new float[m.Tx.SampleCount]; m.Tx.GetData(SamplesOut, 0); outputSamples.ToByte(SamplesOut); outputSamples.Close(); #region Test of Complex data { IQ a = new IQ(1, 2); IQ b = new IQ(3, 4); IQ c = new IQ(5, 6); IQ f = a + b; f = a * c; f = f - a; f = a / b; f -= b; } #endregion #region Test of Serial Class SerialData tx = new SerialData(7, 1, 1, SerialData.Parity.N); SerialData rx = new SerialData(7, 1, 1, SerialData.Parity.N); for (int i = 0; i < 256; i++) { tx.PutSymbol(i); } byte[] rdd = new byte[10000]; int nbits = tx.GetData(rdd); rx.PutData(rdd, 0, nbits); int[] rsymb = new int[256]; rx.GetData(rsymb); #endregion #region Test Convolutional Encoder { int[] Poly = { 0x7, 0x5, 0x3, 0x6 }; int[] PolyMIL = { 0x5B, 0x79 }; // OldConvEncoder ce = new OldConvEncoder(2, 7, PolyMIL, 0x7, 4, ConvEncoderType.TailBiting_Head); byte[] input = { 0xF7, 0x45, 0x12, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0xFF, 0xA5 }; byte[] output = new byte[input.Length * 4]; byte[] res = new byte[input.Length]; int iBits = input.Length * 8; // int nBits = ce.Process(input, 0, output, 0, iBits); // Test Convolutional decoder output[0] ^= 0x08; output[2] ^= 0x04; output[5] ^= 0x01; output[7] ^= 0x20; output[10] ^= 0x40; output[13] ^= 0x10; output[15] ^= 0x80; // OldVitDecoder vd = new OldVitDecoder(2, 7, PolyMIL, 0x7, 4, 6, ConvEncoderType.TailBiting_Head); int[] sdd = new int[200]; // int qBits = vd.Quantize(output, sdd, nBits); // int rBits = vd.Process(output, res, nBits); } #endregion #region Test of the IQEncoder and IQDecoder int[] symb = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 0, 3, 5, 7, 4, 3, 2, 1 }; IQEncoder e = new IQEncoder(2, Constellation.Table_1_to_1, Constellation.ITable_QPSK, Constellation.QTable_QPSK, EncodingType.NON_DIFF); IQDecoder d = new IQDecoder(2, Constellation.Table_1_to_1, Constellation.ITable_QPSK, Constellation.QTable_QPSK, EncodingType.NON_DIFF); IQ iqs; int r; for (int i = 0; i < symb.Length; i++) { e.Process(symb[i], out iqs); d.Process(iqs, out r); } #endregion float[] fCoeff = Filters.Fill(Filters.rrc_180, 2); int[] datadecoded = new int[300]; int[] syncseq = { 0, 1, 3, 0, 1, 3, 1, 2, 0, 7, 7, 4, 4, 6, 0, 0, 1, 3, 0, 1, 3, 1, 2, 0, 7, 7, 4, 4, 5, 0, }; IQ[] syncIQ = new IQ[syncseq.Length]; const float SamplingFreq = 24000; const float SymbolFreq = 2400; const float CarrierFreq = 1800; const float FreqOffset = 0; const float PhaseOffset = 0; const int GrpDelay = 0; int DFac = (int)(SamplingFreq / SymbolFreq); // Let's start with the encoder and decoder e = new IQEncoder(3, Constellation.Table_1_to_1, Constellation.IQTable_8PSK, EncodingType.NON_DIFF); d = new IQDecoder(3, Constellation.Table_1_to_1, Constellation.IQTable_8PSK, EncodingType.NON_DIFF); // Create Modulator IQModulator mod = new IQModulator(CarrierFreq + FreqOffset, CarrierFreq + FreqOffset, 1, SamplingFreq, SymbolFreq, fCoeff); // Add offset mod.Phase = PhaseOffset; // Create Demodulator IQDemodulator dem = new IQDemodulator(CarrierFreq, CarrierFreq, 1, SamplingFreq, SymbolFreq, fCoeff); // Now correlator to catch the symbol pattern and sync on it Correlator corr = new Correlator(CORR_TYPE.DELTA_DIFF, 70, 30, 15, 0.5f, 10.0f, 5.0f); e.Init(); // Fill the sync pattern for (int i = 0; i < syncseq.Length; i++) { e.Process(syncseq[i], out syncIQ[i]); } corr.AddTarget(syncIQ); IQ sym; //Encode and Modulate - result goes into incomingData[] array e.Init(); for (int i = 0; i < datastream.Length; i++) { e.Process(datastream[i], out sym); mod.Process(sym, incomingData, i * DFac + GrpDelay); } // Output 20 more ZERO symbols to flush modulator sym = IQ.ZERO; for (int i = datastream.Length; i < datastream.Length + 20; i++) { mod.Process(sym, incomingData, i * DFac + GrpDelay); } //------------------ Now start processing the data on the receiver side IQ[] demodArray = new IQ[300]; // start feeding the data into the demodulator - turn symbolsync search first int startIdx = 0; int outIdx = 0; // feed the data until we get a symbol sync dem.Init(); dem.StartCorrectionProcess(SYNC_TYPE.GARDNER_DD | SYNC_TYPE.GARDNER_NDA | SYNC_TYPE.QAMLD_NDA | SYNC_TYPE.DIFF_NDA | SYNC_TYPE.ZERODET_NDA | SYNC_TYPE.PEAK_NDA | SYNC_TYPE.CORR_NDA, 100); while (!dem.IsSyncReady) { dem.Process(incomingData, startIdx, DFac); startIdx += DFac; } // Feed demodulated data into correlator and search for sync pattern corr.Init(); corr.StartCorrectionProcess(); for (int i = 0; !corr.IsSyncReady; i++, startIdx += DFac) { int nSymb = dem.Process(incomingData, startIdx, DFac); while (nSymb-- > 0) { IQ iqData = dem.GetData(); demodArray[outIdx++] = iqData; corr.Process(iqData); } } dem.RotateCorrection = corr.RotateCorrection; dem.FrequencyCorrection = corr.FrequencyCorrection; corr.GetLastData(corr.CorrelationMaxIndex, demodArray, corr.CorrelationMaxIndex); outIdx = corr.CorrelationMaxIndex; while (startIdx < (incomingData.Length - DFac)) { int nSym = dem.Process(incomingData, startIdx, DFac); while (nSym-- > 0) { demodArray[outIdx++] = dem.GetData(); } startIdx += DFac; } d.Init(); d.StartCorrectionProcess(300); int iSymb; for (int i = 0; i < demodArray.Length; i++) { d.Process(demodArray[i], out iSymb); datadecoded[i] = iSymb; } demodArray.Initialize(); #region Test of Integrate and Dump decoder { int[] teststring = { 0, 4, 0, 4, 0, 4, 0, 4, 4 }; int[] datadecoded1 = new int[300]; const float SYMBOL_TIME = 0.0225f; // Every symbol lasts for 22.5ms const float SYMBOLRATE = 1 / SYMBOL_TIME; // Symbol rate will be 44.44444444 Hz const float SamplingFreq1 = 8000; const float SymbolFreq1 = SYMBOLRATE; const float CarrierFreq1 = 1800; const float FreqOffset1 = 0; const float PhaseOffset1 = 0; const int GrpDelay1 = 0; int DFac1 = (int)(SamplingFreq1 / SymbolFreq1); // Let's start with the encoder and decoder e = new IQEncoder(3, Constellation.Table_1_to_1, Constellation.IQTable_8PSK, EncodingType.NON_DIFF); d = new IQDecoder(3, Constellation.Table_1_to_1, Constellation.IQTable_8PSK, EncodingType.NON_DIFF); // Create Modulator IQModulator mod1 = new IQModulator(CarrierFreq1 + FreqOffset1, CarrierFreq1 + FreqOffset1, 1, SamplingFreq1, SymbolFreq1, null); // Add offset mod1.Phase = PhaseOffset1; // Create Demodulator Quad dem1 = new Quad(CarrierFreq1, SamplingFreq1); e.Init(); IQ sym1; //Encode and Modulate - result goes into incomingData[] array e.Init(); Array.Clear(incomingData, 0, incomingData.Length); for (int i = 0; i < teststring.Length; i++) { e.Process(teststring[i], out sym1); mod1.Process(sym1, incomingData, i * DFac1 + GrpDelay1); } // Output 20 more ZERO symbols to flush modulator //------------------ Now start processing the data on the receiver side IQ[] demodArray1 = new IQ[300]; IntegrateAndDump IandD = new IntegrateAndDump(DFac1); // IandD.Offset = DFac1 / 2; // start feeding the data into the demodulator int[] decodedData = new int[64]; int outIdx1 = 0; foreach (float sample in incomingData) { dem1.Process(sample, out sym1); IandD.Process(sym1); while (IandD.Count > 0) { sym1 = IandD.GetData(); demodArray1[outIdx1] = sym1; d.Process(sym1, out decodedData[outIdx1++]); } } } #endregion #region Decimator Testing /* Testing of the Decimator */ int K = 50; int SAMP = 200; int DEC = 10; float[] Arr = new float[K]; float[] Samp = new float[SAMP]; for (int i = 0; i < Arr.Length; i++) { Arr[i] = 1; } for (int i = 0; i < Samp.Length; i++) { Samp[i] = i / 100.0f; } FIR fff = new FIR(Arr, DEC); float[] rrr = new float[Samp.Length / DEC]; float[] mmm = { 1, 2, 3 }; float[] mmmm = { 1, 2, 3, 4, 5, 6, 7 }; fff.Decimate(mmm, rrr); fff.Decimate(mmm, rrr); fff.Decimate(mmmm, rrr); fff.Decimate(Samp, rrr); fff.Decimate(mmmm, rrr); fff.Decimate(mmm, rrr); fff.Decimate(mmmm, rrr); fff.Decimate(mmm, rrr); fff.Decimate(mmmm, rrr); fff.Decimate(mmmm, rrr); fff.Decimate(mmmm, rrr); #endregion #region // Test EOM detector BitCorrelator bc = new BitCorrelator(); int FlipEOM = MILSTD_188.MSBFirst(MILSTD_188.EOM); bc.AddTarget(FlipEOM, 32); BitArray testBA = new BitArray(8); testBA.Add(0x12); testBA.Add(0x15); testBA.Add((FlipEOM >> 0) & 0x00FF); testBA.Add((FlipEOM >> 8) & 0x00FF); testBA.Add((FlipEOM >> 16) & 0x00FF); testBA.Add((FlipEOM >> 24) & 0x00FF); testBA.Add(0xFF); testBA.Add(0x05); byte[] testArray = new byte[testBA.BitsCount]; testBA.GetData(testArray); bc.Process(testArray, 0, testArray.Length); #endregion // etab [] Tab = new etab[] //{ // {4, 0x13, 1, 1, 4, 8, 10 }, // RS(7,3) on GF(15) // {4, 0x13, 1, 1, 4, 1, 10 }, // RS(14,10) on GF(15) // {4, 0x13, 1, 1, 4, 9, 10 }, // RS(6,2) on GF(15) // {4, 0x13, 1, 1, 4, 10, 10 }, // RS(5,1) on GF(15) // {2, 0x7, 1, 1, 1, 0, 10 }, // {3, 0xb, 1, 1, 2, 0, 10 }, // {4, 0x13, 1, 1, 4, 0, 10 }, // {5, 0x25, 1, 1, 6, 0, 10 }, // {6, 0x43, 1, 1, 8, 0, 10 }, // {7, 0x89, 1, 1, 10, 0, 10 }, // {8, 0x11d, 1, 1, 32, 0, 10 }, // {8, 0x187, 112,11, 32, 0, 10 }, /* Duplicates CCSDS codec */ // {9, 0x211, 1, 1, 32, 0, 10 }, // {10,0x409, 1, 1, 32, 0, 10 }, // {11,0x805, 1, 1, 32, 0, 10 }, // {12,0x1053, 1, 1, 32, 0, 5 }, // {13,0x201b, 1, 1, 32, 0, 2 }, // {14,0x4443, 1, 1, 32, 0, 1 }, // {15,0x8003, 1, 1, 32, 0, 1 }, // {16,0x1100b, 1, 1, 32, 0, 1 }, // {0, 0, 0, 0, 0}, //}; //----------------------------------------------------------------------------------------------------------------------------------- #region Test of the bit rearranger BitGroup[] D2400_old = { new BitGroup(0 * 78, 64) }; BitGroup[] D1200_old = { new BitGroup(0 * 64, 64), new BitGroup(0 * 63, 14) }; BitGroup[] D600_old = { new BitGroup(0 * 32, 32), new BitGroup(0 * 32, 32), new BitGroup(0, 14) }; BitGroup[] D300_old = { new BitGroup(0 * 16, 16), new BitGroup(0 * 16, 16), new BitGroup(0 * 16, 16), new BitGroup(0 * 16, 16), new BitGroup(0 * 0, 14) }; BitGroup[] D150_old = { new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 8, 8), new BitGroup(0 * 0, 8), new BitGroup(0 * 8, 6) }; BitGroup[] D75_old = { new BitGroup(0 * 0, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(0 * 4, 2) }; BitGroup[] D2400_new = { new BitGroup(0 * 78, 64) }; BitGroup[] D1200_new = { new BitGroup(0 * 64, 64), new BitGroup(0 * 63, 14) }; BitGroup[] D600_new = { new BitGroup(0 * 32, 32), new BitGroup(8 * 32, 32), new BitGroup(0, 14) }; BitGroup[] D300_new = { new BitGroup(0 * 16, 16), new BitGroup(4 * 16, 16), new BitGroup(8 * 16, 16), new BitGroup(12 * 16, 16), new BitGroup(0 * 0, 14) }; BitGroup[] D150_new = { new BitGroup(0 * 8, 8), new BitGroup(2 * 8, 8), new BitGroup(4 * 8, 8), new BitGroup(6 * 8, 8), new BitGroup(8 * 8, 8), new BitGroup(10 * 8, 8), new BitGroup(12 * 8, 8), new BitGroup(14 * 8, 8), new BitGroup(0 * 0, 8), new BitGroup(2 * 8, 6) }; BitGroup[] D75_new = { new BitGroup(0 * 0, 4), new BitGroup(1 * 4, 4), new BitGroup(2 * 4, 4), new BitGroup(3 * 4, 4), new BitGroup(4 * 4, 4), new BitGroup(5 * 4, 4), new BitGroup(6 * 4, 4), new BitGroup(7 * 4, 4), new BitGroup(8 * 4, 4), new BitGroup(9 * 4, 4), new BitGroup(10 * 4, 4), new BitGroup(11 * 4, 4), new BitGroup(12 * 4, 4), new BitGroup(13 * 4, 4), new BitGroup(14 * 4, 4), new BitGroup(15 * 4, 4), new BitGroup(0 * 4, 4), new BitGroup(1 * 4, 4), new BitGroup(2 * 4, 4), new BitGroup(3 * 4, 2) }; DataSpreader <byte> dsp = new DataSpreader <byte>(4, D75_new); DataCombiner dcb = new DataCombiner(4, D75_new); dsp.Init(); dcb.Init(); for (int idx = 0; idx < 100; idx++) { dsp.Process((byte)idx); } byte[] od = new byte[dsp.Count]; dsp.GetData(od, 0); foreach (byte b in od) { dcb.Process(b); } #endregion //----------------------------------------------------------------------------------------------------------------------------------- #region Test of the SoftInterleaver // Interleaver_188_110B_39 il = new Interleaver_188_110B_39(18, 12, 4, 7, 3); Interleaver_188_110B_39 il = new Interleaver_188_110B_39(18, 12, 4, 7, 3); il.Init(); int ii = 0; il.Init(); while (!il.IsDataReady) { int Data = ii++; for (int i = 0; (i < 4); i++) { il.ProcessEncode((byte)(Data & 0x0001)); Data >>= 1; } } byte[] OutData = new byte[il.Count]; il.GetData(OutData, 0); Queue <byte> chann = new Queue <byte>(); foreach (byte b in OutData) { chann.Enqueue(b); } il.Init(); while (chann.Count > 0) { il.ProcessDecode(chann.Dequeue()); } while (!il.IsDataReady) { il.ProcessDecode(0); } OutData = new byte[il.Count]; il.GetData(OutData, 0); #endregion ReedSolomon rs = new ReedSolomon(); rs.Init(4, 0x13, 1, 1, 4, 8); int[] data = new int[7]; data[0] = 0x08; data[1] = 0x03; data[2] = 0x04; int[] parity, eras; eras = new int[15]; parity = new int[15]; rs.Encode(data, parity); Array.Copy(parity, 0, data, 3, 4); data[0] = 0x00; data[1] = 0x00; data[2] = 0x00; // data[3] = 0x00; eras[0] = 0; eras[1] = 1; eras[2] = 2; eras[3] = 3; int nerr = rs.Decode(data, eras, 3); LFSR__188_110B_39 lsr = new LFSR__188_110B_39(9, 0x0116); lsr.Init(0x01); int ff = 0; while ((lsr.Value & 0x1FF) != 0x1FF) { ff++; lsr.Shift(); } int rr = (int)lsr.CurrentBit; int[] requiredoffsets = { 252, 256, 260, 264, 267, 268, 272, 280, 288, 300, 308, 340, 356, 376, 384, 385, 392, 396, 400, 408, 416, 420, 432, 440, 444, 448, 464, 480, 484, 497, 504, 512, 520, 528 }; int[] calculatedseeds = new int[requiredoffsets.Length]; int[] mem = new int[511]; int el = 0; int q = 0; el = 0; lsr.Init(0x1FF); do { lsr.Shift(); mem[el++] = lsr.Value & 0x1FF; } while ((lsr.Value & 0x1FF) != 0x1FF); foreach (int req in requiredoffsets) { el = 510 - req; if (el < 0) { el += 511; } calculatedseeds[q++] = mem[el] & 0x1FF; } q = 0; foreach (int load in calculatedseeds) { lsr.Init(load); lsr.Shift(requiredoffsets[q++]); el = (int)lsr.Value; rr = (int)lsr.CurrentBit; } int[] AllValues = new int[512]; lsr.Init(0x1FF); ii = 0; for (ii = 0; ii < 0x200; ii++) { AllValues[ii] = lsr.Value & 0x1FF; lsr.Shift(); } // Now calculate the seed value differently int[] newseeds = new int[requiredoffsets.Length]; ii = 0; foreach (int req in requiredoffsets) { int ShiftVal = 0x200 - req - 1; if (ShiftVal < 0) { ShiftVal += 0x200 - 1; } lsr.Init(0x1FF); lsr.Shift(ShiftVal); newseeds[ii++] = lsr.Value & 0x1FF; } }
int ReceiveProbe(float[] incomingSamples, int startingIndex, int numSamples) { if (numSamples == 0) { LFSRState State = DataScrambler.State; // Save current DataScrambler state Array.Clear(Probe, 0, CurrentMode.ProbeDataSymbols); // The last 2 probes for the interleaver are special - // they are not 0, but D1 and D2 values instead if (ProbeCounter == (TotalPatternsInBlock - 2)) { ChanSymbToTribit[CurrentMode.D1].CopyTo(Probe, 0); // Send 8 tribits ChanSymbToTribit[CurrentMode.D1].CopyTo(Probe, 8); // Send 8 tribits } else if (ProbeCounter == (TotalPatternsInBlock - 1)) { ChanSymbToTribit[CurrentMode.D2].CopyTo(Probe, 0); // Send 8 tribits ChanSymbToTribit[CurrentMode.D2].CopyTo(Probe, 8); // Send 8 tribits } for (int k = 0; k < CurrentMode.ProbeDataSymbols; k++) { ProbeEncoder.Process(Probe[k], DataScrambler.DataNext(), SCRAMBLE_MASK, out ProbeTarget[k]); } ProbeCorr.AddTarget(ProbeTarget); DataScrambler.State = State; // Restore scrambler state ProbeCounter++; if (ProbeCounter >= TotalPatternsInBlock) { ProbeCounter = 0; } Demodulator.RotateCorrection *= Decoder.RotateCorrection; Demodulator.FrequencyCorrection *= (IQ.UNITY + 0.05f * Decoder.FrequencyCorrection) / 1.05f; ProbeCorr.StartCorrectionProcess(); // Demodulator.StartCorrectionProcess(SYNC_TYPE.GARDNER_DD | SYNC_TYPE.GARDNER_NDA | SYNC_TYPE.QAMLD_NDA | // SYNC_TYPE.DIFF_NDA | SYNC_TYPE.ZERODET_NDA | SYNC_TYPE.PEAK_NDA | SYNC_TYPE.CORR_NDA, // CurrentMode.UnknownDataSymbols + CurrentMode.ProbeDataSymbols); Decoder.StartCorrectionProcess(CurrentMode.UnknownDataSymbols + CurrentMode.ProbeDataSymbols); this.SymbolsCounter = 0; } int i, nProc; int Data; IQ Symb; for (i = 0; i < numSamples; i += nProc) { nProc = Math.Min(numSamples - i, DECFACTOR); int nSymb = Demodulator.Process(incomingSamples, startingIndex + i, nProc); while (nSymb-- > 0) { Symb = Demodulator.GetData(); ProbeCorr.Process(Symb); Decoder.Process(Symb, DataScrambler.DataNext(), SCRAMBLE_MASK, out Data); SymbolsCounter++; // Is data sequence coming ? if (SymbolsCounter >= CurrentMode.ProbeDataSymbols) { Demodulator.RotateCorrection *= ProbeCorr.RotateCorrection; Demodulator.FrequencyCorrection *= (IQ.UNITY + 0.05f * ProbeCorr.FrequencyCorrection) / 1.05f; ProcessData(); // Process received data NextFunction = ReceiveData; numSamples = 0; break; } } } return(i); }