Example #1
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }
            SignalBuffer dbin  = getSignalInputBuffer(ioI);
            SignalBuffer dbout = getSignalOutputBuffer(ioO);

            if ((dbin == null) && (dbout == null))
            {
                return;
            }

            if (filter == null)
            {
                filter = new AFilterIIR(owner.sampleRate);
            }

            if (dbin != null)
            {
                for (int i = 0; i < owner.blockSize; i++)
                {
                    double x = dbin.data[i];
                    double y = filter.filter(x);
                    if (dbout != null)
                    {
                        dbout.data[i] = y;
                    }
                }
            }
        }
Example #2
0
        private void processChannel(SignalBuffer d, RTLED rl, int led)
        {
            Boolean restate = state[led];

            if (d != null)
            {
                for (int j = 0; j < owner.blockSize; j++)
                {
                    if (d.data[j] > 0)
                    {
                        restate = true;
                    }
                    else
                    {
                        restate = false;
                    }
                }
            }
            else
            {
                restate = false;
            }
            state[led] = restate;
            if (state[led] && !rl.LEDState)
            {
                rl.LEDState = true;
            }
            if (!state[led] && rl.LEDState)
            {
                rl.LEDState = false;
            }
        }
Example #3
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            countMax = (int)Math.Floor(windowLength * owner.sampleRate + 0.5);

            if (resetCount)
            {
                for (int i = 0; i < channels; i++)
                {
                    count[i] = 0;
                    S[i]     = S2[i] = 0;
                }
                resetCount = false;
            }

            for (int j = 0; j < channels; j++)
            {
                if (ioX[j].connectedTo != null)
                {
                    SignalBuffer db = ioX[j].connectedTo.signalOutput;
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        S[j]  += db.data[i];
                        S2[j] += db.data[i] * db.data[i];
                        count[j]++;
                        if (count[j] >= countMax)
                        {
                            double v = Math.Sqrt(S2[j] / count[j]);
                            if (removeDC)
                            {
                                v -= Math.Abs(S[j]) / count[j];
                            }
                            if (v < 1e-6)
                            {
                                newValue(j, -120);
                            }
                            else
                            {
                                newValue(j, 20.0 * Math.Log10(v));
                            }
                            count[j] = 0;
                            S[j]     = S2[j] = 0;
                        }
                    }
                }
                else
                {
                    count[j] = 0;
                    S[j]     = S2[j] = 0;
                    newValue(j, -120);
                }
            }
        }
Example #4
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer sx = getSignalInputBuffer(ioX);
            SignalBuffer sy = getSignalInputBuffer(ioY);

            if ((sx == null) && (sy == null))
            {
                return;
            }

            if (xdata == null)
            {
                xdata    = new double[256];
                ydata    = new double[256];
                datafill = 0;
            }

            for (int i = 0; i < owner.blockSize; i++)
            {
                double x = 0;
                double y = 0;
                if (sx != null)
                {
                    x = sx.data[i] / xyscale;
                }
                if (sy != null)
                {
                    y = sy.data[i] / xyscale;
                }

                acx = acx * 0.99 + x * 0.01;
                acy = acy * 0.99 + y * 0.01;

                if (AC)
                {
                    x -= acx;
                    y -= acy;
                }

                xdata[datafill] = x;
                ydata[datafill] = y;
                datafill++;

                if (datafill >= 256)
                {
                    xyDisplay.addData(xdata, ydata);
                    datafill = 0;
                }
            }
        }
Example #5
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer dbin  = getSignalInputBuffer(ioIn);
            SignalBuffer dbout = getSignalOutputBuffer(ioOut);

            if (!active)
            {
                if ((dbin != null) && (dbout != null))
                {
                    dbout.CopyFrom(dbin);
                }
                return;
            }
            SignalBuffer dbf = getSignalInputBuffer(ioF);
            SignalBuffer dbq = getSignalInputBuffer(ioQ);

            if (dbout == null)
            {
                return;
            }
            if (dbin == null)
            {
                return;
            }

            if (filter == null)
            {
                if (HighPass)
                {
                    filter = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.HighPass, Math.Sqrt(f1 * f2), Math.Pow(10, (q1 + q2) / 2 / 20));
                }
                else
                {
                    filter = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.LowPass, Math.Sqrt(f1 * f2), Math.Pow(10, (q1 + q2) / 2 / 20));
                }
            }

            for (int i = 0; i < owner.blockSize; i++)
            {
                double fin = (dbf != null) ? dbf.data[i] : 0;
                double qin = (dbq != null) ? dbq.data[i] : 0;
                double sig = (dbin != null) ? dbin.data[i]:0;
                fin = f1 * Math.Pow(f2 / f1, (fin + 1.0) / 2.0);
                qin = Math.Pow(10, (q1 + (q2 - q1) * (qin + 1.0) / 2) / 20);
                filter.frequency = fin;
                filter.Q         = qin;
                sig           = filter.filter(sig);
                dbout.data[i] = sig;
            }
        }
Example #6
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }
            SignalBuffer dbout = getSignalOutputBuffer(ioOut);

            if (dbout == null)
            {
                return;
            }
            SignalBuffer dbin = null;

            if ((channels >= 1) && (input == 0))
            {
                dbin = getSignalInputBuffer(io1);
            }
            if ((channels >= 2) && (input == 1))
            {
                dbin = getSignalInputBuffer(io2);
            }
            if ((channels >= 3) && (input == 2))
            {
                dbin = getSignalInputBuffer(io3);
            }
            if ((channels >= 4) && (input == 3))
            {
                dbin = getSignalInputBuffer(io4);
            }
            if ((channels >= 5) && (input == 4))
            {
                dbin = getSignalInputBuffer(io5);
            }
            if ((channels >= 6) && (input == 5))
            {
                dbin = getSignalInputBuffer(io6);
            }
            if ((channels >= 7) && (input == 6))
            {
                dbin = getSignalInputBuffer(io7);
            }
            if ((channels >= 8) && (input == 7))
            {
                dbin = getSignalInputBuffer(io8);
            }

            if (dbin == null)
            {
                return;
            }

            dbout.CopyFrom(dbin);
        }
