OpenSiv3D micro:bit test

Main.cpp

# include "Microbit.h"
# include <Siv3D.hpp>

void Main()
{
	const Array<SerialPortInfo> infos = System::EnumerateSerialPorts();
    Microbit microbit = Microbit::GetFirstMicrobit(infos);

    Vec2 playerPosition = Vec2::Zero();

	while (System::Update())
	{
		microbit.update();
		Vec2 rot = Vec2(microbit.rotation().y, microbit.rotation().x);
		playerPosition += (rot - playerPosition) / 10.0;

		Circle(playerPosition, 32)
		    .movedBy(Window::ClientSize() / 2)
		    .draw();

		ClearPrint();
		Print << rot;
	}
}

Microbit.h

# include <Siv3D.hpp>

enum class MicrobitButton
{
    A,
    B
};

struct SerialData
{
    String label;
    String valueString;

    SerialData() = default;

    SerialData(String label, String valueString)
    {
        this->label = label;
        this->valueString = valueString;
    }
};

class Microbit
{
private:
    Serial serial;
    String buffer;

    double pitch = 0;
    double roll = 0;
    bool buttonPressedA = false;
    bool buttonPressedB = false;

    bool stringToBoolean(const String& string)
    {
        return !!Parse<int>(string);
    }

    bool isAvailable()
    {
        return serial.available();
    }

    SerialData parseData(String data)
    {
        int delimiterPosition = data.indexOf(':');
        String label = data.substr(0, delimiterPosition);
        String valueString = data.substr(delimiterPosition + 1);

        return SerialData(label, valueString);
    }

    void onDataEnter(String dataString)
    {
        auto data = parseData(dataString);
        auto label = data.label;
        auto valueString = data.valueString;

        if (label == U"p")
        {
            pitch = Parse<double>(valueString);
        }
        else if (label == U"r")
        {
            roll = Parse<double>(valueString);
        }
        else if (label == U"a")
        {
            buttonPressedA = stringToBoolean(valueString);
        }
        else if (label == U"b")
        {
            buttonPressedB = stringToBoolean(valueString);
        }

    }

    void processBytes(const Array<uint8>& bytes)
    {
        for (const auto& byte: bytes)
        {
            if (byte == ' ') {}
            else if (byte == '\n')
            {
                if (buffer)
                {
                    onDataEnter(buffer);
                }
                buffer.clear();
            }
            else if (buffer)
            {
                buffer << byte;
            }
            else if (IsAlpha(byte))
            {
                buffer << byte;
            }
        }
    }
public:
    static Microbit GetFirstMicrobit(const Array<SerialPortInfo>& infos)
    {
        Serial serial;
        int index = 0;

        for (const auto& info : infos)
        {
            if (info.port.starts_with(U"/dev/cu.usbmodem"))
            {
                serial.open(infos[index].port, 115200);
            }
            ++index;
        }

        return Microbit(serial);
    }

    Microbit() = default;

    Microbit(Serial serial)
    {
        this->serial = serial;
    }

    void setSerial(Serial serial)
    {
        this->serial = serial;
    }

    bool pressed(MicrobitButton button)
    {
        if (button == MicrobitButton::A)
        {
            return buttonPressedA;
        }
        else if (button == MicrobitButton::B)
        {
            return buttonPressedB;
        }

        return false;
    }

    Vec2 rotation()
    {
        return Vec2(pitch, roll);
    }

    void update()
    {
        if (isAvailable())
        {
            processBytes(serial.readBytes());
        }
    }
};