Add generic ADAU1701 parameter access (GET/PUT /api/dsp/param)

New core::IDsp::writeRawParam(address, value) safeloads any named
Parameter RAM cell in the compiled SigmaStudio program (74 cells: mixer/
Beep1/PEQ coefficients/limiter thresholds/etc — the same set SigmaStudio's
own Remote Connection, components/net/SigmaStudioTcpServer, already has
full access to). Value is a plain SigmaStudio floating coefficient,
converted to ADAU 8.23 fixpoint via the existing core::floatToFixpoint823.

Adau1701ParamTable.hpp holds the name->address table extracted from
Firmware/ADAU1701-Firmware/DigiRadio_IC_1_PARAM.h; core::DspParamJson
handles the wire format without core/ depending on the adau1701 driver
(net/SetupWebServer.cpp bridges the two, consistent with how other
JSON DTOs are supplied their data by the net layer).

GET /api/dsp/params lists every cell (name + address) for discovery.
PUT /api/dsp/param {"name":...,"value":...} writes one. Deliberately no
domain validation, matching the trust level already implied by the
existing SigmaStudio TCP bridge being reachable on the same network.
HTTP routes were registered in the SetupWebServer.cpp change committed
alongside the FM band scan feature (3a10ed7).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0178rASQ6ZETPMUamvpoR2KR

Software/components/core/CMakeLists.txt

@@ -12,6 +12,7 @@ idf_component_register(
         "src/WifiScanJson.cpp"
         "src/EmbeddedBlobReader.cpp"
         "src/TunerJson.cpp"
+        "src/DspParamJson.cpp"
         "src/FrequencyKHz.cpp"
         "src/GainDb.cpp"
         "src/FrequencyHz.cpp"

Software/components/core/include/core/DspParamJson.hpp

@@ -0,0 +1,95 @@
+/**
+ * @file    DspParamJson.hpp
+ * @brief   JSON parse/serialise for generic ADAU1701 parameter access (pure core).
+ *
+ * DigiRadio firmware — https://github.com/manvalan/DigiRadio
+ *
+ * Copyright 2026 Michele Bigi
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * @author  Michele Bigi
+ * @date    2026-08-18
+ */
+#pragma once
+
+#include "core/ParseError.hpp"
+
+#include <expected>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace core {
+
+/**
+ * @brief    DspParamWriteRequest — parsed PUT /api/dsp/param body.
+ *
+ * @dname    DspParamWriteRequest
+ * @return   n/a (type)
+ * @pubstate Plain DTO filled by parseDspParamWriteJson at the HTTP boundary.
+ *
+ * @author   Michele Bigi
+ * @date     2026-08-18
+ */
+struct DspParamWriteRequest {
+    std::string name;  ///< Cell name, looked up against the driver's table.
+    float value;       ///< SigmaStudio floating coefficient to write.
+};
+
+/**
+ * @brief    DspParamInfo — one discoverable Parameter RAM cell.
+ *
+ * @dname    DspParamInfo
+ * @return   n/a (type)
+ * @pubstate Plain DTO; caller supplies the table (core stays hardware-agnostic).
+ *
+ * @author   Michele Bigi
+ * @date     2026-08-18
+ */
+struct DspParamInfo {
+    std::string_view name; ///< Cell name as exported by SigmaStudio.
+    unsigned address;      ///< Parameter RAM address for safeload writes.
+};
+
+/**
+ * @brief    parseDspParamWriteJson — validate PUT /api/dsp/param body.
+ *
+ * @dname    parseDspParamWriteJson
+ * @param    json  Untrusted request body from the HTTP handler.
+ * @return   DspParamWriteRequest on success, or a ParseError.
+ * @pubstate none
+ *
+ * @author   Michele Bigi
+ * @date     2026-08-18
+ */
+[[nodiscard]] std::expected<DspParamWriteRequest, ParseError>
+parseDspParamWriteJson(std::string_view json);
+
+/**
+ * @brief    serializeDspParamListJson — serialise the discoverable cell list.
+ *
+ * @dname    serializeDspParamListJson
+ * @param    params  Every named cell in the compiled DSP program.
+ * @return   JSON object with a `params` array for the HTTP response body.
+ * @pubstate none
+ *
+ * @author   Michele Bigi
+ * @date     2026-08-18
+ */
+[[nodiscard]] std::string serializeDspParamListJson(
+    const std::vector<DspParamInfo>& params);
+
+/**
+ * @brief    serializeDspParamErrorJson — serialise a DSP param API error.
+ *
+ * @dname    serializeDspParamErrorJson
+ * @param    reason  Short machine-readable cause (never a secret).
+ * @return   JSON object string with status error and reason fields.
+ * @pubstate none
+ *
+ * @author   Michele Bigi
+ * @date     2026-08-18
+ */
+[[nodiscard]] std::string serializeDspParamErrorJson(const char* reason);
+
+} // namespace core