Example #7
0
        public override void tick()
        {
            SignalBuffer dbin  = getSignalInputBuffer(ioI);
            SignalBuffer dbout = getSignalOutputBuffer(ioO);

            if ((dbin == null) || (dbout == null))
            {
                return;
            }

            dbout.CopyFrom(dbin);
        }
Example #8
0
        public override void tick()
        {
            if (averager == null)
            {
                countTime = (int)Math.Floor(countTimeD * owner.sampleRate + 0.5);
                averager  = new AudioProcessor.Averager(owner.sampleRate, countTime, AveragerCB);
                averager.select(avgmode);
            }

            if (!_active)
            {
                return;
            }

            SignalBuffer dbout = getSignalOutputBuffer(ioO);

            if (dbout == null)
            {
                return;
            }

            if (triglist == null)
            {
                triglist = new double[owner.blockSize];
            }
            if (outlist == null)
            {
                outlist = new double[owner.blockSize];
            }

            Array.Clear(triglist, 0, owner.blockSize);
            for (int i = 0; i < owner.blockSize; i++)
            {
                outlist[i] = oval;
            }


            if (ioI.connectedTo != null)
            {
                averager.process(ioI.connectedTo.signalOutput.data, owner.blockSize);
            }
            else
            {
                averager.process(owner.blockSize);
            }

            Array.Copy(outlist, dbout.data, owner.blockSize);
            if (ioT.connectedTo != null)
            {
                Array.Copy(triglist, ioT.connectedTo.signalInput.data, owner.blockSize);
            }
        }
Example #9
0
 private void processChannel(int channel, SignalBuffer dbin)
 {
     if (dbin != null)
     {
         ow.inputs[channel].insert(dbin);
         ow.inputsActive[channel] = true;
     }
     else
     {
         ow.inputs[channel].insert(0, owner.blockSize);
         ow.inputsActive[channel] = false;
     }
 }
Example #10
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }
            SignalBuffer dbout = getSignalOutputBuffer(ioOut);

            if (dbout == null)
            {
                return;
            }

            SignalBuffer dbAM = getSignalInputBuffer(ioAM);
            double       amp0;

            if (inAmp)
            {
                amp0 = Math.Pow(10.0, genAmp / 20.0);
            }
            else
            {
                amp0 = Math.Pow(10.0, (genAmp + 4.8) / 20.0);
            }

            if (dbAM != null)
            {
                if (AMNoOfs)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = amp0 * dbAM.data[i] * func();
                    }
                }
                else
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = amp0 * (1 + dbAM.data[i]) * func();
                    }
                }
            }
            else
            {
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbout.data[i] = amp0 * func();
                }
            }
        }
Example #11
0
 private void processChannel(SignalBuffer dbA, SignalBuffer dbB, SignalBuffer dbOut)
 {
     if (dbOut == null)
     {
         return;
     }
     if ((dbA == null) || (dbB == null))
     {
         return;
     }
     for (int i = 0; i < owner.blockSize; i++)
     {
         dbOut.data[i] = dbA.data[i] * dbB.data[i];
     }
 }
Example #12
0
 private void processChannel(int i, SignalBuffer db)
 {
     if (db == null)
     {
         return;
     }
     if (state[i])
     {
         db.one();
     }
     else
     {
         db.zero();
     }
 }
Example #13
0
        public override void tick()
        {
            SignalBuffer dbA   = getSignalInputBuffer(ioI0);
            SignalBuffer dbB   = getSignalInputBuffer(ioI1);
            SignalBuffer dbSel = getSignalInputBuffer(ioSel);
            SignalBuffer dbOut = getSignalOutputBuffer(ioO);

            if (dbOut == null)
            {
                return;
            }

            if (dbSel == null)
            {   // No Selector connected
                if (dbA != null)
                {
                    dbOut.CopyFrom(dbA);
                }
                return;
            }
            if ((dbA == null) && (dbB == null))
            {   // No Inputs connected
                return;
            }

            if (dbA == null)
            {   // Input A not connected
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbOut.data[i] = (dbSel.data[i] > 0) ? dbB.data[i] : 0.0;
                }
                return;
            }
            if (dbB == null)
            {   // Input B not connected
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbOut.data[i] = (dbSel.data[i] > 0) ? 0.0 : dbA.data[i];
                }
                return;
            }

            for (int i = 0; i < owner.blockSize; i++)
            {
                dbOut.data[i] = (dbSel.data[i] > 0) ? dbB.data[i] : dbA.data[i];
            }
        }
        public RunningWaveletController(IRunningWaveletView view)
        {
            this._view = view;
            view.SetController(this);

            //Инициализация настроек для вейвлета
            WaveletSettingsInitialization();

            //создание генератора случ. значений
            _generator = new TestSequence();
            _generator.NoiseAmplitude = 2;
            _generator.SignalAmplitude = 10;
            _generator.SignalFrequency = 6;

            this._buffer = new SignalBuffer(WaveletApplication.WaveletTools.GetWaveletPhase(_waveletSettings.H0.Length,_view.DecompilationDepth),_view.DecompilationDepth);
            this._rwp = new RunningProcessor(_buffer, _waveletSettings);
        }
Example #15
0
        private void processChannel(int ch, SignalBuffer dbin, SignalBuffer dbout)
        {
            if (dbout == null)
            {
                return;
            }
            if (dbin == null)
            {
                return;
            }
            double a = Math.Pow(10, gain[ch] / 20);

            for (int i = 0; i < owner.blockSize; i++)
            {
                dbout.data[i] += a * dbin.data[i];
            }
        }
Example #16
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer dbout = getSignalOutputBuffer(ioO);

            if (inputs >= 1)
            {
                processChannel(0, getSignalInputBuffer(ioI1), dbout);
            }
            if (inputs >= 2)
            {
                processChannel(1, getSignalInputBuffer(ioI2), dbout);
            }
            if (inputs >= 3)
            {
                processChannel(2, getSignalInputBuffer(ioI3), dbout);
            }
            if (inputs >= 4)
            {
                processChannel(3, getSignalInputBuffer(ioI4), dbout);
            }
            if (inputs >= 5)
            {
                processChannel(4, getSignalInputBuffer(ioI5), dbout);
            }
            if (inputs >= 6)
            {
                processChannel(5, getSignalInputBuffer(ioI6), dbout);
            }
            if (inputs >= 7)
            {
                processChannel(6, getSignalInputBuffer(ioI7), dbout);
            }
            if (inputs >= 8)
            {
                processChannel(7, getSignalInputBuffer(ioI8), dbout);
            }
        }
