23669027368

Committed 27 Mar 2026 09:50PM UTC coverage: 26.198% (+0.02%) from 26.176%

Build # 23669027368

Build Type

push

github

Committed by

reinder

Commit Message

Merge remote-tracking branch 'origin/master' into cbus

Run Details

11 of 144 new or added lines in 34 files covered. (7.64%)

1 existing line in 1 file now uncovered.

8256 of 31514 relevant lines covered (26.2%)

182.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/server/src/hardware/protocol/withrottle/kernel.cpp

/**
 * server/src/hardware/protocol/withrottle/kernel.cpp
 *
 * This file is part of the traintastic source code.
 *
 * Copyright (C) 2022-2023,2025 Reinder Feenstra
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#include "kernel.hpp"
#include <traintastic/enum/decoderprotocol.hpp>
#include "messages.hpp"
#include "../../decoder/decoder.hpp" // TODO: remove when migrated to Train control
#include "../../interface/interface.hpp"
#include "../../../throttle/hardwarethrottle.hpp"
#include "../../../throttle/throttlecontroller.hpp"
#include "../../../core/eventloop.hpp"
#include "../../../core/method.tpp"
#include "../../../core/objectproperty.tpp"
#include "../../../clock/clock.hpp"
#include "../../../log/log.hpp"
#include "../../../log/logmessageexception.hpp"
#include "../../../train/train.hpp"
#include "../../../train/trainvehiclelist.hpp"
#include "../../../utils/fromchars.hpp"
#include "../../../utils/setthreadname.hpp"
#include "../../../utils/startswith.hpp"

namespace WiThrottle {

struct Address
{
  uint16_t address;
  bool isLong;
  bool isWildcard;

  constexpr bool operator !=(const Address& other) const noexcept
  {
    return
      (address != other.address) ||
      (isLong != other.isLong) ||
      (isWildcard != other.isWildcard);
  }
};

static bool parseAddress(std::string_view& sv, Address& address)
{
  if(sv.empty() || (sv[0] != 'S' && sv[0] != 'L' && sv[0] != '*'))
    return false;

  if(sv[0] == '*')
  {
    address.address = 0;
    address.isLong = false;
    address.isWildcard = true;
    sv = sv.substr(1);
    return true;
  }

  auto r = fromChars(sv.substr(1), address.address);
  if(r.ec != std::errc())
    return false;

  address.isLong = (sv[0] == 'L');
  address.isWildcard = false;
  sv = sv.substr(r.ptr - sv.data());

  return true;
}

static std::string buildName(std::string name, char multiThrottleId)
{
  if(multiThrottleId != Kernel::invalidMultiThrottleId)
  {
    name.append(" [");
    name.push_back(multiThrottleId);
    name.push_back(']');
  }
  return name;
}

Kernel::Kernel(std::string logId_, const Config& config)
  : KernelBase(std::move(logId_))
  , m_config{config}
{
  assert(isEventLoopThread());
}

void Kernel::setConfig(const Config& config)
{
  boost::asio::post(m_ioContext, 
    [this, newConfig=config]()
    {
      m_config = newConfig;
    });
}

void Kernel::setClock(std::shared_ptr<Clock> clock)
{
  assert(isEventLoopThread());
  assert(!m_running);
  assert(clock);
  m_clock = std::move(clock);
}

void Kernel::start()
{
  assert(isEventLoopThread());
  assert(m_ioHandler);
  assert(!m_running);

  m_running = true;

  m_powerOn = TriState::Undefined;

  m_thread = std::thread(
    [this]()
    {
      setThreadName("withrottle");
      boost::asio::executor_work_guard<decltype(m_ioContext.get_executor())> work{m_ioContext.get_executor()};
      m_ioContext.run();
    });

  if(m_clock)
    m_clockChangeConnection = m_clock->onChange.connect(
      [this](Clock::ClockEvent event, uint8_t multiplier, Time time)
      {
        postSendToAll(fastClock((time.hour() * 60U + time.minute()) * 60U, (event == Clock::ClockEvent::Freeze) ? 0 : multiplier));
      });

  boost::asio::post(m_ioContext, 
    [this]()
    {
      try
      {
        m_ioHandler->start();
      }
      catch(const LogMessageException& e)
      {
        EventLoop::call(
          [this, e]()
          {
            Log::log(logId, e.message(), e.args());
            error();
          });
        return;
      }

      started();
    });
}

void Kernel::stop()
{
  assert(isEventLoopThread());

  m_running = false;

  m_clockChangeConnection.disconnect();

  // remove all clients:
  auto itClient = m_clients.begin();
  while(itClient != m_clients.end())
  {
    auto& multiThrottles = itClient->second.multiThrottles;
    auto itMultiThrottle = multiThrottles.begin();
    while(itMultiThrottle != multiThrottles.end())
    {
      itMultiThrottle->second.address = 0; // don't try send a release to the client anymore
      itMultiThrottle->second.throttle->destroy();
      itMultiThrottle = multiThrottles.erase(itMultiThrottle);
    }
    itClient = m_clients.erase(itClient);
  }

  // stop iohandler and kernel thread:
  boost::asio::post(m_ioContext, 
    [this]()
    {
      m_ioHandler->stop();
      m_ioContext.stop();
    });

  m_thread.join();
}

void Kernel::setPowerOn(bool on)
{
  assert(isEventLoopThread());

  boost::asio::post(m_ioContext, 
    [this, on]()
    {
      if(m_powerOn != toTriState(on))
      {
        sendToAll(trackPower(on));
        m_powerOn = toTriState(on);
      }
    });
}

void Kernel::newClient(IOHandler::ClientId clientId)
{
  assert(isKernelThread());
  assert(m_running);

  sendTo(protocolVersion(), clientId);
  sendTo(serverType(), clientId);
  sendTo(serverVersion(), clientId);
  sendTo(rosterList({}), clientId);
  sendTo(trackPower(m_powerOn), clientId);

  EventLoop::call(
    [this, clientId]()
    {
      postSendTo(fastClock((m_clock->hour * 60U + m_clock->minute) * 60U, m_clock->running ? m_clock->multiplier : 0), clientId);

      if(auto* interface = dynamic_cast<Interface*>(m_throttleController))
      {
        auto throttle = HardwareThrottle::create(std::dynamic_pointer_cast<ThrottleController>(interface->shared_ptr<Interface>()), interface->world());
        auto [it, success] = m_clients.emplace(clientId, Client());
        assert(success);
        it->second.multiThrottles.emplace(invalidMultiThrottleId, MultiThrottle{0, false, std::move(throttle)});
      }
    });
}

void Kernel::clientGone(IOHandler::ClientId clientId)
{
  assert(isKernelThread());

  if(!m_running)
    return;

  EventLoop::call(
    [this, clientId]()
    {
      if(auto itClient = m_clients.find(clientId); itClient != m_clients.end())
      {
        for(auto& itMultiThrottle : itClient->second.multiThrottles)
        {
          const auto& throttle = itMultiThrottle.second.throttle;
          if(m_throttleController->removeThrottle(*throttle))
            throttle->destroy();
          else
            assert(false);
        }
        m_clients.erase(itClient);
      }
    });
}

void Kernel::receiveFrom(std::string_view message, IOHandler::ClientId clientId)
{
  assert(isKernelThread());
  assert(m_running);

  if(m_config.debugLogRXTX)
    EventLoop::call(
      [this, clientId, msg=std::string(message)]()
      {
        Log::log(logId, LogMessage::D2005_X_RX_X, clientId, msg);
      });

  if(message[0] == 'M') // Multi throttle command
  {
    if(message.size() >= 3)
    {
      static constexpr std::string_view seperator{"<;>"};

      [[maybe_unused]] const char multiThrottleId = message[1];
      const char command = message[2];
      message = message.substr(3);

      // address
      Address address;
      if(!parseAddress(message, address))
        return;

      // seperator
      if(!startsWith(message, seperator))
        return;
      message = message.substr(seperator.size());

      switch(command)
      {
        case 'A': // action
        {
          const auto throttleCommand = static_cast<ThrottleCommand>(message[0]);
          multiThrottleAction(clientId, multiThrottleId, address, throttleCommand, message.substr(1));
          break;
        }
        case '+': // add locomotive
        case 'S': // steal locomotive
        {
          if(address.isWildcard)
            return;

          Address addressRepeat;
          if(!parseAddress(message, addressRepeat) || !message.empty() || address != addressRepeat)
            return;

          EventLoop::call(
            [this, clientId, multiThrottleId, address, steal=(command == 'S')]()
            {
              const auto& throttle = getThottle(clientId, multiThrottleId);
              if(!throttle)
                return;

              const auto ec = throttle->acquire(address.isLong ? DecoderProtocol::DCCLong : DecoderProtocol::DCCShort, address.address, steal);
              if(!ec)
              {
                if(auto* multiThrottle = getMultiThrottle(clientId, multiThrottleId))
                {
                  multiThrottle->address = address.address;
                  multiThrottle->isLongAddress = address.isLong;
                }
                else
                  assert(false);

                postSendTo(throttleCommand(multiThrottleId, '+', address.address, address.isLong), clientId);

                for(const auto& vehicle : *throttle->train->vehicles)
                {
                  if(vehicle->decoder && vehicle->decoder->address == address.address)
                  {
                    const auto& functions = vehicle->decoder->functions;

                    std::unordered_map<uint32_t, std::string_view> functionNames;
                    for(const auto& f : *functions)
                      functionNames.emplace(f->number.value(), f->name.value());
                    postSendTo(throttleFuctionNames(multiThrottleId, address.address, address.isLong, functionNames), clientId);

                    for(const auto& f : *functions)
                      postSendTo(throttleFunction(multiThrottleId, address.address, address.isLong, f->number, f->value), clientId);

                    break;
                  }
                }

                if(throttle->train->emergencyStop)
                  postSendTo(throttleEstop(multiThrottleId, address.address, address.isLong), clientId);
                else
                  postSendTo(throttleSpeed(multiThrottleId, address.address, address.isLong, std::round(throttle->train->speed.value() / throttle->train->speedMax.getValue(throttle->train->speed.unit()) * speedMax)), clientId);

                postSendTo(throttleDirection(multiThrottleId, address.address, address.isLong, throttle->train->direction), clientId);

                postSendTo(throttleSpeedStepMode(multiThrottleId, address.address, address.isLong, 128), clientId);
              }
              else
              {
                postSendTo(alert(ec.message()), clientId);
              }
            });

          break;
        }
        case '-':
        {
          EventLoop::call(
            [this, clientId, multiThrottleId, address]()
            {
              auto* multiThrottle = getMultiThrottle(clientId, multiThrottleId);
              if(multiThrottle && (address.isWildcard || (address.address == multiThrottle->address && address.isLong == multiThrottle->isLongAddress)))
              {
                multiThrottle->address = 0; // set address to zero so the release callback doesn't sent a release to.
                assert(multiThrottle->throttle);
                multiThrottle->throttle->release(false);

                // confirm release:
                // - WiThrottle needs this, else it won't release it.
                postSendTo(throttleRelease(multiThrottleId, address.address, address.isLong), clientId);
              }
            });
          break;
        }
      }
    }
  }
  else if(message == trackPowerOff() || message == trackPowerOn())
  {
    sendTo(alert("Track power control isn't allowed."), clientId);
    sendTo(trackPower(m_powerOn), clientId); // notify about current state
  }
  else if(message[0] == 'N') // throttle name
  {
    EventLoop::call(
      [this, clientId, name=std::string(message.substr(1))]()
      {
        if(auto itClient = m_clients.find(clientId); itClient != m_clients.end())
        {
          itClient->second.name = name;
          for(auto& itMultiThrottle : itClient->second.multiThrottles)
            itMultiThrottle.second.throttle->name.setValueInternal(buildName(name, itMultiThrottle.first));
        }
      });
  }
  else if(startsWith(message, "HU")) // throttle id
  {
    EventLoop::call(
      [this, clientId, id=std::string(message.substr(2))]()
      {
        if(auto itClient = m_clients.find(clientId); itClient != m_clients.end())
        {
          itClient->second.id = id;
        }
      });
  }
  else if(message == quit())
  {
    // post disconnect to finish current callback
    boost::asio::post(m_ioContext, 
      [this, clientId]()
      {
        m_ioHandler->disconnect(clientId);
      });
  }
}

void Kernel::setIOHandler(std::unique_ptr<IOHandler> handler)
{
  assert(isEventLoopThread());
  assert(handler);
  assert(!m_ioHandler);
  m_ioHandler = std::move(handler);
}

void Kernel::sendTo(std::string_view message, IOHandler::ClientId clientId)
{
  assert(isKernelThread());

  if(m_ioHandler->sendTo(message, clientId))
  {
    if(m_config.debugLogRXTX)
      EventLoop::call(
        [this, clientId, msg=std::string(message)]()
        {
          Log::log(logId, LogMessage::D2004_X_TX_X, clientId, msg);
        });
  }
}

void Kernel::sendToAll(std::string_view message)
{
  assert(isKernelThread());

  if(m_ioHandler->hasClients() && m_ioHandler->sendToAll(message))
  {
    if(m_config.debugLogRXTX)
      EventLoop::call(
        [this, msg=std::string(message)]()
        {
          Log::log(logId, LogMessage::D2001_TX_X, msg);
        });
  }
}

Kernel::MultiThrottle* Kernel::getMultiThrottle(IOHandler::ClientId clientId, char multiThrottleId)
{
  assert(isEventLoopThread());

  if(auto itClient = m_clients.find(clientId); itClient != m_clients.end())
  {
    auto& multiThrottles = itClient->second.multiThrottles;
    if(auto itMultiThrottle = multiThrottles.find(multiThrottleId); itMultiThrottle != multiThrottles.end())
      return &itMultiThrottle->second;
  }

  return nullptr;
}

const std::shared_ptr<HardwareThrottle>& Kernel::getThottle(IOHandler::ClientId clientId, char multiThrottleId)
{
  assert(isEventLoopThread());

  static const std::shared_ptr<HardwareThrottle> noThrottle;

  if(auto itClient = m_clients.find(clientId); itClient != m_clients.end())
  {
    auto& multiThrottles = itClient->second.multiThrottles;

    // check for multi throttle id:
    auto itMultiThrottle = multiThrottles.find(multiThrottleId);
    if(itMultiThrottle != multiThrottles.end())
      return itMultiThrottle->second.throttle;

    // check for invalid multi throttle id (multi throttle id is unknown until first throttle command):
    itMultiThrottle = multiThrottles.find(invalidMultiThrottleId);
    if(itMultiThrottle != multiThrottles.end())
    {
      auto n = multiThrottles.extract(invalidMultiThrottleId);
      n.key() = multiThrottleId;
      auto it = multiThrottles.insert(std::move(n)).position;
      const auto& throttle = it->second.throttle;
      throttle->name.setValueInternal(buildName(itClient->second.name, multiThrottleId));
      throttle->onRelease.connect(std::bind_front(&Kernel::throttleReleased, this, clientId, multiThrottleId));
      return throttle;
    }

    // create a new throttle:
    if(auto* interface = dynamic_cast<Interface*>(m_throttleController))
    {
      auto newThrottle = HardwareThrottle::create(std::dynamic_pointer_cast<ThrottleController>(interface->shared_ptr<Interface>()), interface->world());
      auto [it, success] = multiThrottles.emplace(multiThrottleId, MultiThrottle{0, false, std::move(newThrottle)});
      assert(success);
      const auto& throttle = it->second.throttle;
      throttle->name.setValueInternal(buildName(itClient->second.name, multiThrottleId));
      throttle->onRelease.connect(std::bind_front(&Kernel::throttleReleased, this, clientId, multiThrottleId));
      return throttle;
    }
  }

  return noThrottle;
}

const std::shared_ptr<Decoder>& Kernel::getDecoder(IOHandler::ClientId clientId, char multiThrottleId)
{
  assert(isEventLoopThread());

  static const std::shared_ptr<Decoder> noDecoder;

  const auto* multiThrottle = getMultiThrottle(clientId, multiThrottleId);

  if(multiThrottle && multiThrottle->throttle->acquired())
  {
    for(const auto& vehicle : *multiThrottle->throttle->train->vehicles)
    {
      if(vehicle->decoder && vehicle->decoder->address == multiThrottle->address)
      {
        return vehicle->decoder.value();
      }
    }
  }

  return noDecoder;
}

void Kernel::multiThrottleAction(IOHandler::ClientId clientId, char multiThrottleId, const Address& /*address*/, ThrottleCommand throttleCommand, std::string_view message)
{
  assert(isKernelThread());

  switch(throttleCommand)
  {
    case ThrottleCommand::SetSpeed:
    {
      int value;
      auto r = fromChars(message, value);
      if(r.ec == std::errc() && value <= speedMax)
      {
        EventLoop::call(
          [this, clientId, multiThrottleId, value]()
          {
            if(const auto& throttle = getThottle(clientId, multiThrottleId); throttle && throttle->acquired())
            {
              if(value < 0)
              {
                throttle->emergencyStop();
              }
              else
              {
                throttle->setSpeed(throttle->train->speedMax.value() * value / speedMax, throttle->train->speedMax.unit());
              }
            }
          });
      }
      break;
    }
    case ThrottleCommand::SetDirection:
    {
      int value;
      auto r = fromChars(message, value);
      if(r.ec == std::errc())
      {
        EventLoop::call(
          [this, clientId, multiThrottleId, value]()
          {
            if(const auto& throttle = getThottle(clientId, multiThrottleId); throttle && throttle->acquired())
            {
              throttle->setDirection((value == 0) ? Direction::Reverse : Direction::Forward);
            }
          });
      }
      break;
    }
    case ThrottleCommand::Function:
    case ThrottleCommand::ForceFunction:
    {
      const bool value = message[0] != '0';
      uint32_t number;
      auto r = fromChars(message.substr(1), number);
      if(r.ec == std::errc())
      {
        EventLoop::call(
          [this, clientId, multiThrottleId, number, force=(throttleCommand == ThrottleCommand::ForceFunction), value]()
          {
            if(const auto& decoder = getDecoder(clientId, multiThrottleId))
            {
              if(const auto& function = decoder->getFunction(number))
              {
                if(force) // set
                {
                  function->value = value;
                }
                else if(value) // press
                {
                  switch(function->type.value())
                  {
                    case DecoderFunctionType::Hold:
                    case DecoderFunctionType::Momentary:
                      function->value = false;
                      break;

                    case DecoderFunctionType::OnOff:
                      // toggle when button is pushed, do nothing on release
                      function->value = !function->value;
                      break;

                    case DecoderFunctionType::AlwaysOff:
                    case DecoderFunctionType::AlwaysOn:
                      break; // do nothing
                  }
                }
                else // release
                {
                  switch(function->type.value())
                  {
                    case DecoderFunctionType::Hold:
                    case DecoderFunctionType::Momentary:
                      function->value = false;
                      break;

                    case DecoderFunctionType::OnOff:
                    case DecoderFunctionType::AlwaysOff:
                    case DecoderFunctionType::AlwaysOn:
                      break; // do nothing
                  }
                }
              }
            }
          });
      }
      break;
    }
    case ThrottleCommand::Idle:
      EventLoop::call(
        [this, clientId, multiThrottleId]()
        {
          if(const auto& throttle = getThottle(clientId, multiThrottleId); throttle && throttle->acquired())
          {
            throttle->setSpeed(0.0, throttle->train->speed.unit());
          }
        });
      break;

    case ThrottleCommand::EmergencyStop:
      EventLoop::call(
        [this, clientId, multiThrottleId]()
        {
          if(const auto& throttle = getThottle(clientId, multiThrottleId); throttle && throttle->acquired())
          {
            throttle->emergencyStop();
          }
        });
      break;

    case ThrottleCommand::Query:
      if(message.size() == 1)
      {
        switch(message[0])
        {
          case 'V': // speed
            EventLoop::call(
              [this, clientId, multiThrottleId]()
              {
                if(const auto* multiThrottle = getMultiThrottle(clientId, multiThrottleId))
                {
                  const auto& train = *multiThrottle->throttle->train;
                  if(train.emergencyStop)
                    postSendTo(throttleEstop(multiThrottleId, multiThrottle->address, multiThrottle->isLongAddress), clientId);
                  else
                    postSendTo(throttleSpeed(multiThrottleId, multiThrottle->address, multiThrottle->isLongAddress, std::round(train.speed.value() / train.speedMax.getValue(train.speed.unit()) * speedMax)), clientId);
                }
              });
            break;

          case 'R': // direction
            EventLoop::call(
              [this, clientId, multiThrottleId]()
              {
                if(const auto* multiThrottle = getMultiThrottle(clientId, multiThrottleId))
                {
                  postSendTo(throttleDirection(multiThrottleId, multiThrottle->address, multiThrottle->isLongAddress, multiThrottle->throttle->train->direction), clientId);
                }
              });
            break;
        }
      }
      break;

    case ThrottleCommand::Consist:
    case ThrottleCommand::ConsistLeadFromRosterEntry:
    case ThrottleCommand::Dispatch:
    case ThrottleCommand::SetAddressFromRosterEntry:
    case ThrottleCommand::SetLongAddress:
    case ThrottleCommand::MomentaryFunction:
    case ThrottleCommand::Quit:
    case ThrottleCommand::Release:
    case ThrottleCommand::SetShortAddress:
    case ThrottleCommand::SetSpeedStepMode:
      // unsupported
      break;
  }
}

void Kernel::throttleReleased(IOHandler::ClientId clientId, char multiThrottleId, const std::shared_ptr<Throttle>& /*throttle*/)
{
  assert(isEventLoopThread());

  const auto* multiThrottle = getMultiThrottle(clientId, multiThrottleId);
  if(multiThrottle && multiThrottle->address != 0)
    postSendTo(throttleRelease(multiThrottleId, multiThrottle->address, multiThrottle->isLongAddress), clientId);
}

}

traintastic / traintastic / 23669027368

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous