traintastic/traintastic | Build 26121453997 | server/src/hardware/protocol/cbus/cbuskernel.cpp | Coveralls

45

constexpr uint16_t makeAddressKey(uint16_t address, bool longAddress)

×

47

  return longAddress ? (0xC000 | (address & 0x3FFF)) : (address & 0x7F);

×

50

constexpr CBUS::SetEngineSessionMode::SpeedMode toSpeedMode(uint8_t speedSteps)

×

54

  switch(speedSteps)

×

56

    case 14:

×

57

      return SpeedMode14;

×

59

    case 28:

×

60

      return SpeedMode28;

×

62

    default:

×

63

      return SpeedMode128;

×

71

Kernel::Kernel(std::string logId_, const Config& config, uint8_t canId, bool simulation)

×

72

  : KernelBase(std::move(logId_))

×

73

  , m_canId{canId}

×

74

  , m_simulation{simulation}

×

75

  , m_initializationTimer{ioContext()}

×

76

  , m_config{config}

×

77

  , m_engineKeepAliveTimer{ioContext()}

×

78

  , m_dccAccessoryTimer{ioContext()}

×

80

  assert(isEventLoopThread());

×

81

×

83

void Kernel::setConfig(const Config& config)

×

85

  assert(isEventLoopThread());

×

87

  boost::asio::post(m_ioContext,

×

88

    [this, newConfig=config]()

×

90

      m_config = newConfig;

×

91

});

×

92

×

94

void Kernel::setRequestEventsDuringInitialize(std::vector<uint16_t> shortEvents, std::vector<std::pair<uint16_t,uint16_t>> longEvents)

×

96

  assert(isEventLoopThread());

×

98

  std::reverse(shortEvents.begin(), shortEvents.end());

×

99

  std::reverse(longEvents.begin(), longEvents.end());

×

101

  m_initializationRequestShortEvents = std::move(shortEvents);

×

102

  m_initializationRequestLongEvents = std::move(longEvents);

×

103

×

105

void Kernel::start()

×

107

  assert(isEventLoopThread());

×

108

  assert(m_ioHandler);

×

110

  m_thread = std::thread(

×

111

    [this]()

×

113

      setThreadName("cbus");

×

114

      auto work = std::make_shared<boost::asio::io_context::work>(m_ioContext);

×

115

      m_ioContext.run();

×

116

});

×

118

  boost::asio::post(m_ioContext,

×

119

    [this]()

×

123

        m_ioHandler->onReceive =

×

124

          [this](const CAN::Message& canMessage)

×

126

            receive(canMessage);

×

127

            if(m_hub)

×

129

              m_hub->send(canMessage);

×

131

};

×

133

        m_ioHandler->start();

×

135

        if(m_config.hubEnabled)

×

137

          m_hub = std::make_shared<IOHub>(m_ioContext, logId, m_config.hubLocalhostOnly, m_config.hubPort);

×

138

          m_hub->start(

×

139

            [this](const CAN::Message& message)

×

141

              receive(message);

×

142

              (void)m_ioHandler->send(message); // FICME: add error handling

×

143

});

×

146

      catch(const LogMessageException& e)

×

148

        EventLoop::call(

×

149

          [this, e]()

×

151

            Log::log(logId, e.message(), e.args());

×

152

            error();

×

153

});

×

154

        return;

×

155

×

157

×

159

void Kernel::stop()

×

161

  assert(isEventLoopThread());

×

163

  boost::asio::post(m_ioContext,

×

164

    [this]()

×

166

      if(m_hub)

×

168

        m_hub->stop();

×

170

      m_ioHandler->stop();

×

172

      m_ioContext.stop();

×

173

});

×

175

  m_thread.join();

×

176

×

178

void Kernel::started()

×

180

  assert(isKernelThread());

×

182

  nextState();

×

183

×

185

void Kernel::receive(const CAN::Message& canMessage)

×

187

  assert(isKernelThread());

×

189

  const auto canId = getCanId(canMessage);

×

190

  const auto& message = asMessage(canMessage);

×

192

  if(m_config.debugLogRXTX)

×

194

    EventLoop::call(

×

195

      [this, msg=toString(message)]()

×

197

        Log::log(logId, LogMessage::D2002_RX_X, msg);

×

198

});

×

201

  switch(message.opCode)

×

203

    case OpCode::TOF:

×

204

      m_trackOn = false;

×

205

      if(onTrackOff) [[likely]]

×

207

        EventLoop::call(onTrackOff);

×

209

      break;

×

211

    case OpCode::TON:

×

212

      m_trackOn = true;

×

213

      if(onTrackOn) [[likely]]

×

215

        EventLoop::call(onTrackOn);

×

217

      break;

×

219

    case OpCode::ESTOP:

×

220

      if(onEmergencyStop) [[likely]]

×

222

        EventLoop::call(onEmergencyStop);

×

224

      break;

×

226

    case OpCode::KLOC:

×

227

      receiveKLOC(static_cast<const ReleaseEngine&>(message));

×

228

      break;

×

230

    case OpCode::RLOC:

×

232

      const auto rloc = static_cast<const RequestEngineSession&>(message);

×

UNCOV

233

      receiveGLOC(rloc.address(), rloc.isLongAddress(), GetEngineSession::Mode::Request);

×

234

      break;

×

236

    case OpCode::GLOC:

×

UNCOV

238

      const auto gloc = static_cast<const GetEngineSession&>(message);

×

239

      receiveGLOC(gloc.address(), gloc.isLongAddress(), gloc.mode());

×

240

      break;

×

UNCOV

242

    case OpCode::DSPD:

×

243

      receiveDSPD(static_cast<const SetEngineSpeedDirection&>(message));

×

244

      break;

×

UNCOV

246

    case OpCode::DFNON:

×

248

      receiveDFNOx(static_cast<const SetEngineFunction&>(message));

×

249

      break;

×

251

    case OpCode::DFUN:

×

UNCOV

252

      receiveDFUN(static_cast<const SetEngineFunctions&>(message));

×

253

      break;

×

255

    case OpCode::ASON:

×

256

      receiveShortEvent(static_cast<const AccessoryShortOn&>(message).deviceNumber(), true);

×

UNCOV

257

      break;

×

259

    case OpCode::ASOF:

×

UNCOV

260

      receiveShortEvent(static_cast<const AccessoryShortOff&>(message).deviceNumber(), false);

×

261

      break;

×

263

    case OpCode::ARSON:

×

265

      const auto eventNumber = static_cast<const AccessoryShortResponseEventOff&>(message).deviceNumber();

×

266

      receiveShortEvent(eventNumber, true);

×

267

      if(m_state == State::RequestShortEvents &&

×

268

          m_initializationRequestShortEvents.back() == eventNumber)

×

270

        m_initializationRequestShortEvents.pop_back();

×

271

        requestShortEvent();

×

273

      break;

×

275

    case OpCode::ARSOF:

×

277

      const auto eventNumber = static_cast<const AccessoryShortResponseEventOff&>(message).deviceNumber();

×

UNCOV

278

      receiveShortEvent(eventNumber, false);

×

UNCOV

279

      if(m_state == State::RequestShortEvents &&

×

UNCOV

280

          m_initializationRequestShortEvents.back() == eventNumber)

×

UNCOV

282

        m_initializationRequestShortEvents.pop_back();

×

283

        requestShortEvent();

×

285

      break;

×

287

    case OpCode::ERR:

×

UNCOV

289

      switch(static_cast<const CommandStationErrorMessage&>(message).errorCode)

×

293

        case LocoStackFull:

×

UNCOV

295

          const auto& err = static_cast<const CommandStationLocoStackFullError&>(message);

×

296

          const auto key = makeAddressKey(err.address(), err.isLongAddress());

×

297

          if(m_engineGLOCs.contains(key))

×

299

            m_engineGLOCs.erase(key);

×

UNCOV

302

          break;

×

UNCOV

304

        case SessionCancelled:

×

UNCOV

305

          if(auto it = std::find_if(m_engines.begin(), m_engines.end(),

×

306

            [session=static_cast<const CommandStationSessionCancelled&>(message).session()](const auto& item)

×

UNCOV

308

              return item.second.session && *item.second.session == session;

×

309

            }); it != m_engines.end())

×

311

            it->second.session = std::nullopt;

×

313

            if(m_engineKeepAliveTimerActive && m_engineKeepAliveSession == *it->second.session)

×

315

              restartEngineKeepAliveTimer();

×

UNCOV

318

            EventLoop::call(

×

UNCOV

319

              [this, key=it->first]()

×

UNCOV

321

                if(onEngineSessionCancelled) [[likely]]

×

323

                  onEngineSessionCancelled(key & 0x3FFF, (key & 0xC000) == 0xC000);

×

325

});

×

327

          break;

×

329

        case LocoAddressTaken:

×

335

          break;

×

337

      break;

×

339

    case OpCode::ACON:

×

341

      const auto& acon = static_cast<const AccessoryOn&>(message);

×

342

      receiveLongEvent(acon.nodeNumber(), acon.eventNumber(), true);

×

343

      break;

×

345

    case OpCode::ACOF:

×

347

      const auto& acof = static_cast<const AccessoryOff&>(message);

×

348

      receiveLongEvent(acof.nodeNumber(), acof.eventNumber(), false);

×

UNCOV

349

      break;

×

UNCOV

351

    case OpCode::ARON:

×

UNCOV

353

      const auto& aron = static_cast<const AccessoryResponseEventOn&>(message);

×

354

      receiveLongEvent(aron.nodeNumber(), aron.eventNumber(), true);

×

355

      if(m_state == State::RequestShortEvents &&

×

356

          m_initializationRequestLongEvents.back().first == aron.nodeNumber() &&

×

357

          m_initializationRequestLongEvents.back().second == aron.eventNumber())