Software/components/core/include/core/IDsp.hpp

@@ -145,6 +145,24 @@ public:
      */
     [[nodiscard]] virtual std::expected<void, DspError> setBeepEnabled(
         bool enabled) = 0;
+
+    /**
+     * @brief    writeRawParam — safeload any named Parameter RAM cell.
+     *
+     * @dname    writeRawParam
+     * @param    address  Parameter RAM address.
+     * @param    value    Coefficient in the SigmaStudio floating
+     *                    convention; converted to ADAU 8.23 fixpoint.
+     * @return   Ok on success, or DspError.
+     * @pubstate writes ADAU1701 parameter RAM via safeload. Not part of
+     *           AudioProfile — live-only, never persisted. No domain
+     *           validation; see Adau1701Driver::writeRawParam().
+     *
+     * @author   Michele Bigi
+     * @date     2026-08-18
+     */
+    [[nodiscard]] virtual std::expected<void, DspError> writeRawParam(
+        unsigned address, float value) = 0;
 };
 
 } // namespace core

Software/components/core/src/DspParamJson.cpp

@@ -0,0 +1,100 @@
+/**
+ * @file    DspParamJson.cpp
+ * @brief   DspParamJson implementation.
+ *
+ * DigiRadio firmware — https://github.com/manvalan/DigiRadio
+ *
+ * Copyright 2026 Michele Bigi
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * @author  Michele Bigi
+ * @date    2026-08-18
+ */
+
+#include "core/DspParamJson.hpp"
+
+#include <cstdlib>
+#include <sstream>
+
+namespace core {
+
+namespace {
+
+[[nodiscard]] std::string_view extractJsonString(std::string_view json,
+                                                  std::string_view key)
+{
+    const std::string needle =
+        std::string("\"") + std::string(key) + "\":\"";
+    const std::size_t start = json.find(needle);
+    if (start == std::string_view::npos) {
+        return {};
+    }
+    const std::size_t valueStart = start + needle.size();
+    const std::size_t valueEnd = json.find('"', valueStart);
+    if (valueEnd == std::string_view::npos) {
+        return {};
+    }
+    return json.substr(valueStart, valueEnd - valueStart);
+}
+
+[[nodiscard]] bool extractJsonFloat(std::string_view json,
+                                    std::string_view key, float& out)
+{
+    const std::string needle = std::string("\"") + std::string(key) + "\":";
+    const std::size_t start = json.find(needle);
+    if (start == std::string_view::npos) {
+        return false;
+    }
+    const std::size_t valueStart = start + needle.size();
+    char* end = nullptr;
+    out = std::strtof(json.data() + valueStart, &end);
+    return end != json.data() + valueStart;
+}
+
+} // namespace
+
+std::expected<DspParamWriteRequest, ParseError> parseDspParamWriteJson(
+    std::string_view json)
+{
+    if (json.find('{') == std::string_view::npos) {
+        return std::unexpected(ParseError::InvalidJson);
+    }
+
+    const std::string_view name = extractJsonString(json, "name");
+    if (name.empty()) {
+        return std::unexpected(ParseError::MissingField);
+    }
+
+    float value = 0.0F;
+    if (!extractJsonFloat(json, "value", value)) {
+        return std::unexpected(ParseError::MissingField);
+    }
+
+    DspParamWriteRequest req;
+    req.name.assign(name.begin(), name.end());
+    req.value = value;
+    return req;
+}
+
+std::string serializeDspParamListJson(const std::vector<DspParamInfo>& params)
+{
+    std::ostringstream out;
+    out << "{\"params\":[";
+    for (std::size_t i = 0; i < params.size(); ++i) {
+        if (i > 0U) {
+            out << ',';
+        }
+        out << "{\"name\":\"" << params[i].name << "\",\"address\":"
+            << params[i].address << "}";
+    }
+    out << "]}";
+    return out.str();
+}
+
+std::string serializeDspParamErrorJson(const char* reason)
+{
+    return std::string("{\"status\":\"error\",\"reason\":\"") + reason
+           + "\"}";
+}
+
+} // namespace core

Software/components/core/test/CMakeLists.txt

