gateway/apps/gateway/main/app_main.cpp

#include "dali_domain.hpp"
#include "gateway_ble.hpp"
#include "gateway_controller.hpp"
#include "gateway_core.hpp"
#include "gateway_runtime.hpp"

#include "sdkconfig.h"

#include <cstdio>
#include <memory>

#ifndef CONFIG_GATEWAY_CHANNEL_COUNT
#define CONFIG_GATEWAY_CHANNEL_COUNT 2
#endif

namespace {
constexpr const char* kProjectName = "DALI_485_Gateway";
constexpr const char* kProjectVersion = "0.1.0";

std::unique_ptr<gateway::DaliDomainService> s_dali_domain;
std::unique_ptr<gateway::GatewayRuntime> s_runtime;
std::unique_ptr<gateway::GatewayController> s_controller;
std::unique_ptr<gateway::GatewayBleBridge> s_ble_bridge;

[[maybe_unused]] void LogBindError(const char* channel_name, esp_err_t err) {
  if (err != ESP_OK) {
    std::printf("gateway_main: failed to bind %s err=%d\n", channel_name, err);
  }
}

void BindConfiguredChannels(gateway::DaliDomainService& dali_domain,
                            const gateway::GatewayRuntime& runtime) {
#if CONFIG_GATEWAY_CHANNEL1_PHY_NATIVE
  gateway::DaliHardwareBusConfig channel1{};
  channel1.channel_index = 0;
  channel1.gateway_id = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL1_GW_ID);
  channel1.bus_id = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL1_NATIVE_BUS_ID);
  channel1.tx_pin = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL1_NATIVE_TX_PIN);
  channel1.rx_pin = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL1_NATIVE_RX_PIN);
  channel1.baudrate = static_cast<uint32_t>(CONFIG_GATEWAY_CHANNEL1_NATIVE_BAUDRATE);
  channel1.name = runtime.gatewayName(channel1.gateway_id);
  LogBindError("channel1 native DALI", dali_domain.bindHardwareBus(channel1));
#elif CONFIG_GATEWAY_CHANNEL1_PHY_UART1 || CONFIG_GATEWAY_CHANNEL1_PHY_UART2
  gateway::DaliSerialBusConfig channel1{};
  channel1.channel_index = 0;
  channel1.gateway_id = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL1_GW_ID);
#if CONFIG_GATEWAY_CHANNEL1_PHY_UART1
  channel1.uart_port = 1;
#else
  channel1.uart_port = 2;
#endif
  channel1.tx_pin = CONFIG_GATEWAY_CHANNEL1_SERIAL_TX_PIN;
  channel1.rx_pin = CONFIG_GATEWAY_CHANNEL1_SERIAL_RX_PIN;
  channel1.baudrate = static_cast<uint32_t>(CONFIG_GATEWAY_CHANNEL1_SERIAL_BAUDRATE);
  channel1.rx_buffer_size = static_cast<size_t>(CONFIG_GATEWAY_CHANNEL1_SERIAL_RX_BUFFER);
  channel1.tx_buffer_size = static_cast<size_t>(CONFIG_GATEWAY_CHANNEL1_SERIAL_RX_BUFFER);
  channel1.name = runtime.gatewayName(channel1.gateway_id);
  LogBindError("channel1 serial DALI", dali_domain.bindSerialBus(channel1));
#endif

#if CONFIG_GATEWAY_CHANNEL_COUNT >= 2
#if CONFIG_GATEWAY_CHANNEL2_PHY_NATIVE
  gateway::DaliHardwareBusConfig channel2{};
  channel2.channel_index = 1;
  channel2.gateway_id = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL2_GW_ID);
  channel2.bus_id = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL2_NATIVE_BUS_ID);
  channel2.tx_pin = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL2_NATIVE_TX_PIN);
  channel2.rx_pin = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL2_NATIVE_RX_PIN);
  channel2.baudrate = static_cast<uint32_t>(CONFIG_GATEWAY_CHANNEL2_NATIVE_BAUDRATE);
  channel2.name = runtime.gatewayName(channel2.gateway_id);
  LogBindError("channel2 native DALI", dali_domain.bindHardwareBus(channel2));
