# Запрос анализа ELM327-кода — для Claude Sonnet

## Контекст

Android-приложение для OBD2-диагностики автомобиля через ELM327 Bluetooth-адаптер.
Стек: Kotlin, minSdk 24, OkHttp 4.12.

**Проблема:** динамический тест (START/STOP) — опрос 3 PID (RPM, MAF, STFT) в реальном времени — 
даёт 94-100% пустых ответов. ELM327 v1.5 просто перестаёт отвечать.

Статическая диагностика (одиночные PID) работает нормально.

## Важно

АНАЛИЗИРУЙ ТОЛЬКО ELM-код. Не трогай UI, сервер, БД. 
Нужен анализ того, почему ELM327 замолкает при динамическом опросе.

## Файлы

Ниже полный код всех файлов, связанных с ELM327.

---

### 1. ElmProtocol.kt — стейт-машина AndrOBD (1:1 копия ElmProt.java)

```kotlin
package ru.elmer.client.elm

import android.util.Log
import java.io.InputStream
import java.io.OutputStream

class ElmProtocol(
    private val input: InputStream,
    private val output: OutputStream
) {
    companion object {
        private const val TAG = "ElmProto"
        private const val POLL_DELAY = 1L
        private const val INIT_TIMEOUT = 10000L
        private const val DEF_TIMEOUT  = 500L
        private const val TIMEOUT_MIN  = 50L
        private const val TIMEOUT_MAX  = 2000L
        private const val TIMEOUT_STEP = 20L
        private const val TIMEOUT_RES  = 4
        private const val MAX_RETRIES  = 10
    }

    private enum class State { UNDEFINED, INITIALIZING, READY, BUSY, ERROR, DISCONNECTED }
    private var state = State.UNDEFINED
    private var timeoutMs = DEF_TIMEOUT
    private var learnedMin = TIMEOUT_MIN

    fun init() {
        Log.i(TAG, "init start")
        state = State.INITIALIZING
        write("ATSP0"); tryRead(4000); drainInput()
        write("ATAT1"); tryRead(2000); drainInput()
        updateAtst()
        write("ATS0"); tryRead(2000); drainInput()
        write("ATL0"); tryRead(2000); drainInput()
        write("ATE0"); tryRead(2000); drainInput()
        state = State.READY
        Log.i(TAG, "ready")
    }

    fun sendCommand(cmd: String): String {
        if (state == State.ERROR || state == State.DISCONNECTED) recover()
        state = State.BUSY
        val result = exec(cmd, timeoutMs)
        if (state == State.BUSY) state = State.READY
        return result
    }

    private fun exec(cmd: String, timeout: Long): String {
        write(cmd)
        var t = timeout
        for (i in 0 until MAX_RETRIES) {
            try {
                return handle(read(t))
            } catch (_: TimeoutException) {
                if (state == State.INITIALIZING) t += 1000
                else { increaseTimeout(); t = timeoutMs }
            }
        }
        Log.e(TAG, "no response for $cmd")
        state = State.ERROR
        return ""
    }

    private fun handle(raw: String): String {
        val u = raw.uppercase().trim()
        when {
            u.startsWith("SEARCHING") -> {}
            u.startsWith("OK") -> decreaseTimeout()
            u.startsWith("NODATA") || u.startsWith("NO DATA") -> {
                increaseTimeout(); updateAtst()
            }
            isBusError(u) -> {
                Log.w(TAG, "BUS ERROR: ${raw.take(60)}")
                state = State.DISCONNECTED
                resetTimeout(); updateAtst()
                write("ATPC"); tryRead(3000)
                write("ATSP0"); tryRead(3000)
            }
            u.startsWith("ERROR") && !u.startsWith("DATA ERROR") -> {
                Log.w(TAG, "ERROR — warm start")
                state = State.ERROR
                write("ATWS"); tryRead(3000)
            }
            isDataError(u) -> {
                Log.w(TAG, "data error — warm start")
                state = State.ERROR
                write("ATWS"); tryRead(3000)
            }
            else -> decreaseTimeout()
        }
        return raw
    }

    private fun recover() {
        Log.i(TAG, "recovering...")
        state = State.INITIALIZING
        write("ATWS"); tryRead(2000); drainInput()
        write("ATSP0"); tryRead(2000); drainInput()
        write("ATE0"); tryRead(2000); drainInput()
        state = State.READY
    }

    private fun write(cmd: String) {
        drainInput()
        output.write((cmd + "\r").toByteArray())
        output.flush()
        Log.d(TAG, "→ $cmd")
    }

    private fun drainInput() {
        while (input.available() > 0) input.read()
    }

    @Throws(TimeoutException::class)
    private fun read(timeout: Long): String {
        val dl = System.currentTimeMillis() + timeout
        val sb = StringBuilder()
        val lines = mutableListOf<String>()
        var gotPrompt = false
        while (System.currentTimeMillis() < dl) {
            if (input.available() > 0) {
                val b = input.read()
                if (b == -1) break
                when (b) {
                    62 -> { push(sb, lines); gotPrompt = true; break }     // '>'
                    13 -> push(sb, lines)                                   // CR
                    10, 32 -> {}                                            // LF, space
                    else -> sb.append(b.toChar())
                }
            } else {
                Thread.sleep(POLL_DELAY)
            }
        }
        push(sb, lines)
        if (!gotPrompt) throw TimeoutException("timeout ${timeout}ms")
        return lines.joinToString("\n")
    }

    private fun tryRead(timeout: Long) {
        try { read(timeout) } catch (_: TimeoutException) {}
    }

    private fun push(sb: StringBuilder, lines: MutableList<String>) {
        if (sb.isNotEmpty()) { lines.add(sb.toString()); sb.clear() }
    }

    private fun increaseTimeout() {
        if (timeoutMs + TIMEOUT_STEP < TIMEOUT_MAX) timeoutMs += TIMEOUT_STEP
    }

    private fun decreaseTimeout() {
        if (timeoutMs - TIMEOUT_STEP >= learnedMin) timeoutMs -= TIMEOUT_STEP
    }

    private fun resetTimeout() { timeoutMs = DEF_TIMEOUT }

    fun resetAdaptiveTiming() { timeoutMs = DEF_TIMEOUT }

    private fun updateAtst() {
        val v = (timeoutMs / TIMEOUT_RES).toInt().coerceAtLeast(1)
        write("ATST${v.toString(16).uppercase().padStart(2, '0')}")
        tryRead(2000)
        drainInput()
    }

    private fun isBusError(s: String): Boolean {
        return listOf("UNABLE", "BUS BUSY", "BUS ERROR", "CAN ERROR",
            "BUS INIT", "STOPPED").any { s.startsWith(it) }
    }

    private fun isDataError(s: String): Boolean {
        return listOf("DATA ERROR", "BUFFER FULL", "RX ERROR").any { s.startsWith(it) }
    }
}

class TimeoutException(message: String) : Exception(message)
```