@@ -24,6 +24,7 @@ add_library(digiradio_core STATIC
     "${CORE_SRC_DIR}/WifiScanJson.cpp"
     "${CORE_SRC_DIR}/EmbeddedBlobReader.cpp"
     "${CORE_SRC_DIR}/TunerJson.cpp"
+    "${CORE_SRC_DIR}/DspParamJson.cpp"
     "${CORE_SRC_DIR}/FrequencyKHz.cpp"
     "${CORE_SRC_DIR}/GainDb.cpp"
     "${CORE_SRC_DIR}/FrequencyHz.cpp"
@@ -89,6 +90,10 @@ add_executable(tuner_json_test tuner_json_test.cpp)
 target_link_libraries(tuner_json_test PRIVATE digiradio_core)
 add_test(NAME tuner_json_test COMMAND tuner_json_test)
 
+add_executable(dsp_param_json_test dsp_param_json_test.cpp)
+target_link_libraries(dsp_param_json_test PRIVATE digiradio_core)
+add_test(NAME dsp_param_json_test COMMAND dsp_param_json_test)
+
 add_executable(frequency_khz_test frequency_khz_test.cpp)
 target_link_libraries(frequency_khz_test PRIVATE digiradio_core)
 add_test(NAME frequency_khz_test COMMAND frequency_khz_test)

Software/components/core/test/dsp_param_json_test.cpp

@@ -0,0 +1,129 @@
+/**
+ * @file    dsp_param_json_test.cpp
+ * @brief   Host tests for DspParamJson parse/serialise.
+ *
+ * DigiRadio firmware — https://github.com/manvalan/DigiRadio
+ *
+ * Copyright 2026 Michele Bigi
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * @author  Michele Bigi
+ * @date    2026-08-18
+ */
+
+#include "core/DspParamJson.hpp"
+
+#include <cstdlib>
+#include <iostream>
+
+namespace {
+
+bool expectEqual(const std::string& actual, const std::string& expected)
+{
+    if (actual != expected) {
+        std::cerr << "expected: " << expected << "\n  actual: " << actual
+                  << "\n";
+        return false;
+    }
+    return true;
+}
+
+[[nodiscard]] int runParseWriteTest()
+{
+    const auto parsed = core::parseDspParamWriteJson(
+        R"({"name":"BEEP1_KICK","value":1.0})");
+    if (!parsed) {
+        std::cerr << "expected parse success\n";
+        return EXIT_FAILURE;
+    }
+    if (parsed->name != "BEEP1_KICK" || parsed->value != 1.0F) {
+        std::cerr << "unexpected parsed fields\n";
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+[[nodiscard]] int runParseNegativeValueTest()
+{
+    const auto parsed = core::parseDspParamWriteJson(
+        R"({"name":"LIMITER1_THRESHOLD","value":-0.5})");
+    if (!parsed || parsed->value != -0.5F) {
+        std::cerr << "expected negative value to parse\n";
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+[[nodiscard]] int runParseMissingFieldTest()
+{
+    const auto parsed = core::parseDspParamWriteJson(R"({"name":"X"})");
+    if (parsed) {
+        std::cerr << "expected missing value to fail\n";
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+[[nodiscard]] int runParseInvalidJsonTest()
+{
+    const auto parsed = core::parseDspParamWriteJson("not json");
+    if (parsed) {
+        std::cerr << "expected invalid json to fail\n";
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+[[nodiscard]] int runSerialiseListTest()
+{
+    const std::vector<core::DspParamInfo> params = {
+        {"BEEP1_ENABLE", 0},
+        {"BEEP1_KICK", 1},
+    };
+    const std::string json = core::serializeDspParamListJson(params);
+    if (!expectEqual(
+            json,
+            R"({"params":[{"name":"BEEP1_ENABLE","address":0},{"name":"BEEP1_KICK","address":1}]})")) {
+        return EXIT_FAILURE;
+    }
+
+    const std::string emptyJson = core::serializeDspParamListJson({});
+    if (!expectEqual(emptyJson, R"({"params":[]})")) {
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+[[nodiscard]] int runSerialiseErrorTest()
+{
+    const std::string json = core::serializeDspParamErrorJson("not_found");
+    if (!expectEqual(json, R"({"status":"error","reason":"not_found"})")) {
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+} // namespace
+
+int main()
+{
+    if (runParseWriteTest() != EXIT_SUCCESS) {
+        return EXIT_FAILURE;
+    }
+    if (runParseNegativeValueTest() != EXIT_SUCCESS) {
+        return EXIT_FAILURE;
+    }
+    if (runParseMissingFieldTest() != EXIT_SUCCESS) {
+        return EXIT_FAILURE;
+    }
+    if (runParseInvalidJsonTest() != EXIT_SUCCESS) {
+        return EXIT_FAILURE;
+    }
+    if (runSerialiseListTest() != EXIT_SUCCESS) {
+        return EXIT_FAILURE;
+    }
+    if (runSerialiseErrorTest() != EXIT_SUCCESS) {
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}

Software/components/core/test/integration_service_test.cpp

@@ -75,6 +75,12 @@ public:
     {
         return {};
     }
+
+    [[nodiscard]] std::expected<void, core::DspError> writeRawParam(
+        unsigned, float) override
+    {
+        return {};
+    }
 };
 
 class TrackingTuner final : public core::ITuner {