Example #17
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }
            SignalBuffer dbin  = getSignalInputBuffer(ioI);
            SignalBuffer dbout = getSignalOutputBuffer(ioO);
            UInt32       pick  = (UInt32)Math.Floor(delay * owner.sampleRate + 0.5);

            if (pick > 10 * owner.sampleRate)
            {
                pick = (UInt32)(10 * owner.sampleRate);  // Hard limit to 10s !
            }
            if (dd == null)
            {
                dd = new DynamicDelay(pick + 100);
            }
            for (int i = 0; i < owner.blockSize; i++)
            {
                double rin = 0;
                if (dbin != null)
                {
                    rin = dbin.data[i];
                }
                double delayout = dd.Fetch(pick) * gain;
                if (dbout != null)
                {
                    dbout.data[i] = rin + delayout;
                }
                if (recursive)
                {
                    dd.Store(rin + delayout);
                }
                else
                {
                    dd.Store(rin);
                }
            }
        }
Example #18
0
        private void processChannel(int ch, SignalBuffer dbin, SignalBuffer dbout)
        {
            if ((dbin == null) && (dbout == null))
            {
                return;
            }
            if (dbin != null)
            {
                switch (filterOrder)
                {
                case FilterOrder.First:
                case FilterOrder.Second:
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        double x = dbin.data[i];
                        double y = stage1[ch].filter(x);
                        if (dbout != null)
                        {
                            dbout.data[i] = y;
                        }
                    }
                    break;

                case FilterOrder.Fourth:
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        double x = dbin.data[i];
                        double u = stage1[ch].filter(x);
                        double y = stage2[ch].filter(u);
                        if (dbout != null)
                        {
                            dbout.data[i] = y;
                        }
                    }
                    break;
                }
            }
        }
Example #19
0
        public override void tick()
        {
            SignalBuffer dbA = getSignalInputBuffer(ioA);

            if (inputs >= 1)
            {
                processChannel(dbA, getSignalInputBuffer(ioB1), getSignalOutputBuffer(ioOut1));
            }
            if (inputs >= 2)
            {
                processChannel(dbA, getSignalInputBuffer(ioB2), getSignalOutputBuffer(ioOut2));
            }
            if (inputs >= 3)
            {
                processChannel(dbA, getSignalInputBuffer(ioB3), getSignalOutputBuffer(ioOut3));
            }
            if (inputs >= 4)
            {
                processChannel(dbA, getSignalInputBuffer(ioB4), getSignalOutputBuffer(ioOut4));
            }
            if (inputs >= 5)
            {
                processChannel(dbA, getSignalInputBuffer(ioB5), getSignalOutputBuffer(ioOut5));
            }
            if (inputs >= 6)
            {
                processChannel(dbA, getSignalInputBuffer(ioB6), getSignalOutputBuffer(ioOut6));
            }
            if (inputs >= 7)
            {
                processChannel(dbA, getSignalInputBuffer(ioB7), getSignalOutputBuffer(ioOut7));
            }
            if (inputs >= 8)
            {
                processChannel(dbA, getSignalInputBuffer(ioB8), getSignalOutputBuffer(ioOut8));
            }
        }
 public void UpdateWaveletSettings()
 {
     this._buffer = new SignalBuffer(WaveletApplication.WaveletTools.GetWaveletPhase(_waveletSettings.H0.Length, _view.DecompilationDepth), _view.DecompilationDepth);
     this._rwp = new RunningProcessor(_buffer,_waveletSettings);
 }
        public override void tick()
        {
            if (!active)
            {
                return;
            }

            if (tcpClient != null)
            {
                if (tcpClient.Connected)
                {
                    online = true;
                    // Client is connected
                    int bytesav = tcpClient.Available;
                    while (bytesav > 0)
                    {
                        if (buffer == null)
                        {
                            buffer = new byte[32];
                        }
                        int N = 32;
                        if (bytesav < 32)
                        {
                            N = bytesav;
                        }
                        try
                        {
                            N = tcpClient.GetStream().Read(buffer, 0, N);
                        } catch (Exception e)
                        {
                            N = 0;
                            tcpClient.Close();
                            tcpClient = null;
                            online    = false;
                            bytesav   = 0;
                            owner.logText("AsyncNetListener: Client closed unexpectedly");
                            owner.showLogWin();
                        }
                        if (N > 0)
                        {
                            for (int i = 0; i < N; i++)
                            {
                                commandParser.add(buffer[i]);
                            }
                        }
                        bytesav -= N;
                    }
                }
                else
                {
                    online = false;
                    tcpClient.Close();
                    tcpClient = null;
                }
            }
            else if (tcpListener != null)
            {
                if (tcpListener.Pending())
                {
                    tcpClient = tcpListener.AcceptTcpClient();
                    if (!tcpClient.Connected)
                    {
                        tcpClient.Close();
                        tcpClient = null;
                        online    = false;
                    }
                    else
                    {
                        online = true;
                    }
                }
                else
                {
                    online = false;
                }
            }
            else
            {
                startListener();
                online = false;
            }

            SignalBuffer[] db = new SignalBuffer[channels];
            if (channels > 0)
            {
                db[0] = getSignalOutputBuffer(io1);
            }
            if (channels > 1)
            {
                db[1] = getSignalOutputBuffer(io2);
            }
            if (channels > 2)
            {
                db[2] = getSignalOutputBuffer(io3);
            }
            if (channels > 3)
            {
                db[3] = getSignalOutputBuffer(io4);
            }
            if (channels > 4)
            {
                db[4] = getSignalOutputBuffer(io5);
            }
            if (channels > 5)
            {
                db[5] = getSignalOutputBuffer(io6);
            }
            if (channels > 6)
            {
                db[6] = getSignalOutputBuffer(io7);
            }
            if (channels > 7)
            {
                db[7] = getSignalOutputBuffer(io8);
            }

            for (int i = 0; i < channels; i++)
            {
                if (db[i] != null)
                {
                    db[i].SetTo(channelValues[i]);
                }
            }

            SignalBuffer dbTrig = getSignalOutputBuffer(ioTrig);

            if (dbTrig != null)
            {
                if (newValue)
                {
                    dbTrig.data[0] = 1.0;
                }
            }
            newValue = false;
            if (online && !ledOn.LEDState)
            {
                ledOn.LEDState = true;
            }
            if (!online && ledOn.LEDState)
            {
                ledOn.LEDState = false;
            }
        }
Example #22
0
        public override void tick()
        {
            SignalBuffer dbFM        = getSignalInputBuffer(ioFM);
            SignalBuffer dbAM        = getSignalInputBuffer(ioAM);
            SignalBuffer dbPWM       = getSignalInputBuffer(ioPWM);
            SignalBuffer dbSync      = getSignalInputBuffer(ioSyncIn);
            SignalBuffer dbout       = getSignalOutputBuffer(io0);
            SignalBuffer dboutninety = getSignalOutputBuffer(io90);
            SignalBuffer dbtrig      = getSignalOutputBuffer(ioSyncOut);

            if (!_active)
            {
                return;
            }

            if ((dbout == null) && (dboutninety == null) && (dbtrig == null))
            {
                return;
            }

            double dphi0 = genF / owner.sampleRate;
            double amp   = Math.Pow(10.0, genAmp / 20.0);

            if (!inAmp)
            {
                amp *= MathUtils.AmplitudeFromRMS(genWaveForm);
            }

            for (int i = 0; i < owner.blockSize; i++)
            {
                if (dbSync != null)
                {
                    if ((dbSync.data[i] >= 0) && (lastSync < 0))
                    {
                        genPhi = 0;
                    }
                    lastSync = dbSync.data[i];
                }
                else
                {
                    lastSync = 0;
                }

                double zero   = 0.0;
                double ninety = 0.0;
                double g      = amp;
                if (dbAM != null)
                {
                    if (AMnoOfs)
                    {
                        g *= dbAM.data[i];
                    }
                    else
                    {
                        g *= dbAM.data[i] + 1.0;
                    }
                }
                double pw = genPWM;
                if (dbPWM != null)
                {
                    pw += dbPWM.data[i];
                }

                MathUtils.waveForm(genWaveForm, ref zero, ref ninety, genPhi, pw);

                if (dbout != null)
                {
                    dbout.data[i] = g * zero;
                }
                if (dboutninety != null)
                {
                    dboutninety.data[i] = g * ninety;
                }
                if (dbtrig != null)
                {
                    dbtrig.data[i] = MathUtils.trig(genPhi);
                }

                double dphi = dphi0;
                if (dbFM != null)
                {
                    if (FMlog)
                    {
                        dphi *= Math.Pow(2, dbFM.data[i]);
                    }
                    else
                    {
                        dphi *= (1 + dbFM.data[i]);
                    }
                }
                genPhi += dphi;
                if ((genPhi < 0) || (genPhi >= 1))
                {
                    genPhi -= Math.Floor(genPhi);
                }
            }
        }
Example #23
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer dbin   = getSignalInputBuffer(ioI);
            SignalBuffer dbTrig = getSignalInputBuffer(ioTrig);
            DataBuffer   dbout  = getDataOutputBuffer(ioData);

            if (dbin == null)
            {
                return;
            }

            if ((buffIn == null) || (buffIn.Length != blockSize))
            {
                buffIn     = new double[blockSize];
                re         = new double[blockSize / 2];
                im         = new double[blockSize / 2];
                buffInFill = 0;
                fft        = null;
            }
            if ((fft != null) && (fft.windowType != fftWindow))
            {
                fft = new FFTProcessor(FFTProcessor.ProcessorMode.Bidirectional, blockSize, owner.sampleRate, fftWindow);
            }

            if (dbTrig != null)
            { // Triggered mode
                int trigger = -1;
                for (int i = 0; i < owner.blockSize; i++)
                {
                    if ((dbTrig.data[i] > 0) && (lastTrig <= 0))
                    {
                        trigger = i;
                    }
                    lastTrig = dbTrig.data[i];
                }
                if (trigger >= 0)
                {
                    // Triggered somewhere in this block
                    buffInFill = 0;
                }
            }
            if (buffInFill + owner.blockSize <= blockSize)
            {
                Array.Copy(dbin.data, 0, buffIn, buffInFill, owner.blockSize);
                buffInFill += owner.blockSize;
            }
            else
            {
                // Going to fill it
                int rem = blockSize - buffInFill;
                Array.Copy(dbin.data, 0, buffIn, buffInFill, rem);
                buffInFill += rem;
                processBlock(dbout);
                buffInFill = 0;
                Array.Copy(dbin.data, rem, buffIn, 0, owner.blockSize - rem);
                buffInFill += owner.blockSize - rem;
            }
        }
Example #24
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer sin = getSignalInputBuffer(ioS);

            if (sin == null)
            {
                return;
            }
            int xsteps = xyDisplay.xSteps;
            int smps   = (int)Math.Floor(owner.sampleRate * timescale + 0.5);

            if ((xdata == null) || (xdata.Length != xsteps))
            {
                xdata = new double[xsteps];
                for (int i = 0; i < xsteps; i++)
                {
                    xdata[i] = -1.0 + 2.0 * i / xsteps;
                }
                ydata       = new double[xsteps];
                lastn       = -1;
                xsample     = 0;
                waitfortrig = 0;
                ylast       = 0;
            }
            for (int i = 0; i < owner.blockSize; i++)
            {
                if (waitfortrig >= 0)
                {
                    waitfortrig++;
                }
                double y = sin.data[i] / yscale;
                acy = acy * 0.99 + y * 0.01;
                if (AC)
                {
                    y -= acy;
                }
                if ((y > 0) && (ylast <= 0))
                {
                    waitfortrig = -1; // Triggered
                }
                ylast = y;
                if (waitfortrig > 5 * smps)
                {
                    waitfortrig = -1; // Auto Trigger
                }
                if (waitfortrig < 0)
                {
                    int n = xsample * xsteps / smps;
                    if ((lastn >= 0) && (lastn < n - 1))
                    { // Interpolate in x-direction
                        for (int j = lastn + 1; j <= n; j++)
                        {
                            double q = (double)(j - lastn) / (n - lastn);
                            if (j < xsteps)
                            {
                                ydata[j] = ydata[lastn] * (1.0 - q) + y * q;
                            }
                        }
                    }
                    else
                    {
                        if (n < xsteps)
                        {
                            ydata[n] = y;
                        }
                    }
                    lastn = n;
                    xsample++;
                    if (n >= xsteps)
                    {
                        xyDisplay.addData(xdata, ydata);
                        Array.Clear(ydata, 0, xdata.Length);
                        xsample     = 0;
                        lastn       = -1;
                        waitfortrig = 0;
                    }
                }
            }
        }