---

### 2. DynamicCollector.kt — сборщик для динамического теста

```kotlin
package ru.elmer.client.script

import ru.elmer.client.elm.ElmProtocol
import ru.elmer.client.elm.ObdDecoder
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.concurrent.thread

class DynamicCollector(
    private val elm: ElmProtocol,
    private val steps: List<ElmStep>,
    private val intervalMs: Long,
    private val onSample: (sampleIndex: Int) -> Unit,
    private val onLog: (msg: String) -> Unit
) {
    data class ElmStep(val id: String, val cmd: String, val desc: String)
    private val running = AtomicBoolean(false)
    private val samples = mutableListOf<List<SampleResponse>>()
    private var threadRef: Thread? = null

    data class SampleResponse(
        val stepId: String, val cmd: String, val raw: String,
        val decoded: String, val ts: Long = 0
    )

    fun start() {
        running.set(true)
        val startTs = System.currentTimeMillis()
        threadRef = thread(name = "DynamicCollector", isDaemon = true) {
            var idx = 0
            while (running.get()) {
                val t0 = System.currentTimeMillis()
                val batch = mutableListOf<SampleResponse>()
                for (step in steps) {
                    if (!running.get()) break
                    try {
                        val raw = elm.sendCommand(step.cmd)
                        val dec = ObdDecoder.decode(step.cmd, raw)
                        batch.add(SampleResponse(step.id, step.cmd, raw, dec, System.currentTimeMillis() - startTs))
                    } catch (e: Exception) {
                        batch.add(SampleResponse(step.id, step.cmd, "(err)", e.message ?: "error", System.currentTimeMillis() - startTs))
                    }
                    Thread.sleep(350)
                }
                if (batch.isNotEmpty()) {
                    synchronized(samples) { samples.add(batch) }
                    onSample(idx); idx++
                }
                val elapsed = System.currentTimeMillis() - t0
                val sleep = intervalMs - elapsed
                if (sleep > 0 && running.get()) Thread.sleep(sleep)
            }
        }
    }

    fun stop(): List<List<SampleResponse>> {
        running.set(false)
        try { threadRef?.join(3000) } catch (_: Exception) {}
        return synchronized(samples) { samples.toList() }
    }

    fun isRunning(): Boolean = running.get()
}
```

---

### 3. ElmChecker.kt — проверка устройства + speed-test

