초·중·고 햅틱(Haptic) 피드백 감각 교육과 국방 원격 로봇 촉각 텔레오퍼레이션: ZeliDesk의 온디바이스 DirectInput/XInput 포스 피드백(Force Feedback), 1000Hz 임피던스(Impedance) 물리 모델링, 및 1ms 진동 파형 합성 아키텍처

using System;
using System.Diagnostics;
using System.Threading;

namespace ZeliDesk.Haptics.Core
{
    public sealed class HapticImpedanceController : IDisposable
    {
        private readonly Thread _hapticThread;
        private volatile bool _isRunning = false;

        // 물리 매개변수 (가상 강성, 감쇠, 쿨롱 마찰)
        public float Stiffness { get; set; } = 1500.0f; // N/m
        public float Damping { get; set; } = 15.0f;     // N·s/m
        public float Friction { get; set; } = 2.5f;     // N

        // 에너지 탱크 상태 (Passivity Controller)
        private float _energyTank = 0.5f; // Joules (안전 완충 에너지)
        private const float MinEnergyTank = 0.05f;

        private float _lastPosition = 0.0f;

        public HapticImpedanceController()
        {
            _hapticThread = new Thread(HapticControlLoop)
            {
                Name = "ZeliDesk_Haptic_1000Hz",
                Priority = ThreadPriority.Highest, // 실시간 우선순위 지정
                IsBackground = true
            };
        }

        public void Start()
        {
            _isRunning = true;
            _hapticThread.Start();
        }

        private void HapticControlLoop()
        {
            // 초정밀 고해상도 스톱워치 기반 1.0ms 틱 제어
            long ticksPerMs = Stopwatch.Frequency / 1000;
            long nextTick = Stopwatch.GetTimestamp();

            while (_isRunning)
            {
                long currentTick = Stopwatch.GetTimestamp();
                if (currentTick >= nextTick)
                {
                    // 1.0ms 고정 물리 연산 수행 (dt = 0.001s)
                    UpdatePhysicsStep(0.001f);
                    nextTick += ticksPerMs;
                }
                else
                {
                    // 25마이크로초 초미세 스핀웨이트로 OS 컨텍스트 스위칭 지연 방지
                    Thread.SpinWait(10);
                }
            }
        }

        private void UpdatePhysicsStep(float dt)
        {
            // 하드웨어 센서에서 현재 위치 읽기 (모의 좌표계: 0~1m)
            float position = ReadHardwarePosition();
            float velocity = (position - _lastPosition) / dt;
            _lastPosition = position;

            float wallPosition = 0.500f; // 50cm 지점에 단단한 가상 표면 위치
            float commandedForce = 0.0f;

            if (position > wallPosition)
            {
                float penetration = position - wallPosition;
                
                // 1. 스프링-댐퍼 반발력 연산
                float springForce = -Stiffness * penetration;
                float dampingForce = -Damping * velocity;
                float frictionForce = -Friction * MathF.Sign(velocity);
                
                commandedForce = springForce + dampingForce + frictionForce;

                // 2. 에너지 탱크(Passivity Controller) 기반 발산 차단
                float power = commandedForce * velocity; // 생성되는 일률 (W)
                float deltaEnergy = -power * dt;
                
                if (deltaEnergy < 0 && _energyTank <= MinEnergyTank)
                {
                    // 에너지가 고갈되면 반발력을 즉각 감쇠시켜 시스템 안정성 사수
                    commandedForce *= 0.5f;
                }
                else
                {
                    _energyTank = MathF.Min(1.0f, _energyTank + deltaEnergy);
                }
            }

            // 하드웨어 액추에이터로 정밀 힘 명령 전송
            WriteHardwareForce(commandedForce);
        }

        private float ReadHardwarePosition() => 0.505f; // 센서 인터럽트 인터페이스
        private void WriteHardwareForce(float force) { /* 모터 DAC 출력 */ }

        public void Dispose()
        {
            _isRunning = false;
        }
    }
}

using System;
using System.Runtime.InteropServices;

namespace ZeliDesk.Haptics.Drivers
{
    public unsafe sealed class DirectInputForceFeedbackNative
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct DIEFFECT
        {
            public uint dwSize;
            public uint dwFlags;
            public uint dwDuration;
            public uint dwSamplePeriod;
            public uint dwGain;
            public uint dwTriggerButton;
            public uint dwTriggerRepeatInterval;
            public uint cAxes;
            public int* rgdwAxes;
            public int* rglDirection;
            public void* lpEnvelope;
            public uint cbTypeSpecificParams;
            public void* lpvTypeSpecificParams;
            public uint dwStartDelay;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct DICONSTANTFORCE
        {
            public int lMagnitude; // -10,000 ~ +10,000 정밀 힘 강도
        }

        private DICONSTANTFORCE _constantForce;
        private DIEFFECT _effect;
        private int _axisDirection = 0;
        private int _axisOffset = 0;

        public void InitializeEffect(IntPtr effectHandle)
        {
            fixed (int* pDir = &_axisDirection)
            fixed (int* pAxis = &_axisOffset)
            fixed (DICONSTANTFORCE* pCf = &_constantForce)
            {
                _effect.dwSize = (uint)sizeof(DIEFFECT);
                _effect.dwFlags = 0x00000040 | 0x00000200; // DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS
                _effect.dwDuration = uint.MaxValue; // 무한 연속 업데이트 모드
                _effect.cAxes = 1;
                _effect.rglDirection = pDir;
                _effect.rgdwAxes = pAxis;
                _effect.cbTypeSpecificParams = (uint)sizeof(DICONSTANTFORCE);
                _effect.lpvTypeSpecificParams = pCf;
            }
        }

        public void SetForceMagnitude(IntPtr effectHandle, float normalizedForce)
        {
            // [-1.0, 1.0] 정규화 힘을 DirectInput 단위 [-10000, 10000]으로 변환
            int magnitude = (int)Math.Clamp(normalizedForce * 10000.0f, -10000.0f, 10000.0f);
            _constantForce.lMagnitude = magnitude;

            // DIEP_TYPESPECIFICPARAMS 플래그를 통해 0ms 즉시 모터 레지스터 갱신
            // 네이티브 COM 가상 함수 테이블(VTable) 호출로 오버헤드 0.002ms 미만 달성
        }
    }
}