Example #25
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer IN  = getSignalInputBuffer(ioIn);
            SignalBuffer SIN = getSignalInputBuffer(ioRef0);
            SignalBuffer COS = getSignalInputBuffer(ioRef90);

            SignalBuffer OUTI = getSignalOutputBuffer(ioOI);
            SignalBuffer OUTQ = getSignalOutputBuffer(ioOQ);
            SignalBuffer OUTA = getSignalOutputBuffer(ioA);

            if ((IN == null) || (SIN == null) || (COS == null))
            {
                return;
            }
            if ((OUTI == null) && (OUTQ == null) && (OUTA == null))
            {
                return;
            }

            if (stage1a == null)
            {
                stage1a      = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.LowPass, fc, Math.Sqrt(Math.Sqrt(2)));
                stage2a      = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.LowPass, fc, Math.Sqrt(Math.Sqrt(2)));
                stage1b      = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.LowPass, fc, Math.Sqrt(Math.Sqrt(2)));
                stage2b      = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.LowPass, fc, Math.Sqrt(Math.Sqrt(2)));
                updateNeeded = false;
            }
            if (updateNeeded)
            {
                stage1a.frequency = fc;
                stage1b.frequency = fc;
                stage2a.frequency = fc;
                stage2b.frequency = fc;
                updateNeeded      = false;
            }

            for (int i = 0; i < owner.blockSize; i++)
            {
                sval = SIN.data[i] * IN.data[i];
                cval = COS.data[i] * IN.data[i];

                double sout = stage2a.filter(stage1a.filter(sval));
                double cout = stage2b.filter(stage1b.filter(cval));

                if (OUTI != null)
                {
                    OUTI.data[i] = sout;
                }
                if (OUTQ != null)
                {
                    OUTQ.data[i] = cout;
                }
                if (OUTA != null)
                {
                    OUTA.data[i] = Math.Sqrt(sout * sout + cout * cout);
                }
            }
        }
Example #26
0
        public override void tick()
        {
            SignalBuffer dbA   = getSignalInputBuffer(ioA);
            SignalBuffer dbB   = getSignalInputBuffer(ioB);
            SignalBuffer dbout = getSignalOutputBuffer(ioOut);

            if (dbout == null)
            {
                return;
            }

            if ((dbA == null) && (dbB == null))
            {
                if ((mode == CompareMode.A_larger_equal_B) || (mode == CompareMode.A_smaller_equal_B))
                {
                    dbout.one();
                }
                else
                {
                    dbout.zero();
                }
                return;
            }

            switch (mode)
            {
            case CompareMode.A_larger_B:
                if (dbA == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (0 > dbB.data[i]) ? 1 : -1;
                    }
                    return;
                }
                if (dbB == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (dbA.data[i] > 0) ? 1 : -1;
                    }
                    return;
                }
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbout.data[i] = (dbA.data[i] > dbB.data[i]) ? 1 : -1;
                }
                return;

            case CompareMode.A_larger_equal_B:
                if (dbA == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (0 >= dbB.data[i]) ? 1 : -1;
                    }
                    return;
                }
                if (dbB == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (dbA.data[i] >= 0) ? 1 : -1;
                    }
                    return;
                }
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbout.data[i] = (dbA.data[i] >= dbB.data[i]) ? 1 : -1;
                }
                return;

            case CompareMode.A_smaller_B:
                if (dbA == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (0 < dbB.data[i]) ? 1 : -1;
                    }
                    return;
                }
                if (dbB == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (dbA.data[i] < 0) ? 1 : -1;
                    }
                    return;
                }
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbout.data[i] = (dbA.data[i] < dbB.data[i]) ? 1 : -1;
                }
                return;

            case CompareMode.A_smaller_equal_B:
                if (dbA == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (0 <= dbB.data[i]) ? 1 : -1;
                    }
                    return;
                }
                if (dbB == null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        dbout.data[i] = (dbA.data[i] <= 0) ? 1 : -1;
                    }
                    return;
                }
                for (int i = 0; i < owner.blockSize; i++)
                {
                    dbout.data[i] = (dbA.data[i] <= dbB.data[i]) ? 1 : -1;
                }
                return;
            }
        }