×

UNCOV

359

        m_initializationRequestLongEvents.pop_back();

×

360

        requestLongEvent();

×

UNCOV

362

      break;

×

UNCOV

364

    case OpCode::AROF:

×

366

      const auto& arof = static_cast<const AccessoryResponseEventOff&>(message);

×

UNCOV

367

      receiveLongEvent(arof.nodeNumber(), arof.eventNumber(), false);

×

368

      if(m_state == State::RequestShortEvents &&

×

369

          m_initializationRequestLongEvents.back().first == arof.nodeNumber() &&

×

UNCOV

370

          m_initializationRequestLongEvents.back().second == arof.eventNumber())

×

UNCOV

372

        m_initializationRequestLongEvents.pop_back();

×

373

        requestLongEvent();

×

UNCOV

375

      break;

×

377

    case OpCode::PARAN:

×

UNCOV

378

      if(m_state == State::ReadNodeParameters && !m_readNodeParameters.empty())

×

UNCOV

380

        const auto& rqnpn = m_readNodeParameters.front();

×

381

        const auto& paran = static_cast<const NodeParameterResponse&>(message);

×

383

        if(rqnpn.nodeNumber() == paran.nodeNumber() && rqnpn.parameter == paran.parameter)

×

385

          m_readNodeParameters.pop();

×

UNCOV

386

          m_initializationTimer.cancel();

×

388

          EventLoop::call(

×

UNCOV

389

            [this, canId, paran]()

×

391

              if(onNodeParameterResponse) [[likely]]

×

393

                onNodeParameterResponse(canId, paran.nodeNumber(), paran.parameter, paran.value);

×

395

});

×

397

          readNodeParameter();

×

UNCOV

400

      break;

×

402

    case OpCode::PNN:

×

UNCOV

403

      if(m_state == State::QueryNodes)

×

UNCOV

405

        restartInitializationTimer(queryNodeNumberTimeout);

×

UNCOV

407

        const auto& pnn = static_cast<const PresenceOfNode&>(message);

×

UNCOV

409

        m_readNodeParameters.emplace(ReadNodeParameter(pnn.nodeNumber(), NodeParameter::VersionMajor));

×

410

        m_readNodeParameters.emplace(ReadNodeParameter(pnn.nodeNumber(), NodeParameter::VersionMinor));

×

UNCOV

411

        m_readNodeParameters.emplace(ReadNodeParameter(pnn.nodeNumber(), NodeParameter::BetaReleaseCode));

×

UNCOV

413

        EventLoop::call(

×

414

          [this, canId, pnn]()

×

416

            if(onPresenceOfNode) [[likely]]

×

UNCOV

418

              onPresenceOfNode(canId, pnn.nodeNumber(), pnn.manufacturerId, pnn.moduleId, pnn.flimMode(), pnn.supportsServiceDiscovery());

×

UNCOV

420

});

×

UNCOV

422

      break;

×

UNCOV

424

    case OpCode::PLOC:

×

426

      const auto& ploc = static_cast<const EngineReport&>(message);

×

UNCOV

427

      const auto key = makeAddressKey(ploc.address(), ploc.isLongAddress());

×

428

      auto gloc = m_engineGLOCs.find(key);

×

UNCOV

429

      const auto owner = (gloc != m_engineGLOCs.end()) ? gloc->second : Owner::CBUS;

×

UNCOV

431

      EventLoop::call(

×

432

        [this, ploc, owner]()

×

UNCOV

434

          if(onEngineSessionAcquire) [[likely]]

×

436

            onEngineSessionAcquire(ploc.session, owner != Owner::Traintastic, ploc.address(), ploc.isLongAddress());

×

438

});

×

440

      if(auto it = m_engines.find(key); it != m_engines.end())

×

UNCOV

442

        auto& engine = it->second;

×

443

        engine.session = ploc.session;

×

UNCOV

444

        engine.owner = owner;

×

UNCOV

446

        if(engine.owner == Owner::Traintastic)

×

UNCOV

448

          sendSetEngineSessionMode(ploc.session, engine.speedSteps);

×

UNCOV

449

          sendSetEngineSpeedDirection(ploc.session, engine.speed, engine.directionForward);

×

UNCOV

451

          for(const auto& [number, value] : engine.functions)

×

UNCOV

453

            sendSetEngineFunction(ploc.session, number, value);

×

UNCOV

456

          engine.lastCommand = std::chrono::steady_clock::now();

×

458

          if(!m_engineKeepAliveTimerActive)

×

460

            restartEngineKeepAliveTimer();

×

463

        else if(engine.owner == Owner::CBUS)

×

465

          engine.speed = ploc.speed();

×

466

          engine.directionForward = ploc.directionForward();

×

UNCOV

468

          EventLoop::call(

×

UNCOV

469

            [this, session=*engine.session, speed=engine.speed, directionForward=engine.directionForward]()

×

UNCOV

471

              if(onEngineSpeedDirectionChanged) [[likely]]

×

UNCOV

473

                onEngineSpeedDirectionChanged(session, speed, directionForward);

×

475

});

×

477

          for(uint8_t fn : ploc.numbers())

×

UNCOV

479

            engine.functions[fn] = ploc.f(fn);

×

480

            EventLoop::call(

×

UNCOV

481

              [this, session=*engine.session, number=fn, value=engine.functions[fn]]()

×

UNCOV

483

                if(onEngineFunctionChanged) [[likely]]

×

485

                  onEngineFunctionChanged(session, number, value);

×

487

});

×

491

      else if(owner == Owner::Traintastic) // we're no longer in need of control (rare but possible)

×

493

        send(ReleaseEngine(ploc.session));

×

UNCOV

496

      if(gloc != m_engineGLOCs.end())

×

498

        m_engineGLOCs.erase(gloc);

×

500

      break;

×

UNCOV

502

    case OpCode::STAT:

×

503

      if(m_state == State::GetCommandStationStatus)

×

UNCOV

505

        m_initializationTimer.cancel();

×

506

        nextState();

×

508

      break;

×

510

    default:

×

UNCOV

511

      break;

×

515

  for(const auto& [handle, opCode] : m_onReceiveFilters)

×

517

    if(message.opCode == opCode)

×

519

      auto buffer = std::make_shared<std::byte[]>(message.size());

×

UNCOV

520

      std::memcpy(buffer.get(), &message, message.size());

×

521

      EventLoop::call(

×

UNCOV

522

        [this, handle, canId, data=std::move(buffer)]()

×

UNCOV

525

          if(auto it = m_onReceiveCallbacks.find(handle); it != m_onReceiveCallbacks.end())

×

UNCOV

527

            it->second(canId, *reinterpret_cast<const Message*>(data.get()));

×

UNCOV

529

});

×

530

×

UNCOV

532

×

UNCOV

534

size_t Kernel::registerOnReceive(OpCode opCode, std::function<void(uint8_t, const Message&)> callback)

×

UNCOV

536

  assert(isEventLoopThread());

×

538

  while(++m_onReceiveHandle == 0);

×

540

  m_onReceiveCallbacks.emplace(m_onReceiveHandle, std::move(callback));

×

542

  m_ioContext.post(

×

UNCOV

543

    [this, handle=m_onReceiveHandle, opCode]()

×

545

      m_onReceiveFilters.emplace(handle, opCode);

×

UNCOV

546

});

×

UNCOV

548

  return m_onReceiveHandle;

×

551

void Kernel::unregisterOnReceive(size_t handle)

×

UNCOV

553

  assert(isEventLoopThread());

×

555

  m_onReceiveCallbacks.erase(handle);

×

UNCOV

557

  m_ioContext.post(

×

558

    [this, handle]()

×

560

      m_onReceiveFilters.erase(handle);

×

UNCOV

561

});

×

562

×

564

void Kernel::trackOff()

×

UNCOV

566

  assert(isEventLoopThread());

×

568

  boost::asio::post(m_ioContext,

×

569

    [this]()

×

571

      if(m_trackOn)

×

573

        send(RequestTrackOff());

×

575

});

×

UNCOV

576

×

UNCOV

578

void Kernel::trackOn()

×

UNCOV

580

  assert(isEventLoopThread());

×

UNCOV

582

  boost::asio::post(m_ioContext,

×

583

    [this]()

×

585

      if(!m_trackOn)

×

UNCOV

587

        send(RequestTrackOn());

×

UNCOV

589

});

×

590

×

592

void Kernel::requestEmergencyStop()

×

UNCOV

594

  assert(isEventLoopThread());

×

UNCOV

596

  boost::asio::post(m_ioContext,

×

597

    [this]()

×

599

      send(RequestEmergencyStop());

×

600

});

×

UNCOV

601

×

603

void Kernel::setEngineSpeedDirection(uint16_t address, bool longAddress, uint8_t speedStep, uint8_t speedSteps, bool eStop, bool directionForward)

×

UNCOV

605

  assert(isEventLoopThread());

×

UNCOV

607

  const uint8_t speed = eStop ? 1 : (speedStep > 0 ? speedStep + 1 : 0);

×

UNCOV

609

  boost::asio::post(m_ioContext,

×

610

    [this, address, longAddress, speed, speedSteps, directionForward]()

×

612

      auto& engine = m_engines[makeAddressKey(address, longAddress)];

×

UNCOV

613

      const bool speedStepsChanged = engine.speedSteps != speedSteps;

×

UNCOV

614

      engine.speedSteps = speedSteps;

×

UNCOV

615

      engine.speed = speed;

×

UNCOV

616

      engine.directionForward = directionForward;

×

UNCOV

618

      if(engine.session) // we're in control

×

620

        if(speedStepsChanged)

×

622

          sendSetEngineSessionMode(*engine.session, engine.speedSteps);

×

624

        sendSetEngineSpeedDirection(*engine.session, engine.speed, engine.directionForward);

×

626

        engine.lastCommand = std::chrono::steady_clock::now();

×

UNCOV

628

        if(!m_engineKeepAliveTimerActive || (m_engineKeepAliveTimerActive && m_engineKeepAliveSession == *engine.session))

×

UNCOV

630

          restartEngineKeepAliveTimer();

×

635

        sendGetEngineSession(address, longAddress);

×

637

});