#elif CONFIG_GATEWAY_CHANNEL2_PHY_UART1 || CONFIG_GATEWAY_CHANNEL2_PHY_UART2
  gateway::DaliSerialBusConfig channel2{};
  channel2.channel_index = 1;
  channel2.gateway_id = static_cast<uint8_t>(CONFIG_GATEWAY_CHANNEL2_GW_ID);
#if CONFIG_GATEWAY_CHANNEL2_PHY_UART1
  channel2.uart_port = 1;
#else
  channel2.uart_port = 2;
#endif
  channel2.tx_pin = CONFIG_GATEWAY_CHANNEL2_SERIAL_TX_PIN;
  channel2.rx_pin = CONFIG_GATEWAY_CHANNEL2_SERIAL_RX_PIN;
  channel2.baudrate = static_cast<uint32_t>(CONFIG_GATEWAY_CHANNEL2_SERIAL_BAUDRATE);
  channel2.rx_buffer_size = static_cast<size_t>(CONFIG_GATEWAY_CHANNEL2_SERIAL_RX_BUFFER);
  channel2.tx_buffer_size = static_cast<size_t>(CONFIG_GATEWAY_CHANNEL2_SERIAL_RX_BUFFER);
  channel2.name = runtime.gatewayName(channel2.gateway_id);
  LogBindError("channel2 serial DALI", dali_domain.bindSerialBus(channel2));
#endif
#endif
}

}  // namespace

extern "C" void app_main(void) {
  ESP_ERROR_CHECK(gateway::InitializeRuntimeNvs());

  const gateway::BootProfile profile{
      gateway::AppRole::kGateway,
      "gateway",
      true,
      true,
      true,
      true,
      true,
  };

  gateway::GatewayCore core(profile);
  core.start();

  s_dali_domain = std::make_unique<gateway::DaliDomainService>();
  s_runtime = std::make_unique<gateway::GatewayRuntime>(
    profile,
    gateway::GatewayRuntimeConfig{
      kProjectName,
      kProjectVersion,
      gateway::ReadRuntimeSerialId(),
    },
    s_dali_domain.get());
  ESP_ERROR_CHECK(s_runtime->start());
  s_runtime->setGatewayCount(CONFIG_GATEWAY_CHANNEL_COUNT);
  BindConfiguredChannels(*s_dali_domain, *s_runtime);

  gateway::GatewayControllerConfig controller_config;
  controller_config.setup_supported = true;
  controller_config.ble_supported = profile.enable_ble;
  controller_config.wifi_supported = profile.enable_wifi;
  controller_config.ip_router_supported = profile.enable_wifi || profile.enable_eth;
  controller_config.internal_scene_supported = true;
  controller_config.internal_group_supported = true;

  s_controller = std::make_unique<gateway::GatewayController>(*s_runtime, *s_dali_domain,
                                                              controller_config);
  ESP_ERROR_CHECK(s_controller->start());

  if (profile.enable_ble) {
    s_ble_bridge = std::make_unique<gateway::GatewayBleBridge>(*s_controller, *s_runtime,
                                                               *s_dali_domain);
    ESP_ERROR_CHECK(s_ble_bridge->start());
  }

  const auto device_info = s_runtime->deviceInfo();
  std::printf("gateway_main: dali domain implementation=%s bound=%d channels=%u\n",
              s_dali_domain->implementationName(), s_dali_domain->isBound(),
              static_cast<unsigned>(s_dali_domain->channelCount()));
  for (const auto& channel : s_dali_domain->channelInfo()) {
    std::printf("gateway_main: channel=%u gateway=%u name=%s\n", channel.channel_index,
                channel.gateway_id, channel.name.c_str());
  }
  std::printf("gateway_main: runtime device type=%s serial=%s project=%s version=%s\n",
              device_info.type.c_str(), device_info.serial_id.c_str(),
              device_info.project.c_str(), device_info.version.c_str());
}