```kotlin
package ru.elmer.client.elm

import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothSocket
import android.util.Log
import java.io.IOException
import java.util.UUID

class ElmChecker(
    private val device: BluetoothDevice,
    private val adapter: BluetoothAdapter
) {
    companion object {
        private const val TAG = "ElmChecker"
        private val SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
    }

    data class DeviceInfo(
        val version: String, val deviceId: String, val protocol: String,
        val voltage: String, val hasAdaptive: Boolean
    )
    data class EcuData(val supportsObd: Boolean, val pidMask: String, val vin: String?)
    data class Result(val good: Boolean, val device: DeviceInfo, val ecu: EcuData, val log: String)

    private val logLines = mutableListOf<String>()
    fun getLog(): String = logLines.joinToString("\n")
    private var socket: BluetoothSocket? = null
    private var elm: ElmProtocol? = null

    fun checkDevice(): DeviceInfo? {
        if (!connectAndInit()) return null
        val ati = send("ATI"); val version = parseVersion(ati)
        val isV2 = version.contains("v2", ignoreCase = true)
        val deviceId = if (isV2) cleanAt2(send("AT@2")) else "—"
        val dp = send("ATDP"); val protocol = if (dp.length > 3 && dp != "OK") dp.take(60) else dp
        val rv = send("ATRV"); val voltage = if (rv.contains("V", ignoreCase = true) || rv.matches(Regex("[0-9.]+"))) rv else "—"
        val hasAdaptive = if (isV2) send("ATAT1") == "OK" else false
        return DeviceInfo(version, deviceId, protocol, voltage, hasAdaptive)
    }

    fun checkEcu(): EcuData {
        val pid0100 = send("0100"); val supportsObd = pid0100.startsWith("41")
        val pidMask = if (supportsObd) pid0100.take(60) else "—"
        val vinRaw = send("0902"); val vin = parseVin(vinRaw)
        return EcuData(supportsObd, pidMask, vin)
    }

    fun scanDtc(): List<String>? {
        if (!connectAndInit()) { disconnect(); return null }
        val codes = mutableListOf<String>()
        codes.addAll(parseDtcCodes(send("03")))
        codes.addAll(parseDtcCodes(send("07")))
        return codes.distinct()
    }

    fun ensureConnected(): Boolean = connectAndInit()
    fun isConnected(): Boolean = socket?.isConnected == true && elm != null
    fun getElm(): ElmProtocol? = elm

    fun quickCheck(): Int? {
        val e = elm ?: return null
        return try {
            val t0 = System.currentTimeMillis()
            val raw = e.sendCommand("010C"); val dt = System.currentTimeMillis() - t0
            if (raw.isBlank() || raw == "(err)") null else dt.toInt()
        } catch (_: Exception) { null }
    }

    data class SpeedTestResult(val perPidAvg: List<Int>, val batchTime: Int, val reliable: Boolean, val message: String)

    fun measureResponseTime(onProgress: (String) -> Unit): SpeedTestResult {
        val testPids = listOf("010C" to "RPM", "0110" to "MAF", "0106" to "STFT")
        val perPidAvg = mutableListOf<Int>()
        var hadErrors = false; var reliable = true
        val reasons = mutableListOf<String>()
        val e = elm ?: return SpeedTestResult(listOf(250,250,250), 750, false, "❌ ELM не инициализирован")
        try { e.sendCommand("010C") } catch (_: Exception) {}
        onProgress("\n⏱ Тест скорости ELM...")
        for ((pi, pair) in testPids.withIndex()) {
            val (cmd, name) = pair; val allTimes = mutableListOf<Long>()
            val count = if (pi == 0) 4 else 3
            for (i in 0 until count) {
                val t0 = System.currentTimeMillis()
                val raw = try { e.sendCommand(cmd) } catch (_: Exception) { "(err)" }
                val dt = System.currentTimeMillis() - t0; allTimes.add(dt)
                if (raw == "(err)" || raw.isBlank()) hadErrors = true
            }
            val times = if (pi == 0) allTimes.takeLast(2).toMutableList() else allTimes
            val avg = times.average().toInt(); perPidAvg.add(avg)
            onProgress("\n   $name: ${times.joinToString("ms, ")}ms  (среднее ${avg}ms)")
            for (t in times) {
                if (t > 0 && avg > 0 && kotlin.math.abs(t - avg).toFloat() / avg > 0.5f) {
                    if (reliable) reliable = false
                    reasons.add("${name} нестабилен: ${t}ms vs среднее ${avg}ms")
                }
            }
        }
        val batchTime = perPidAvg.sum()
        val message = if (reliable) "✅ Скорость стабильна: ${perPidAvg.joinToString("+")}=${batchTime}ms"
        else "⚠️ ${reasons.joinToString("; ")}. Проверьте контакт ELM в OBD-разъёме."
        onProgress("\n$message")
        return SpeedTestResult(perPidAvg, batchTime, reliable, message)
    }

    fun close() { try { socket?.close() } catch (_: Exception) {}; socket = null; elm = null }

    // ... (private connect, send, parseVin, parseDtcCodes, parseVersion, failResult опущены для краткости)
}
```