×

638

×

640

void Kernel::setEngineFunction(uint16_t address, bool longAddress, uint8_t number, bool value)

×

642

  assert(isEventLoopThread());

×

644

  boost::asio::post(m_ioContext,

×

645

    [this, address, longAddress, number, value]()

×

647

      auto& engine = m_engines[makeAddressKey(address, longAddress)];

×

UNCOV

648

      engine.functions[number] = value;

×

649

      if(engine.session) // we're in control

×

UNCOV

651

        sendSetEngineFunction(*engine.session, number, value);

×

653

        engine.lastCommand = std::chrono::steady_clock::now();

×

655

        if(!m_engineKeepAliveTimerActive || (m_engineKeepAliveTimerActive && m_engineKeepAliveSession == *engine.session))

×

UNCOV

657

          restartEngineKeepAliveTimer();

×

662

        sendGetEngineSession(address, longAddress);

×

UNCOV

664

});

×

665

×

667

void Kernel::setAccessoryShort(uint16_t deviceNumber, bool on)

×

669

  assert(isEventLoopThread());

×

671

  boost::asio::post(m_ioContext,

×

UNCOV

672

    [this, deviceNumber, on]()

×

UNCOV

674

      if(on)

×

676

        send(AccessoryShortOn(m_config.shortEventNodeNumber, deviceNumber));

×

680

        send(AccessoryShortOff(m_config.shortEventNodeNumber, deviceNumber));

×

682

});

×

683

×

685

void Kernel::setAccessory(uint16_t nodeNumber, uint16_t eventNumber, bool on)

×

687

  assert(isEventLoopThread());

×

689

  boost::asio::post(m_ioContext,

×

UNCOV

690

    [this, nodeNumber, eventNumber, on]()

×

UNCOV

692

      if(on)

×

UNCOV

694

        send(AccessoryOn(nodeNumber, eventNumber));

×

698

        send(AccessoryOff(nodeNumber, eventNumber));

×

UNCOV

700

});

×

701

×

UNCOV

703

void Kernel::setDccAccessory(uint16_t address, bool secondOutput)

×

UNCOV

705

  assert(isEventLoopThread());

×

707

  boost::asio::post(m_ioContext,

×

UNCOV

708

    [this, address, secondOutput]()

×

UNCOV

710

      send(RequestDCCPacket<sizeof(DCC::SetSimpleAccessory) + 1>(DCC::SetSimpleAccessory(address, secondOutput, true), Config::dccAccessoryRepeat));

×

711

      const bool wasEmpty = m_dccAccessoryQueue.empty();

×

UNCOV

712

      m_dccAccessoryQueue.emplace(std::make_pair(

×

713

        std::chrono::steady_clock::now() + m_config.dccAccessorySwitchTime,

×

UNCOV

714

        DCC::SetSimpleAccessory(address, secondOutput, false)

×

716

      if(wasEmpty)

×

718

        startDccAccessoryTimer();

×

UNCOV

720

});

×

721

×

723

void Kernel::setDccAdvancedAccessoryValue(uint16_t address, uint8_t aspect)

×

725

  assert(isEventLoopThread());

×

727

  boost::asio::post(m_ioContext,

×

728

    [this, address, aspect]()

×

UNCOV

730

      send(RequestDCCPacket<sizeof(DCC::SetAdvancedAccessoryValue) + 1>(DCC::SetAdvancedAccessoryValue(address, aspect), Config::dccExtRepeat));

×

731

});

×

732

×

UNCOV

734

bool Kernel::send(std::vector<uint8_t> message)

×

736

  assert(isEventLoopThread());

×

UNCOV

738

  if(!inRange<size_t>(message.size(), 1, 8))

×

740

    return false;

×

743

  boost::asio::post(m_ioContext,

×

UNCOV

744

    [this, msg=std::move(message)]()

×

UNCOV

746

      send(*reinterpret_cast<const Message*>(msg.data()));

×

UNCOV

747

});

×

UNCOV

749

  return true;

×

752

bool Kernel::sendDCC(std::vector<uint8_t> dccPacket, uint8_t repeat)

×

754

  assert(isEventLoopThread());

×

756

  if(!inRange<size_t>(dccPacket.size(), 2, 5) || repeat == 0)

×

758

    return false;

×

UNCOV

761

  dccPacket.emplace_back(DCC::calcChecksum(dccPacket));

×

763

  boost::asio::post(m_ioContext,

×

UNCOV

764

    [this, packet=std::move(dccPacket), repeat]()

×

766

      switch(packet.size())

×

UNCOV

768

        case 3:

×

769

          send(RequestDCCPacket<3>(packet, repeat));

×

UNCOV

770

          break;

×

UNCOV

772

        case 4:

×

UNCOV

773

          send(RequestDCCPacket<4>(packet, repeat));

×

UNCOV

774

          break;

×

776

        case 5:

×

UNCOV

777

          send(RequestDCCPacket<5>(packet, repeat));

×

778

          break;

×

780

        case 6:

×

UNCOV

781

          send(RequestDCCPacket<6>(packet, repeat));

×

782

          break;

×

784

        default: [[unlikely]]

×

785

          assert(false);

×

788

});

×

UNCOV

790

  return true;

×

793

void Kernel::setIOHandler(std::unique_ptr<IOHandler> handler)

×

795

  assert(isEventLoopThread());

×

UNCOV

796

  assert(handler);

×

797

  assert(!m_ioHandler);

×

798

  m_ioHandler = std::move(handler);

×

UNCOV

799

×

UNCOV

801

void Kernel::send(const Message& message)

×

UNCOV

803

  assert(isKernelThread());

×

UNCOV

805

  if(m_config.debugLogRXTX)

×

807

    EventLoop::call(

×

UNCOV

808

      [this, msg=toString(message)]()

×

UNCOV

810

        Log::log(logId, LogMessage::D2001_TX_X, msg);

×

811

});

×

814

  const auto canMessage = toCANMessage(message, m_canId);

×

816

  if(auto ec = m_ioHandler->send(canMessage); ec)

×

UNCOV

821

  if(m_hub)

×

823

    m_hub->send(canMessage);

×

825

×

827

void Kernel::sendGetEngineSession(uint16_t address, bool longAddress)

×

829

  assert(isKernelThread());

×

830

  const auto key = makeAddressKey(address, longAddress);

×

UNCOV

831

  if(!m_engineGLOCs.contains(key))

×

UNCOV

833

    m_engineGLOCs.emplace(key, Owner::Traintastic);

×

834

    send(GetEngineSession(address, longAddress, GetEngineSession::Mode::Steal));

×

836

×

838

void Kernel::sendSetEngineSessionMode(uint8_t session, uint8_t speedSteps)

×

840

  assert(isKernelThread());

×

842

  send(SetEngineSessionMode(session, toSpeedMode(speedSteps), false, false));

×

843

×

845

void Kernel::sendSetEngineSpeedDirection(uint8_t session, uint8_t speed, bool directionForward)

×

847

  assert(isKernelThread());

×

849

  send(SetEngineSpeedDirection(session, speed, directionForward));

×

851

  EventLoop::call(

×

UNCOV

852

    [this, session, speed, directionForward]()

×

UNCOV

854

      if(onEngineSpeedDirectionChanged) [[likely]]

×

UNCOV

856

        onEngineSpeedDirectionChanged(session, speed, directionForward);

×

858

});

×

UNCOV

859

×

UNCOV

861

void Kernel::sendSetEngineFunction(uint8_t session, uint8_t number, bool value)

×

UNCOV

863

  assert(isKernelThread());

×

865

  send(SetEngineFunction(session, number, value));

×

867

  EventLoop::call(

×

UNCOV

868

    [this, session, number, value]()

×

UNCOV

870

      if(onEngineFunctionChanged) [[likely]]

×

872

        onEngineFunctionChanged(session, number, value);

×

874

});

×

UNCOV

875

×

UNCOV

877

void Kernel::receiveGLOC(uint16_t address, bool longAddress, GetEngineSession::Mode /*mode*/)

×

879

  assert(isKernelThread());

×

UNCOV

880

  const auto key = makeAddressKey(address, longAddress);

×

881

  if(!m_engineGLOCs.contains(key))

×

883

    m_engineGLOCs.emplace(key, Owner::CBUS);

×

UNCOV

884

    (void)m_engines[makeAddressKey(address, longAddress)]; // create entry if not exists

×

886

×

888

void Kernel::receiveDFNOx(const SetEngineFunction& message)

×

890

  assert(isKernelThread());

×

UNCOV

891

  EventLoop::call(

×

UNCOV

892

    [this, message]()

×

894

      if(onEngineFunctionChanged) [[likely]]

×

896

        onEngineFunctionChanged(message.session, message.number, message.on());

×

898

});

×

899

×

UNCOV

901

void Kernel::receiveDFUN(const CBUS::SetEngineFunctions& message)

×

UNCOV

903

  assert(isKernelThread());

×

904

  EventLoop::call(

×

UNCOV

905

    [this, message]()

×

907

      if(onEngineFunctionChanged) [[likely]]

×

909

        switch(message.range)

×

913

          case F0F4:

×

UNCOV

914

            for(auto fn : message.numbers())

×

UNCOV

916

              onEngineFunctionChanged(message.session, fn, static_cast<const SetEngineFunctionsF0F4&>(message).f(fn));

×

UNCOV

918

            break;

×

920

          case F5F8:

×

UNCOV

921

            for(auto fn : message.numbers())

×

UNCOV

923

              onEngineFunctionChanged(message.session, fn, static_cast<const SetEngineFunctionsF5F8&>(message).f(fn));

×

925

            break;

×

UNCOV

927

          case F9F12:

×

928

            for(auto fn : message.numbers())

×

930

              onEngineFunctionChanged(message.session, fn, static_cast<const SetEngineFunctionsF9F12&>(message).f(fn));

×

932

            break;

×

UNCOV

934

          case F13F20:

×

935

            for(auto fn : message.numbers())

×

937

              onEngineFunctionChanged(message.session, fn, static_cast<const SetEngineFunctionsF13F20&>(message).f(fn));

×

939

            break;

×

941

          case F21F28:

×

UNCOV

942

            for(auto fn : message.numbers())

×

UNCOV

944

              onEngineFunctionChanged(message.session, fn, static_cast<const SetEngineFunctionsF21F28&>(message).f(fn));

×

946

            break;

×

UNCOV

949

});

×

950

×

UNCOV

952

void Kernel::receiveDSPD(const SetEngineSpeedDirection& message)

×

UNCOV

954

  assert(isKernelThread());

×

955

  EventLoop::call(

×

UNCOV

956

    [this, message]()

×

958

      if(onEngineSpeedDirectionChanged) [[likely]]

×

UNCOV

960

        onEngineSpeedDirectionChanged(message.session, message.speed(), message.directionForward());

×

962

});

×

963

×

UNCOV

965

void Kernel::receiveKLOC(const ReleaseEngine& message)

×

967

  assert(isKernelThread());

×

968

  EventLoop::call(

×

UNCOV

969

    [this, session=message.session]()

×

971

      if(onEngineSessionReleased) [[likely]]

×

973

        onEngineSessionReleased(session);

×

975

});

×

976

×

UNCOV

978

void Kernel::receiveShortEvent(uint16_t eventNumber, bool on)

×

980

  assert(isKernelThread());

×

981

  EventLoop::call(

×

UNCOV

982

    [this, eventNumber, on]()

×

984

      if(onShortEvent) [[likely]]

×

UNCOV

986

        onShortEvent(eventNumber, on);

×

UNCOV

988

});

×

989

×

991

void Kernel::receiveLongEvent(uint16_t nodeNumber, uint16_t eventNumber, bool on)

×

UNCOV

993

  assert(isKernelThread());

×

994

  EventLoop::call(

×

995

    [this, nodeNumber, eventNumber, on]()

×

997

      if(onLongEvent) [[likely]]

×

UNCOV

999

        onLongEvent(nodeNumber, eventNumber, on);

×

1001

});

×

UNCOV

1002

×

1004

void Kernel::changeState(State value)

×

1006

  assert(isKernelThread());

×

1007

  assert(m_state != value);

×

1009

  m_state = value;

×

UNCOV

1011

  switch(m_state)

×

1013

    case State::Initial: [[unlikely]]

×

UNCOV

1014

      assert(false);

×

UNCOV

1017

    case State::QueryNodes:

×

1018

      send(QueryNodeNumber());

×

1019

      restartInitializationTimer(queryNodeNumberTimeout);

×

UNCOV

1020

      break;

×

1022

    case State::ReadNodeParameters:

×

UNCOV

1023

      readNodeParameter();

×

UNCOV

1024

      break;

×

UNCOV

1026

    case State::GetCommandStationStatus:

×

1027

      send(RequestCommandStationStatus());

×

UNCOV

1028

      restartInitializationTimer(requestCommandStationStatusTimeout);

×

1029

      break;

×

1031

    case State::RequestShortEvents:

×

1032

      requestShortEvent();

×

1033

      break;

×

1035

    case State::RequestLongEvents:

×

UNCOV

1036

      requestLongEvent();

×

1037

      break;

×

UNCOV

1039

    case State::Started:

×

1040

      KernelBase::started();

×

UNCOV

1041

      break;

×

1043

×

UNCOV

1045

void Kernel::readNodeParameter()

×

1047

  assert(m_state == State::ReadNodeParameters);

×

1048

  if(m_readNodeParameters.empty())

×

UNCOV

1050

    nextState();

×

1051

    return;

×

1053

  send(m_readNodeParameters.front());

×

UNCOV

1054

  restartInitializationTimer(readNodeParameterTimeout);

×

1057

void Kernel::requestShortEvent()

×

UNCOV

1059

  assert(m_state == State::RequestShortEvents);

×

1060

  if(m_initializationRequestShortEvents.empty())

×

1062

    nextState();

×

1063

    return;

×

1065

  send(AccessoryShortRequestEvent(m_config.shortEventNodeNumber, m_initializationRequestShortEvents.back()));

×

1066

  restartInitializationTimer(requestShortEventTimeout);

×

UNCOV

1069

void Kernel::requestLongEvent()

×

1071

  assert(m_state == State::RequestLongEvents);

×

UNCOV

1072

  if(m_initializationRequestLongEvents.empty())

×

UNCOV

1074

    nextState();

×

1075

    return;

×

1077

  send(AccessoryRequestEvent(m_initializationRequestLongEvents.back().first, m_initializationRequestLongEvents.back().second));

×

UNCOV

1078

  restartInitializationTimer(requestLongEventTimeout);

×

1081

void Kernel::restartInitializationTimer(std::chrono::milliseconds timeout)

×

1083

  assert(isKernelThread());

×

1085

  m_initializationTimer.cancel();

×

UNCOV

1087

  m_initializationTimer.expires_after(timeout);

×

UNCOV

1088

  m_initializationTimer.async_wait(

×

UNCOV

1089

    [this](std::error_code ec)

×

UNCOV

1091

      if(ec)

×

UNCOV

1093

        return;

×

1096

      switch(m_state)

×

1098

        case State::QueryNodes:

×

UNCOV

1099

          nextState();

×

1100

          break;

×

UNCOV

1102

        case State::ReadNodeParameters:

×

1103

          m_readNodeParameters.pop();

×

UNCOV

1104

          readNodeParameter();

×

1105

          break;

×

UNCOV

1107

        case State::GetCommandStationStatus:

×

1108

          nextState();

×

1109

          break;

×

1111

        case State::RequestShortEvents:

×

UNCOV

1112

          m_initializationRequestShortEvents.pop_back();

×

UNCOV

1113

          requestShortEvent();

×

1114

          break;

×

UNCOV

1116

        case State::RequestLongEvents:

×

1117

          m_initializationRequestLongEvents.pop_back();

×

UNCOV

1118

          requestLongEvent();

×

1119

          break;

×

1121

        case State::Initial: [[unlikely]]

×

UNCOV

1122

        case State::Started: [[unlikely]]

×

1123

          assert(false);

×

UNCOV

1127

×

1129

void Kernel::restartEngineKeepAliveTimer()

×

UNCOV

1131

  assert(isKernelThread());

×

UNCOV

1133

  m_engineKeepAliveTimer.cancel();

×

UNCOV

1136

  std::chrono::steady_clock::time_point lastUpdate = std::chrono::steady_clock::time_point::max();

×

1137

  for(const auto& [_, engine] : m_engines)

×

1139

    if(engine.session && engine.lastCommand < lastUpdate)

×

1141

      lastUpdate = engine.lastCommand;

×

UNCOV

1142

      m_engineKeepAliveSession = *engine.session;

×

UNCOV

1146

  m_engineKeepAliveTimerActive = (lastUpdate < std::chrono::steady_clock::time_point::max());

×

UNCOV

1148

  if(m_engineKeepAliveTimerActive)

×

UNCOV

1150

    m_engineKeepAliveTimer.expires_at(lastUpdate + m_config.engineKeepAlive);

×

UNCOV

1151

    m_engineKeepAliveTimer.async_wait(

×

UNCOV

1152

      [this](std::error_code ec)

×

UNCOV

1154

        if(ec)

×

UNCOV

1156

          return;

×

UNCOV

1159

        send(SessionKeepAlive(m_engineKeepAliveSession));

×

UNCOV

1161

        if(auto it = std::find_if(m_engines.begin(), m_engines.end(),

×

UNCOV

1162

            [session=m_engineKeepAliveSession](const auto& item)

×

UNCOV

1164

              return item.second.session && *item.second.session == session;

×

UNCOV

1165

            }); it != m_engines.end()) [[likely]]

×

UNCOV

1167

          it->second.lastCommand = std::chrono::steady_clock::now();

×

UNCOV

1170

        restartEngineKeepAliveTimer();

×

UNCOV

1173

×

UNCOV

1175

void Kernel::startDccAccessoryTimer()

×

UNCOV

1177

  assert(isKernelThread());

×

UNCOV

1179

  if(m_dccAccessoryQueue.empty()) [[unlikely]]

×

UNCOV

1181

    return;

×

UNCOV

1184

  m_dccAccessoryTimer.expires_at(m_dccAccessoryQueue.front().first);

×

UNCOV

1185

  m_dccAccessoryTimer.async_wait(

×

UNCOV

1186

    [this](std::error_code ec)

×

UNCOV

1188

      if(ec)

×

UNCOV

1190

        return;

×

UNCOV

1193

      send(RequestDCCPacket<sizeof(DCC::SetSimpleAccessory) + 1>(m_dccAccessoryQueue.front().second, Config::dccAccessoryRepeat));

×

UNCOV

1195

      m_dccAccessoryQueue.pop();

×

UNCOV

1197

      if(!m_dccAccessoryQueue.empty())

×

UNCOV

1199

        startDccAccessoryTimer();

×

traintastic / traintastic / 26121453997

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

traintastic / traintastic / 26121453997

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