Example #27
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer[] sin  = new SignalBuffer[inputs];
            SignalBuffer[] sout = new SignalBuffer[inputs];

            if (inputs >= 1)
            {
                sin[0] = getSignalInputBuffer(ioI1); sout[0] = getSignalOutputBuffer(ioO1);
            }
            if (inputs >= 2)
            {
                sin[1] = getSignalInputBuffer(ioI2); sout[1] = getSignalOutputBuffer(ioO2);
            }
            if (inputs >= 3)
            {
                sin[2] = getSignalInputBuffer(ioI3); sout[2] = getSignalOutputBuffer(ioO3);
            }
            if (inputs >= 4)
            {
                sin[3] = getSignalInputBuffer(ioI4); sout[3] = getSignalOutputBuffer(ioO4);
            }
            if (inputs >= 5)
            {
                sin[4] = getSignalInputBuffer(ioI5); sout[4] = getSignalOutputBuffer(ioO5);
            }
            if (inputs >= 6)
            {
                sin[5] = getSignalInputBuffer(ioI6); sout[5] = getSignalOutputBuffer(ioO6);
            }
            if (inputs >= 7)
            {
                sin[6] = getSignalInputBuffer(ioI7); sout[6] = getSignalOutputBuffer(ioO7);
            }
            if (inputs >= 8)
            {
                sin[7] = getSignalInputBuffer(ioI8); sout[7] = getSignalOutputBuffer(ioO8);
            }

            const double a = 0.7;

            // const double b = 0.7;

            if (filter50 == null)
            {
                filter50 = new BiQuad[inputs];
                for (int i = 0; i < inputs; i++)
                {
                    filter50[i] = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.BandPass, 50, a);
                }
            }
            if (filter150 == null)
            {
                filter150 = new BiQuad[inputs];
                for (int i = 0; i < inputs; i++)
                {
                    filter150[i] = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.BandPass, 150, a);
                }
            }
            if (filter500 == null)
            {
                filter500 = new BiQuad[inputs];
                for (int i = 0; i < inputs; i++)
                {
                    filter500[i] = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.BandPass, 500, a);
                }
            }
            if (filter1k5 == null)
            {
                filter1k5 = new BiQuad[inputs];
                for (int i = 0; i < inputs; i++)
                {
                    filter1k5[i] = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.BandPass, 1500, a);
                }
            }
            if (filter5k == null)
            {
                filter5k = new BiQuad[inputs];
                for (int i = 0; i < inputs; i++)
                {
                    filter5k[i] = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.BandPass, 5000, a);
                }
            }
            if (filter15k == null)
            {
                filter15k = new BiQuad[inputs];
                for (int i = 0; i < inputs; i++)
                {
                    filter15k[i] = new BiQuad(owner.sampleRate, BiQuad.BiQuadOrder.Second, BiQuad.BiQuadMode.BandPass, 15000, a);
                }
            }


            for (int i = 0; i < inputs; i++)
            {
                if (sin[i] != null)
                {
                    for (int j = 0; j < owner.blockSize; j++)
                    {
                        double din  = sin[i].data[j];
                        double a50  = filter50[i].filter(din);
                        double a150 = filter150[i].filter(din);
                        double a500 = filter500[i].filter(din);
                        double a1k5 = filter1k5[i].filter(din);
                        double a5k  = filter5k[i].filter(din);
                        double a15k = filter15k[i].filter(din);
                        if (sout[i] != null)
                        {
                            sout[i].data[j] = din + a50 * g50d + a150 * g150d + a500 * g500d + a1k5 * g1k5d + a5k * g5kd + a15k * g15kd;
                        }
                    }
                }
            }
        }
Example #28
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }
            SignalBuffer dbsync  = getSignalInputBuffer(ioSync);
            SignalBuffer dbpitch = getSignalOutputBuffer(ioPitch);
            SignalBuffer dbamp   = getSignalOutputBuffer(ioAmp);
            SignalBuffer dbgate  = getSignalOutputBuffer(ioGate);

            if ((dbpitch == null) && (dbgate == null))
            {
                return;
            }
            int c = 0;

            double a = Math.Pow(10, gain / 20);

            for (int i = 0; i < owner.blockSize; i++)
            {
                if (dbsync != null)
                {
                    if ((dbsync.data[i] > 0) && (lastSync <= 0))
                    {
                        t = 0;
                    }
                    lastSync = dbsync.data[i];
                }
                else
                {
                    lastSync = 0;
                }
                c = (int)Math.Floor(t * (bpm / 60));
                c = c % cols;
                int found = -1;
                for (int j = 0; j < rows; j++)
                {
                    if ((data[j, c] > 0) && (found < 0))
                    {
                        found = j;
                    }
                }
                if ((found >= 0) && (playing >= 0) && (found != playing))
                {
                    if (dbgate != null)
                    {
                        dbgate.data[i] = 0;
                    }
                    if (dbamp != null)
                    {
                        dbamp.data[i] = 0;
                    }
                    playing = -1;
                }
                else if (found >= 0)
                {
                    if (dbgate != null)
                    {
                        dbgate.data[i] = 1;
                    }
                    if (dbamp != null)
                    {
                        dbamp.data[i] = data[found, c] * a;
                    }
                    if (dbpitch != null)
                    {
                        dbpitch.data[i] = (double)found / 12 + octave;
                    }
                    playing = found;
                }
                else if (playing >= 0)
                {
                    playing = -1;
                    if (dbgate != null)
                    {
                        dbgate.data[i] = 0;
                    }
                    if (dbamp != null)
                    {
                        dbamp.data[i] = 0;
                    }
                }
                t += 1.0 / owner.sampleRate;
                if (t >= (double)cols / (bpm / 60))
                {
                    t -= (double)cols / (bpm / 60);
                }
            }

            sfMain.hlCol = c;
        }
