Наблюдаем спектр сигнала при помощи D/QtE5 и Arduino

alias WindowType = QtE.WindowType;
alias normalWindow = WindowType.Window;

class MainForm : QWidget
{
	private
	{
		QHBoxLayout horizontalBox0, horizontalBox1, horizontalBox2;
		QVBoxLayout mainSizer, verticalBox0, verticalBox1, verticalBox2, verticalBox3,
					verticalBox4, verticalBox5, verticalBox7;
		QGroupBox group0, group1, group2, group3, group4, group5, group6, group7;
		QComboBox combo0, combo1;
		QSlider slider0;
		QLabel label0;
		QPushButton startButton, stopButton, overlayButton;
		QSignalBox area0;
		QSonogramBox area1;
		QStatusBar status0;
		QAction action0, action1, action2, action3;
		QTimer timer0;
	}

	private
	{
		USBDevice device;

		float[] data;
		WindowFunction windowFunction;
		uint windowSize;
	}

	this(QWidget parent, WindowType windowType)
	{
		super(parent, windowType);
		showMaximized;
		setWindowTitle("Digital Receiver Experiment");

		timer0 = new QTimer(this);
		timer0.setInterval(1);

		action0 = new QAction(this, &onTimerTick, aThis);
		connects(timer0, "timeout()", action0, "Slot()");

		mainSizer = new QVBoxLayout(null);

		horizontalBox0 = new QHBoxLayout(null);

		verticalBox0 = new QVBoxLayout(null);
		area0 = new QSignalBox(this);
		area0.saveThis(&area0);
		area0.setFixedHeight(80);
		area0.saveThis(&area0);

		verticalBox0.addWidget(area0);

		group0 = new QGroupBox(null);
		group0.setText("Signal data:");
		group0.setLayout(verticalBox0);
		group0.setFixedHeight(150);

		verticalBox1 = new QVBoxLayout(null);
		area1 = new QSonogramBox(this);
		area1.saveThis(&area1);

		verticalBox1.addWidget(area1);

		group1 = new QGroupBox(null);
		group1.setText("Sonogram:");
		group1.setLayout(verticalBox1);

		verticalBox3 = new QVBoxLayout(null);
		verticalBox3
			   .addWidget(group0)
			   .addWidget(group1);

		verticalBox4 = new QVBoxLayout(null);

		verticalBox5 = new QVBoxLayout(null);

		combo0 = new QComboBox(null);

		SerialPort
				 .listAvailable
				 .filter!(a => a.startsWith("/dev/ttyUSB"))
				 .enumerate(0)
				 .each!(a => combo0.addItem(a[1], a[0]));

		verticalBox5.addWidget(combo0);

		group3 = new QGroupBox(null);
		group3.setLayout(verticalBox5);
		group3.setText("COM port");
		group3.setMaximumHeight(70);

		horizontalBox2 = new QHBoxLayout(null);

		slider0 = new QSlider(null);
		slider0.setMinimum(2);
		slider0.setMaximum(9);
		slider0.setSingleStep(2);
		slider0.setSliderPosition(8);

		label0 = new QLabel(null);
		windowSize = 2 ^^ (slider0.value);
		label0.setText("
%d
".format(windowSize));

		horizontalBox2
				.addWidget(slider0)
				.addWidget(label0);

		group4 = new QGroupBox(null);
		group4.setLayout(horizontalBox2);
		group4.setText("Window size");
		group4.setMaximumHeight(70);


		horizontalBox1 = new QHBoxLayout(null);

		startButton = new QPushButton("Start", this);
		stopButton = new QPushButton("Stop", this);
		stopButton.setEnabled(false);

		horizontalBox1
					 .addWidget(startButton)
					 .addWidget(stopButton);

		action1 = new QAction(null, &onStartButton, aThis);
		action2 = new QAction(null, &onStopButton, aThis);
		action3 = new QAction(null, &onValueChanged, aThis);

  	        connects(startButton, "clicked()", action1, "Slot()");
		connects(stopButton, "clicked()", action2, "Slot()");
		connects(startButton, "clicked()", timer0, "start()");
		connects(stopButton, "clicked()", timer0, "stop()");
		connects(slider0, "sliderReleased()", action3, "Slot()");

		combo1 = new QComboBox(null);
		[
			"Rectangular",
			"Blackman",
			"Blackman(e)",
			"Blackman-Harris",
			"Blackman-Nutall",
			"Flat top",
			"Hamming",
			"Nutall",
			"Sine",
			"Hann"
		]
				 .enumerate(0)
				 .each!(a => combo1.addItem(a[1], a[0]));

		verticalBox7 = new QVBoxLayout(null);
		verticalBox7.addWidget(combo1);

		group7 = new QGroupBox(null);
		group7.setLayout(verticalBox7);
		group7.setText("Window function");
		group7.setMaximumHeight(70);


		verticalBox4
					.addWidget(group3)
					.addWidget(group7)
					.addWidget(group4)
					.addWidget(new QWidget(null))
					.addLayout(horizontalBox1);

		group6 = new QGroupBox(null);
		group6.setLayout(verticalBox4);
		group6.setText("Parameters");
		group6.setMaximumWidth(250);

		horizontalBox0
			.addLayout(verticalBox3)
			.addWidget(group6);

		status0 = new QStatusBar(null);
		status0.setMaximumHeight(15);
		status0.showMessage("Ready");

		mainSizer
				.addLayout(horizontalBox0)
				.addWidget(status0);

		setLayout(mainSizer);
	}
}

extern (C)
{
    void onStartButton(MainForm* mainFormPointer)
    {
        (*mainFormPointer).runStart;
    }

    void onStopButton(MainForm* mainFormPointer)
    {
        (*mainFormPointer).runStop;
    }

    void onTimerTick(MainForm* mainFormPointer)
    {
        (*mainFormPointer).runTimer;
    }

    void onValueChanged(MainForm* mainFormPointer)
    {
        (*mainFormPointer).runChange;
    }
}

module receiver.usb;

private
{
    import std.conv;
    import std.stdio;
    import std.string;

    import serialport;
}

class USBDevice
{
    private SerialPortBlk device;
    enum PORT_SPEED = 230_400;