---

## Проблема

При динамическом тесте:

```
Сессия #54 (v1.3.0-dev): 55 ответов
  0106 (STFT): 1 ok / 18 попыток → 94% ошибок
  010C (RPM):  1 ok / 18 попыток → 94% ошибок
  0110 (MAF):  0 ok / 18 попыток → 100% ошибок
  
Первые 2 ответа — нормальные (410680, 41110E), затем 17 пустых.
```

**Поток вызовов перед динамическим тестом:**
1. `ElmProtocol.init()` — 5 AT-команд (ATSP0, ATAT1, ATS0, ATL0, ATE0)
2. `ElmChecker.checkDevice()` — 5-6 AT-команд (ATI, AT@2, ATDP, ATRV, ATAT1)
3. `ElmChecker.checkEcu()` — 2 OBD-команды (0100, 0902)
4. В MainActivity: статический проброс 9 PID (0104-011F)
5. Speed-test: 1 warmup + 4 RPM + 3 MAF + 3 STFT = 11 OBD-команд
6. `ATWS` — сброс ELM
7. DynamicCollector: 3 PID в цикле каждые 500ms

**Ключевое:** `sendCommand()` → `exec()` при таймауте делает RETRY:
- `write(cmd)` — посылает команду
- `read(timeout)` — ждёт ответ
- таймаут → `increaseTimeout()` → `write(cmd)` ОПЯТЬ
- до 10 retry на одну команду

## Вопросы

1. Почему ELM327 v1.5 замолкает после первых 2 ответов в DynamicCollector?
2. Может ли `drainInput()` в `write()` съедать ответ от предыдущей команды?
3. Критична ли последовательность: static probe → speed-test → ATWS → dynamic collect?
4. Нужно ли переподключать ELM перед динамическим тестом вместо ATWS?
5. Как правильно реализовать динамический опрос с учётом медленного ELM327 v1.5 (min ответ 350ms)?

Ответ сохрани в файл `doc/claude-analysis-elm.md`

---

### 4. MainActivity.kt — фрагменты (checkElm, checkEcu, startDynamicRecording)

```kotlin
// Вызывается при клике на светофор ELM
private fun checkElm() {
    // ... поиск Bluetooth-устройства ...
    elmDevice = dev
    try {
        val checker = ElmChecker(dev, btAdapter!!)
        val r = checker.checkDevice()  // AT-команды, инициализация
        if (r != null) {
            elmChecker = checker
            setIndicator(indElm, "🟢")
            checkEcu()  // ← синхронно на главном потоке!
            // Speed-test в фоновом потоке
            thread(name = "SpeedTest", isDaemon = true) {
                val client = ServerClient(...)
                val saved = client.getProfileResponseTime(elmMac)
                if (saved != null && saved > 0) {
                    val quick = checker.quickCheck()  // 010C × 1
                    // сверка с профилем...
                    return@thread
                }
                val result = checker.measureResponseTime { msg -> debugLog(msg) }
                if (result.reliable) client.saveProfile(elmMac, result.batchTime)
            }
        }
    } catch ...
}

private fun checkEcu() {
    val checker = elmChecker ?: return
    try {
        val raw = checker.getElm()?.sendCommand("03") ?: ""  // ← синхронно!
        val ok = raw.startsWith("43")
        setIndicator(indEcu, if (ok) "🟢" else "🔴")
    } catch ...
}

// Вызывается при нажатии СТАРТ
private fun startDynamicRecording() {
    thread(name = "DynamicTest", isDaemon = true) {
        val checker = elmChecker
        if (!checker.ensureConnected()) { /* retry */ }
        val elmProto = checker.getElm()!!

        // ── Статика: пробуем 9 PID ──
        for ((pid, desc) in staticCmds) {
            val raw = elmProto.sendCommand("01$pid")
            // ...
        }

        // ── ATWS: сброс ELM ──
        try { elmProto.sendCommand("ATWS") } catch (_: Exception) {}
        Thread.sleep(300)

        // ── Динамика: 3 PID, интервал 500ms ──
        val dynSteps = listOf("010C" to "RPM", "0110" to "MAF", "0106" to "STFT")
            .map { ElmStep(it.second, it.first, it.second) }
        val collector = DynamicCollector(elmProto, dynSteps, 500L, ...)
        collector.start()
        while (state == State.START && collector.isRunning()) Thread.sleep(200)
        val samples = collector.stop()
        // ... контроль качества, слияние со статикой ...
    }
}
```