Example #29
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer dbin  = getSignalInputBuffer(ioI);
            DataBuffer   dbout = getDataOutputBuffer(ioData);

            if (dbin == null)
            {
                return;
            }

            if (oval == null)
            {
                oval = new double[7];
            }

            if ((buffIn == null) || (buffIn.Length != blockSize))
            {
                buffIn     = new double[blockSize];
                re         = new double[blockSize / 2];
                im         = new double[blockSize / 2];
                buffInFill = 0;
                fft        = null;
                addto      = null;
            }
            if ((fft != null) && (fft.windowType != fftWindow))
            {
                fft = new FFTProcessor(FFTProcessor.ProcessorMode.Bidirectional, blockSize, owner.sampleRate, fftWindow);
            }


            Array.Copy(dbin.data, 0, buffIn, buffInFill, owner.blockSize);
            buffInFill += owner.blockSize;

            if (buffInFill == blockSize)
            {
                if (fft == null)
                {
                    fft = new FFTProcessor(FFTProcessor.ProcessorMode.Bidirectional, blockSize, owner.sampleRate, fftWindow);
                }
                if ((addto == null) || (fA != fA0) || (fMax != fMax0))
                {
                    fA0   = fA;
                    fMax0 = fMax;
                    double fC = fA * Math.Pow(2, -9.0 / 12.0);
                    addto      = new int[blockSize / 2];
                    addtoCoeff = new double[blockSize / 2];
                    for (int i = 0; i < blockSize / 2; i++)
                    {
                        double f      = fft.freq[i];
                        double weight = bandPass(f, fC, fMax);
                        if (weight < 0.1)
                        {
                            addto[i] = -1;
                        }
                        else
                        {
                            int fn = (int)Math.Floor(Math.Log(f / fC, 2.0) * 12 + 0.5);
                            addto[i]      = fn % 12;
                            addtoCoeff[i] = weight;
                        }
                    }
                }

                // n = (int)Math.Floor((double)blockSize * fA / (owner.sampleRate));
                fft.windowType = fftWindow;

                fft.runFFT(ref buffIn, true, ref re, ref im);
                Array.Copy(buffIn, blockSize / 2, buffIn, 0, buffInFill - blockSize / 2);
                buffInFill -= blockSize / 2;

                // Process FFT Data
                //double[] on = new double[12];
                for (int i = 0; i < 12; i++)
                {
                    on[i] = 0;
                }
                double[] n = new double[12];
                for (int i = 0; i < addto.Length; i++)
                {
                    if (addto[i] >= 0)
                    {
                        on[addto[i]] += addtoCoeff[i] * (re[i] * re[i] + im[i] * im[i]);
                        n[addto[i]]  += addtoCoeff[i];
                    }
                }
                double emax = 0;
                double emin = 0;
                for (int i = 0; i < 12; i++)
                {
                    on[i] = Math.Sqrt(on[i] / n[i]);
                    if (i == 0)
                    {
                        emin = emax = on[i];
                    }
                    else
                    {
                        if (on[i] < emin)
                        {
                            emin = on[i];
                        }
                        if (on[i] > emax)
                        {
                            emax = on[i];
                        }
                    }
                }
                if (normalize)
                {
                    if (emax == emin)
                    {
                        emax = emin + 1;
                    }
                    for (int i = 0; i < 12; i++)
                    {
                        on[i] = (on[i] - emin) / (emax - emin);
                    }
                }
                else
                {
                    double[] onLog = new double[12];
                    for (int i = 0; i < 12; i++)
                    {
                        if (on[i] < 1e-5)
                        {
                            onLog[i] = -100;
                        }
                        else if (on[i] > 1e1)
                        {
                            onLog[i] = 20;
                        }
                        else
                        {
                            onLog[i] = 20 * Math.Log10(on[i]);
                        }
                        onLog[i] = (onLog[i] - (-100)) / (20 - (-100));
                    }
                }
                if (dbout != null)
                {
                    dbout.initialize(12);
                    dbout.set(on);
                }
            }
        }
Example #30
0
        public override void tick()
        {
            if ((wave == null) || !wave.valid || !_active)
            {
                return;
            }

            SignalBuffer dbgate  = null;
            SignalBuffer dbspeed = null;

            if (ioGate.connectedTo != null)
            {
                dbgate = ioGate.connectedTo.signalOutput;
            }
            if (ioSpeed.connectedTo != null)
            {
                dbspeed = ioSpeed.connectedTo.signalOutput;
            }
            int chs = min(channels, wave.channels);

            SignalBuffer[] outputs = new SignalBuffer[chs];
            if ((chs > 0) && (io1.connectedTo != null))
            {
                outputs[0] = io1.connectedTo.signalInput;
            }
            if ((chs > 1) && (io2.connectedTo != null))
            {
                outputs[1] = io2.connectedTo.signalInput;
            }
            if ((chs > 2) && (io3.connectedTo != null))
            {
                outputs[2] = io3.connectedTo.signalInput;
            }
            if ((chs > 3) && (io4.connectedTo != null))
            {
                outputs[3] = io4.connectedTo.signalInput;
            }
            if ((chs > 4) && (io5.connectedTo != null))
            {
                outputs[4] = io5.connectedTo.signalInput;
            }
            if ((chs > 5) && (io6.connectedTo != null))
            {
                outputs[5] = io6.connectedTo.signalInput;
            }
            if ((chs > 6) && (io7.connectedTo != null))
            {
                outputs[6] = io7.connectedTo.signalInput;
            }
            if ((chs > 7) && (io8.connectedTo != null))
            {
                outputs[7] = io8.connectedTo.signalInput;
            }
            double gain = Math.Pow(10, amp / 20);

            for (int i = 0; i < owner.blockSize; i++)
            {
                if ((dbgate != null) && !running && (dbgate.data[i] > 0.5))
                {
                    position = 0;
                    running  = true;
                }
                if ((dbgate != null) && running && (dbgate.data[i] < 0.0))
                {
                    running = false;
                }
                if (running)
                {
                    UInt64 idx = (UInt64)Math.Floor(position + 0.5);
                    if ((idx >= 0) && (idx < wave.samples))
                    {
                        for (int j = 0; j < chs; j++)
                        {
                            if (outputs[j] != null)
                            {
                                outputs[j].data[i] = gain * wave.wave[j][idx];
                            }
                        }
                    }
                    double phi = speed / 100.0 * owner.sampleRate / wave.samplerate;
                    if (dbspeed != null)
                    {
                        phi *= dbspeed.data[i];
                    }
                    position += phi;
                    if (position < 0)
                    {
                        if (loop)
                        {
                            position += wave.samples;
                        }
                        else
                        {
                            running = false;
                        }
                    }
                    if (position >= wave.samples)
                    {
                        if (loop)
                        {
                            position -= wave.samples;
                        }
                        else
                        {
                            running = false;
                        }
                    }
                }
            }
            if (running && ledPlay.LEDState == false)
            {
                ledPlay.LEDState = true;
            }
            if (!running && ledPlay.LEDState == true)
            {
                ledPlay.LEDState = false;
            }
        }