    this(string name)
    {
        device = new SerialPortBlk(name, PORT_SPEED);
        device.config = SPConfig(PORT_SPEED, DataBits.data8, Parity.none, StopBits.one);
    }

    float read()
    {
        float result = 0.0f;

        try
        {
            ubyte[2] buffer;
            device.read(buffer);

            auto tmp = buffer[0] * 255 + buffer[1];

                if (tmp <=  1023)
                {
                    result = ((buffer[0] * 255 + buffer[1]) * 5.0f) / 1024.0f;
                }
                else
                {
                    result = -1.0f;
                }
        }
        catch (Throwable)
        {

        }

        return result;
    }

    void close()
    {
        device.close;
    }
}

void setup()
{
    Serial.begin(230400);
}

void loop() {
    float value = analogRead(A0);

    byte low =  ((int) value) / 255;
    byte high = ((int) value) % 255;

    Serial.write(low);
    Serial.write(high);
}

module receiver.qsignalbox;

private
{
    import qte5;

    import receiver.observer;

    extern (C)
    {
        void onPaintSignal(QSignalBox* signalBox, void* eventPointer, void* painterPointer)
        {
            (*signalBox).runPaint(eventPointer, painterPointer);
        }
    }

    void drawSignal(QPainter painter, ref float[] data, int w, int h)
    {
        float scaleY = h / 5.0f;

        foreach (x, y; data)
        {
            float X = x * (w / cast(float) data.length);
            float Y = h - (y * scaleY);

            painter.drawLine(cast(int) X, h, cast(int) X, cast(int) Y);
        }
    }
}

class QSignalBox : QWidget
{
    private
    {
        float[] data;
        bool isDrawing;
    }

    this(QWidget parent)
    {
        super(this);
        setStyleSheet("background: Black");
        setPaintEvent(&onPaintSignal, aThis());
    }

    void setData(ref float[] data)
    {
        this.data = data;
        this.isDrawing = true;
    }

    void runPaint(void* eventPointer, void* painterPointer)
    {
        QPainter painter = new QPainter('+', painterPointer);

        QColor color = new QColor(this);
        color.setRgb(
            cast(int) (255 * 0.1f),
            cast(int) (255 * 0.1f),
            cast(int) (255 * 0.8f),
            70
        );

        QPen pen = new QPen;
        pen.setColor(color);

        auto w = this.width;
        auto h = this.height;

        pen.setWidth(1);

        painter.setPen(pen);

        if (isDrawing)
        {
            isDrawing = false;

            drawSignal(painter, data, w, h);
            data = [];
        }

        painter.end;
    }
}

module receiver.structures;

private
{
    import std.range;
}

// стек для хранения данных
class Stack(T)
{
    private:
        T[] elements;

    public:

        // добавление элемента в конец
        void push(T element)
        {
            elements ~= element;
        }

        // добавление ряда элементов
        void push(T[] elementsArray)
        {
            elements ~= elementsArray;
        }

        // удалить один элемент
        void pop()
        {
            --elements.length;
        }

        // количество элементов
        size_t length() const @property
        {
            return elements.length;
        }

        // вершина стека
        T top() @property
        {
            return elements[$-1];
        }

        // содержимое стека
        T[] content() @property
        {
            return elements;
        }

        // очистить стек
        void clear()
        {
            elements.length = 0;
        }

