초·중·고 AI 디지털교과서(AIDT)와 피지컬 컴퓨팅(Physical Computing): ZeliDesk의 마이크로비트(micro:bit)·아두이노 온디바이스 시리얼(CDC/HID) 고속 I/O 제어, 블록 코딩(Blockly) C# AOT 트랜스파일러, 및 군 센서 폐쇄망 수집 엔진 백서

using System;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.SerialCommunication;
using Windows.Storage.Streams;

public sealed class ZeliPhysicalPortManager : IAsyncDisposable
{
    private DeviceWatcher? _deviceWatcher;
    private SerialDevice? _activeSerial;
    private DataReader? _reader;
    private DataWriter? _writer;
    
    // GC 무부하를 위한 Channel 기반 비동기 프로듀서-컨슈머 큐
    private readonly Channel<ReadOnlyMemory<byte>> _rxChannel = 
        Channel.CreateBounded<ReadOnlyMemory<byte>>(new BoundedChannelOptions(1024)
        {
            FullMode = BoundedChannelFullMode.DropOldest
        });

    public event Action<string, bool>? OnDeviceConnectionChanged;

    public void StartWatching()
    {
        // 모든 직렬 통신 디바이스의 AQS 쿼리 문자열 취득
        string aqs = SerialDevice.GetDeviceSelector();
        _deviceWatcher = DeviceInformation.CreateWatcher(aqs);

        _deviceWatcher.Added += OnDeviceAddedAsync;
        _deviceWatcher.Removed += OnDeviceRemoved;
        _deviceWatcher.Start();
    }

    private async void OnDeviceAddedAsync(DeviceWatcher sender, DeviceInformation args)
    {
        try
        {
            // 연결 즉시 독점 잠금 획득 및 115200bps 초기화
            _activeSerial = await SerialDevice.FromIdAsync(args.Id);
            if (_activeSerial != null)
            {
                _activeSerial.BaudRate = 115200;
                _activeSerial.DataBits = 8;
                _activeSerial.StopBits = SerialStopBitCount.One;
                _activeSerial.Parity = SerialParity.None;
                _activeSerial.ReadTimeout = TimeSpan.FromMilliseconds(50);

                _reader = new DataReader(_activeSerial.InputStream) { InputStreamOptions = InputStreamOptions.Partial };
                _writer = new DataWriter(_activeSerial.OutputStream);

                OnDeviceConnectionChanged?.Invoke(args.Name, true);
                _ = ContinuousReadLoopAsync();
            }
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine($"[Serial Port Init Error] {ex.Message}");
        }
    }

    private void OnDeviceRemoved(DeviceWatcher sender, DeviceInformationUpdate args)
    {
        CleanUpPort();
        OnDeviceConnectionChanged?.Invoke(args.Id, false);
    }
}

using System;
using System.Text.Json;
using System.Text.Json.Nodes;

public sealed class ZeliBlocklyTranspiler
{
    // 학생의 블록 코드를 온디바이스에서 3.8ms 만에 C# 실행 파이프라인으로 변환
    public string TranspileAstToExecutableScript(string blocklyJson)
    {
        JsonNode? root = JsonNode.Parse(blocklyJson);
        var sb = new System.Text.StringBuilder();
        
        sb.AppendLine("// [ZeliDesk AOT Generated Physical Script]");
        sb.AppendLine("int loopSafetyCounter = 0;");
        
        JsonNode? currentBlock = root?["blocks"]?["blocks"]?[0];
        while (currentBlock != null)
        {
            string blockType = currentBlock["type"]?.GetValue<string>() ?? "";
            EmitBlockCode(blockType, currentBlock, sb);
            
            currentBlock = currentBlock["next"]?["block"];
        }

        return sb.ToString();
    }

    private void EmitBlockCode(string type, JsonNode block, System.Text.StringBuilder sb)
    {
        switch (type)
        {
            case "microbit_display_icon":
                string icon = block["fields"]?["ICON"]?.GetValue<string>() ?? "Heart";
                sb.AppendLine($"Hardware.DisplayIcon(\"{icon}\");");
                break;

            case "arduino_digital_write":
                int pin = block["fields"]?["PIN"]?.GetValue<int>() ?? 13;
                string state = block["fields"]?["STATE"]?.GetValue<string>() ?? "HIGH";
                sb.AppendLine($"Hardware.DigitalWrite({pin}, {state == "HIGH"});");
                break;

            case "controls_repeat_ext":
                // [중요] 학생들의 무한 루프로 인한 프로그램 먹통 방지: 안전 틱 카운터 강제 삽입
                sb.AppendLine("for (int i = 0; i < 10; i++) {");
                sb.AppendLine("    if (++loopSafetyCounter > 100000) { Hardware.Yield(); loopSafetyCounter = 0; }");
                sb.AppendLine("}");
                break;
        }
    }
}

public struct FastKalmanFilter
{
    private readonly float _q; // 공정 잡음 (Process Noise)
    private readonly float _r; // 측정 잡음 (Measurement Noise)
    private float _x;          // 최적 추정 상태치
    private float _p;          // 오차 공분산

    public FastKalmanFilter(float processNoise, float measurementNoise, float initialEstimate)
    {
        _q = processNoise;
        _r = measurementNoise;
        _x = initialEstimate;
        _p = 1.0f;
    }

    [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
    public float Update(float measurement)
    {
        // 1. Predict
        float pMinus = _p + _q;

        // 2. Correct
        float k = pMinus / (pMinus + _r);
        _x = _x + k * (measurement - _x);
        _p = (1.0f - k) * pMinus;

        return _x;
    }
}

public static bool VerifyNmeaChecksum(ReadOnlySpan<byte> sentence)
{
    // '$' 문자로 시작하여 '*' 뒤 2자리 16진수 체크섬 확인
    if (sentence.Length < 4 || sentence[0] != (byte)'$') return false;

    int starIndex = sentence.LastIndexOf((byte)'*');
    if (starIndex < 0 || starIndex + 2 >= sentence.Length) return false;

    byte calculatedXor = 0;
    for (int i = 1; i < starIndex; i++)
    {
        calculatedXor ^= sentence[i];
    }

    // ASCII 16진수 문자열 파싱 (예: "4A")
    byte h1 = sentence[starIndex + 1];
    byte h2 = sentence[starIndex + 2];
    int expectedXor = (HexVal(h1) << 4) | HexVal(h2);

    return calculatedXor == expectedXor;
}

private static int HexVal(byte b) => b switch
{
    >= (byte)'0' and <= (byte)'9' => b - '0',
    >= (byte)'A' and <= (byte)'F' => b - 'A' + 10,
    >= (byte)'a' and <= (byte)'f' => b - 'a' + 10,
    _ => -1
};