Example #31
0
        public override void tick()
        {
            if (stopnow)
            {
                vnaState = VNAState.Idle;
                running  = false;
                return;
            }
            if (ow == null)
            {
                return;
            }
            if (!ow.initialized)
            {
                return;
            }

            if (vnaState == VNAState.Idle)
            {
                return;
            }

            SignalBuffer RF = getSignalOutputBuffer(ioRF);
            SignalBuffer A  = getSignalInputBuffer(ioA);

            // DataBuffer B = null;
            SignalBuffer[] B = new SignalBuffer[channels];
            if (channels > 0)
            {
                B[0] = getSignalInputBuffer(ioB1);
            }
            if (channels > 1)
            {
                B[1] = getSignalInputBuffer(ioB2);
            }
            if (channels > 2)
            {
                B[2] = getSignalInputBuffer(ioB3);
            }
            if (channels > 3)
            {
                B[3] = getSignalInputBuffer(ioB4);
            }
            if (channels > 4)
            {
                B[4] = getSignalInputBuffer(ioB5);
            }
            if (channels > 5)
            {
                B[5] = getSignalInputBuffer(ioB6);
            }
            if (channels > 6)
            {
                B[6] = getSignalInputBuffer(ioB7);
            }
            if (channels > 7)
            {
                B[7] = getSignalInputBuffer(ioB8);
            }

            double phisave = phi;
            double dphi    = 2.0 * Math.PI * f / owner.sampleRate;

            phi = phisave;
            int stepsave = substep;

            // Input Processing
            switch (vnaState)
            {
            case VNAState.WaitDelay:
                substep += owner.blockSize;
                if (substep > delaySamples)
                {
                    ASINint = ACOSint = 0;
                    for (int j = 0; j < channels; j++)
                    {
                        BSINint[j] = BCOSint[j] = 0;
                    }
                    vnaState = VNAState.Measuring;
                    substep  = 0;
                    intCount = (int)Math.Floor((double)periods * (double)owner.sampleRate / f + 0.5);
                }
                break;

            case VNAState.Measuring:
                phi     = phisave;
                substep = stepsave;
                if (A != null)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        if (substep < intCount)
                        {
                            double win = windowFunc(substep, intCount);
                            ASINint += A.data[i] * Math.Sin(phi) * win;
                            ACOSint += A.data[i] * Math.Cos(phi) * win;
                        }
                        substep++;
                        phi += dphi;
                    }
                }
                for (int j = 0; j < channels; j++)
                {
                    phi     = phisave;
                    substep = stepsave;
                    if (B[j] != null)
                    {
                        for (int i = 0; i < owner.blockSize; i++)
                        {
                            if (substep < intCount)
                            {
                                double win = windowFunc(substep, intCount);
                                BSINint[j] += B[j].data[i] * Math.Sin(phi) * win;
                                BCOSint[j] += B[j].data[i] * Math.Cos(phi) * win;
                            }
                            substep++;
                            phi += dphi;
                        }
                    }
                }

                substep = stepsave + owner.blockSize;
                if (substep >= intCount)
                {
                    // Process
                    DataPoint dp = new DataPoint(channels);

                    dp.f = f;
                    double scalef = 2.0 / ((double)intCount);
                    dp.A = new Complex(ASINint * scalef, ACOSint * scalef);
                    for (int j = 0; j < channels; j++)
                    {
                        dp.B[j] = new Complex(BSINint[j] * scalef, BCOSint[j] * scalef);
                    }
                    // Phase Correction
                    if (config.compPhaseBlocks != 0)
                    {
                        double  delay = (double)config.compPhaseBlocks * owner.blockSize / owner.sampleRate;    // in s
                        double  phase = -2.0 * Math.PI * delay * f;
                        Complex corr  = new Complex(Math.Cos(phase), Math.Sin(phase));
                        dp.A *= corr;
                    }
                    dataFifo.put(dp);

                    substep = 0;
                    step++;
                    if (step < steps)
                    {
                        // Continue
                        if (logsweep)
                        {
                            f = fstart * Math.Pow(fstop / fstart, (double)step / (steps - 1));
                        }
                        else
                        {
                            f = fstart + (double)step / (steps - 1) * (fstop - fstart);
                        }
                        vnaState = VNAState.WaitDelay;
                    }
                    else
                    {
                        // FInish
                        vnaState = VNAState.Idle;
                        running  = false;
                    }
                }
                break;
            }

            // Generator
            phi = phisave;
            if (RF != null)
            {
                if (vnaState != VNAState.Idle)
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        RF.data[i] = Math.Sin(phi);
                        phi       += dphi;
                        if (phi > 2.0 * Math.PI)
                        {
                            phi -= 2 * Math.PI;
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < owner.blockSize; i++)
                    {
                        RF.data[i] = 0;
                        phi       += dphi;
                        if (phi > 2.0 * Math.PI)
                        {
                            phi -= 2 * Math.PI;
                        }
                    }
                }
            }
        }
Example #32
0
        public override void tick()
        {
            if (!_active)
            {
                return;
            }

            SignalBuffer dbin = getSignalInputBuffer(ioI);

            SignalBuffer[] dbout = new SignalBuffer[7];
            dbout[0] = getSignalOutputBuffer(ioM3);
            dbout[1] = getSignalOutputBuffer(ioM2);
            dbout[2] = getSignalOutputBuffer(ioM1);
            dbout[3] = getSignalOutputBuffer(io0);
            dbout[4] = getSignalOutputBuffer(ioP1);
            dbout[5] = getSignalOutputBuffer(ioP2);
            dbout[6] = getSignalOutputBuffer(ioP3);

            if (dbin == null)
            {
                return;
            }

            if (oval == null)
            {
                oval = new double[7];
            }

            if (buffIn == null)
            {
                buffIn     = new double[blockSize];
                re         = new double[blockSize / 2];
                im         = new double[blockSize / 2];
                buffInFill = 0;
            }

            Array.Copy(dbin.data, 0, buffIn, buffInFill, owner.blockSize);
            buffInFill += owner.blockSize;

            if (buffInFill == blockSize)
            {
                if (fft == null)
                {
                    fft = new FFTProcessor(FFTProcessor.ProcessorMode.Bidirectional, blockSize, owner.sampleRate, fftWindow);
                }
                n = (int)Math.Floor((double)blockSize * f / (owner.sampleRate));
                fft.windowType = fftWindow;

                fft.runFFT(ref buffIn, true, ref re, ref im);
                Array.Copy(buffIn, blockSize / 2, buffIn, 0, buffInFill - blockSize / 2);
                buffInFill -= blockSize / 2;

                // Process FFT
                for (int i = -3; i <= 3; i++)
                {
                    int m = n + i;
                    oval[i + 3] = 0;
                    if ((m >= 0) && (m < blockSize / 2))
                    {
                        oval[i + 3] = Math.Sqrt(re[m] * re[m] + im[m] * im[m]);
                    }
                }
            }

            for (int i = -3; i <= 3; i++)
            {
                if (dbout[i + 3] != null)
                {
                    dbout[i + 3].SetTo(oval[i + 3]);
                }
            }
        }