        // стек пустой ?
        bool empty() const @property
        {
            if (elements.length == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
}


class ShiftedStack(T, size_t M) : Stack!T
{
    private:
        T[M] emptyStack = T.init;

    public:
        this()
        {
            elements ~= emptyStack;
        }


        override
        {
            void push(T element)
            {
                elements ~= element;
                elements = elements[1..$];
            }


            void push(T[] elementsArray)
            {
                if (!elements.empty)
                {
                    elements ~= elementsArray;
                    elements = elements[0..M];
                }
            }

            void pop()
            {
                if (!elements.empty)
                {
                    super.pop();
                    elements ~= emptyStack;
                    elements = elements[0..M];
                }
            }

            size_t length() const @property
            {
                return M;
            }

            void clear()
            {
                elements = emptyStack;
            }
        }

        ref T get(size_t index)
        {
            return elements[index];
        }
}

module receiver.qsonogrambox;

private
{
    import std.algorithm;
    import std.conv;
    import std.math : abs;
    import std.range;
    import std.string;
    import std.stdio;

    import receiver.structures;
    alias FLOW = float[];

    import qte5;

    extern (C)
    {
        void onPaintSonogram(QSonogramBox* sonogram, void* eventPointer, void* painterPointer)
        {
            (*sonogram).runPaint(eventPointer, painterPointer);
        }
    }

    void drawSonogramLine(QPainter painter, ref float[] data, int index)
    {
        auto MIN_N_MAX = data.fold!(min, max);
        enum COLOR_MIN = 0x02;
        enum COLOR_MAX = 0xff;
        float COLOR_STEP = (COLOR_MAX - COLOR_MIN) / (MIN_N_MAX[1] - MIN_N_MAX[0]);

        QColor color = new QColor(null);
        QPen pen = new QPen;
        pen.setWidth(2);

        foreach (x, y; data)
        {
            int COLOR_INTENSITY = cast(int) (COLOR_STEP * y);

            if (COLOR_INTENSITY < COLOR_MIN) { COLOR_INTENSITY = COLOR_MIN; } if (COLOR_INTENSITY > COLOR_MAX)
            {
                COLOR_INTENSITY = COLOR_MAX;
            }

            color.setRgb(
                cast(int) abs(0.8 * COLOR_INTENSITY),
                0,
                COLOR_MAX - COLOR_INTENSITY,
                COLOR_INTENSITY,
            );

            pen.setColor(color);

            painter.setPen(pen);

            painter.drawPoint(cast(int) x * 2, 512 - index);
            //painter.drawPoint((512 - index) * 2, cast(int) (x * 512.0f / data.length));
        }
    }
}

class QSonogramBox : QWidget
{
    private
    {
        ShiftedStack!(FLOW, 512) stack;
        bool isDrawing;
    }

    this(QWidget parent)
    {
        super(this);
        stack = new ShiftedStack!(FLOW, 512);
        setStyleSheet("background: Black");
        setPaintEvent(&onPaintSonogram, aThis);
    }

    void setData(ref float[] data)
    {
        stack.push(data);
        isDrawing = true;
    }

    void runPaint(void* eventPointer, void* painterPointer)
    {
        QPainter painter = new QPainter('+', painterPointer);

        if (isDrawing)
        {
            isDrawing = false;

            foreach (y; 0..512)
            {
                drawSonogramLine(painter, stack.get(y), y);
            }
        }

        painter.end;
   }
}

module receiver.fft;

private
{
    import std.algorithm;
    import std.complex;
    import std.conv;
    import std.math : log10, PI, cos;
    import std.numeric;
    import std.range;
    import std.string;
}

enum WindowFunction
{
    BLACKMAN,
    BLACKMAN_E,
    BLACKMAN_HARRIS,
    BLACKMAN_NUTALL,
    FLAT_TOP,
    HAMMING,
    HANN,
    NUTALL,
    RECTANGULAR,
    SINE
}

auto blackmanWindow(ref float[] data)
{
    float[] result;

    enum float ALPHA = 0.16f;

    enum float a0 = (1.0f - ALPHA) * 0.5f;
    enum float a1 = 0.5;
    enum float a2 = 0.5 * ALPHA;

    foreach (n, e; data)
    {
        auto tmp = a0 - a1 * cos((2 * PI * n) / (data.length - 1.0)) + a2 * cos((4 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto blackmanEWindow(ref float[] data)
{
    float[] result;

    enum float a0 = 0.42659;
    enum float a1 = 0.49656;
    enum float a2 = 0.076849;

    foreach (n, e; data)
    {
        auto tmp = a0 - a1 * cos((2 * PI * n) / (data.length - 1.0)) + a2 * cos((4 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto blackmanHarrisWindow(ref float[] data)
{
    float[] result;

    enum float a0 = 0.35875;
    enum float a1 = 0.48829;
    enum float a2 = 0.14128;
    enum float a3 = 0.01168;

    foreach (n, e; data)
    {
        auto tmp = a0 - a1 * cos((2 * PI * n) / (data.length - 1.0)) + a2 * cos((4 * PI * n) / (data.length - 1.0)) - a3 * cos((6 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto blackmanNutallWindow(ref float[] data)
{
    float[] result;

    enum float a0 = 0.3635819;
    enum float a1 = 0.4891775;
    enum float a2 = 0.1365995;
    enum float a3 = 0.0106411;

    foreach (n, e; data)
    {
        auto tmp = a0 - a1 * cos((2 * PI * n) / (data.length - 1.0)) + a2 * cos((4 * PI * n) / (data.length - 1.0)) - a3 * cos((6 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto flatTopWindow(ref float[] data)
{
    float[] result;

    float a0 = 1.0;
    float a1 = 1.93;
    float a2 = 1.29;
    float a3 = 0.388;
    float a4 = 0.028;

    foreach (n, e; data)
    {
        auto tmp = a0 - a1 * cos((2 * PI * n) / (data.length - 1.0)) + a2 * cos((4 * PI * n) / (data.length - 1.0)) - a3 * cos((6 * PI * n) / (data.length - 1.0)) + a4 * cos((8 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto hammingWindow(ref float[] data)
{
    float[] result;

    foreach (n, e; data)
    {
        auto tmp = 0.53836 - 0.46164 * cos((2 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto hannWindow(ref float[] data)
{
    float[] result;

    foreach (n, e; data)
    {
        auto tmp = 0.5 * (1.0 - cos((2 * PI * n) / (data.length - 1.0)));
        result ~= tmp * e;
    }

    return result;
}

auto nutallWindow(ref float[] data)
{
    float[] result;

    enum float a0 = 0.355768;
    enum float a1 = 0.487396;
    enum float a2 = 0.144232;
    enum float a3 = 0.012604;

    foreach (n, e; data)
    {
        auto tmp = a0 - a1 * cos((2 * PI * n) / (data.length - 1.0)) + a2 * cos((4 * PI * n) / (data.length - 1.0)) - a3 * cos((6 * PI * n) / (data.length - 1.0));
        result ~= tmp * e;
    }

    return result;
}

auto sineWindow(ref float[] data)
{
    float[] result;

    foreach (n, e; data)
    {
        auto tmp = cos(((PI * n) / data.length) - (0.5 * PI));
        result ~= tmp * e;
    }

    return result;
}

auto applyWindow(ref float[] data, WindowFunction window)
{
    float[] result;

    final switch (window) with (WindowFunction)
    {
        case BLACKMAN:
            result = blackmanWindow(data);
            break;
        case BLACKMAN_E:
            result = blackmanEWindow(data);
            break;
        case BLACKMAN_HARRIS:
            result = blackmanHarrisWindow(data);
            break;
        case BLACKMAN_NUTALL:
            result = blackmanNutallWindow(data);
            break;
        case FLAT_TOP:
            result = flatTopWindow(data);
            break;
        case HAMMING:
            result = hammingWindow(data);
            break;
        case HANN:
            result = hannWindow(data);
            break;
        case NUTALL:
            result = nutallWindow(data);
            break;
        case SINE:
            result = sineWindow(data);
            break;
        case RECTANGULAR:
            result = data;
            break;
    }

    return result;
}

auto makeWindow(string windowName)
{
    WindowFunction window;

    switch (windowName)
    {
        case "Blackman":
            window = WindowFunction.BLACKMAN;
            break;
        case "Blackman(e)":
            window = WindowFunction.BLACKMAN_E;
            break;
        case "Blackman-Nutall":
            window = WindowFunction.BLACKMAN_NUTALL;
            break;
        case "Blackman-Harris":
            window = WindowFunction.BLACKMAN_HARRIS;
            break;
        case "Flat top":
            window = WindowFunction.BLACKMAN_HARRIS;
            break;
        case "Hamming":
            window = WindowFunction.HAMMING;
            break;
        case "Hann":
            window = WindowFunction.HANN;
            break;
        case "Nutall":
            window = WindowFunction.NUTALL;
            break;
        case "Sine":
            window = WindowFunction.SINE;
            break;
        default:
            window = WindowFunction.RECTANGULAR;
            break;
    }

    return window;
}

auto makeFFT(ref float[] data, WindowFunction window)
{
    return data
              .applyWindow(window)
              .fft
              .map!(a => cast(float) (20.0f * log10((a * a).abs)))
              .array;
}

auto centerFFT(float[] data)
{
    auto N = cast(uint) data.length;
    //auto centered = new float[N];

    for (uint i = 0; i < N / 2; i++)
    {
        //centered[i] = data[(N / 2) + i];
        //centered[(N / 2) + i] = data[i];
        data[i] = data[(N / 2) + i];
        data[(N / 2) + i] = data[i];
    }

    //return centered;
    return data[0..$/2];
}

void runStart()
{
    string currentPort = combo0.text!string;

    try
    {
        device = new USBDevice(currentPort);

        startButton.setEnabled(false);
        stopButton.setEnabled(true);
        status0.showMessage("Reading from USB device %s ...".format(currentPort));
    }
    catch (Throwable)
    {
        status0.showMessage("Failed to open USB device %s".format(currentPort));
    }
}

void runStop()
{
    string currentPort = combo0.text!string;

    if (device !is null)
    {
        stopButton.setEnabled(false);
        startButton.setEnabled(true);

        status0.showMessage("Reading from USB device %s stopped".format(currentPort));
        device.close;
    }
}

void runTimer()
{
    auto length = area0.width;
    windowFunction = makeWindow(combo1.text!string);
    float block = device.read;

    if (block != -1)
    {
        data ~= block;
    }

    if (data.length == length)
    {
        for (int i = 0; i < data.length; i++)
        {
            try
            {
                area0.setData(data);
                area0.update;

                auto window = data[i..i + windowSize];
                auto fd = window
                                .makeFFT(windowFunction)
                                .centerFFT;

                area1.setData(fd);
                area1.update;
            }
            catch (Throwable)
            {
                break;
            }
        }

        data = [];
    }
}

void runChange()
{
    windowSize = cast(int) (2 ^^ slider0.value);
    label0.setText("%d".format(windowSize));
    label0.update;
}