traintastic/traintastic | Build 20392201742 | server/src/hardware/protocol/loconet/kernel.cpp | Coveralls

51

static void updateDecoderSpeed(const std::shared_ptr<Decoder>& decoder, uint8_t speed)

×

53

  decoder->emergencyStop.setValueInternal(speed == SPEED_ESTOP);

×

UNCOV

55

  if(speed == SPEED_STOP || speed == SPEED_ESTOP)

×

UNCOV

56

    decoder->throttle.setValueInternal(Decoder::throttleStop);

×

59

    speed--; // decrement one for ESTOP: 2..127 -> 1..126

×

60

    const auto currentStep = Decoder::throttleToSpeedStep<uint8_t>(decoder->throttle.value(), SPEED_MAX - 1);

×

UNCOV

61

    if(currentStep != speed) // only update trottle if it is a different step

×

62

      decoder->throttle.setValueInternal(Decoder::speedStepToThrottle<uint8_t>(speed, SPEED_MAX - 1));

×

64

×

66

constexpr Kernel::Priority& operator ++(Kernel::Priority& value)

×

UNCOV

68

  return (value = static_cast<Kernel::Priority>(static_cast<std::underlying_type_t<Kernel::Priority>>(value) + 1));

×

71

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

×

72

  : KernelBase(std::move(logId_))

×

73

  , m_simulation{simulation}

×

74

  , m_waitingForEcho{false}

×

75

  , m_waitingForEchoTimer{m_ioContext}

×

76

  , m_waitingForResponse{false}

×

77

  , m_waitingForResponseTimer{m_ioContext}

×

78

  , m_fastClockSyncTimer(m_ioContext)

×

79

  , m_decoderController{nullptr}

×

80

  , m_inputController{nullptr}

×

81

  , m_outputController{nullptr}

×

82

  , m_identificationController{nullptr}

×

UNCOV

83

  , m_debugDir{Traintastic::instance->debugDir()}

×

84

  , m_config{config}

×

UNCOV

86

  assert(isEventLoopThread());

×

87

×

89

Kernel::~Kernel() = default;

×

91

void Kernel::setConfig(const Config& config)

×

93

  assert(isEventLoopThread());

×

95

  switch(config.fastClock)

×

97

    case LocoNetFastClock::Off:

×

UNCOV

98

      disableClockEvents();

×

99

      break;

×

101

    case LocoNetFastClock::Master:

×

UNCOV

102

      enableClockEvents();

×

UNCOV

103

      break;

×

UNCOV

106

  m_ioContext.post(

×

107

    [this, newConfig=config]()

×

109

      if(newConfig.pcap != m_config.pcap)

×

UNCOV

111

        if(newConfig.pcap)

×

112

          startPCAP(newConfig.pcapOutput);

×

114

          m_pcap.reset();

×

116

      else if(newConfig.pcap && newConfig.pcapOutput != m_config.pcapOutput)

×

UNCOV

118

        m_pcap.reset();

×

UNCOV

119

        startPCAP(newConfig.pcapOutput);

×

122

      if(newConfig.listenOnly && !m_config.listenOnly)

×

UNCOV

124

        for(auto& queue : m_sendQueue)

×

125

          queue.clear();

×

UNCOV

127

        EventLoop::call(

×

128

          [this]()

×

130

            Log::log(logId, LogMessage::N2006_LISTEN_ONLY_MODE_ACTIVATED);

×

131

});

×

UNCOV

132

×

133

      else if(!newConfig.listenOnly && m_config.listenOnly)

×

UNCOV

135

        EventLoop::call(

×

136

          [this]()

×

UNCOV

138

            Log::log(logId, LogMessage::N2007_LISTEN_ONLY_MODE_DEACTIVATED);

×

UNCOV

139

});

×

142

      if(m_config.fastClock == LocoNetFastClock::Master && newConfig.fastClock == LocoNetFastClock::Off)

×

144

        setFastClockMaster(false);

×

146

      else if(m_config.fastClock == LocoNetFastClock::Off && newConfig.fastClock == LocoNetFastClock::Master)

×

UNCOV

148

        setFastClockMaster(true);

×

151

      if(!m_config.fastClockSyncEnabled && newConfig.fastClockSyncEnabled)

×

UNCOV

153

        send(RequestSlotData(SLOT_FAST_CLOCK));

×

154

        startFastClockSyncTimer();

×

156

      else if(m_config.fastClockSyncEnabled && !newConfig.fastClockSyncEnabled)

×

158

        stopFastClockSyncTimer();

×

160

      m_config = newConfig;

×

UNCOV

161

});

×

162

×

164

void Kernel::setOnGlobalPowerChanged(std::function<void(bool)> callback)

×

166

  assert(isEventLoopThread());

×

167

  assert(!m_started);

×

UNCOV

168

  m_onGlobalPowerChanged = std::move(callback);

×

169

×

171

void Kernel::setOnIdle(std::function<void()> callback)

×

173

  assert(isEventLoopThread());

×

174

  assert(!m_started);

×

UNCOV

175

  m_onIdle = std::move(callback);

×

176

×

178

void Kernel::setClock(std::shared_ptr<Clock> clock)

×

180

  assert(isEventLoopThread());

×

181

  assert(!m_started);

×

182

  assert(clock);

×

183

  m_clock = std::move(clock);

×

UNCOV

184

  m_fastClock.store(FastClock{m_clock->running ? m_clock->multiplier : multiplierFreeze, m_clock->hour, m_clock->minute});

×

185

×

187

void Kernel::setDecoderController(DecoderController* decoderController)

×

189

  assert(isEventLoopThread());

×

190

  assert(!m_started);

×

UNCOV

191

  m_decoderController = decoderController;

×

192

×

194

void Kernel::setInputController(InputController* inputController)

×

196

  assert(isEventLoopThread());

×

197

  assert(!m_started);

×

UNCOV

198

  m_inputController = inputController;

×

199

×

201

void Kernel::setOutputController(OutputController* outputController)

×

203

  assert(isEventLoopThread());

×

204

  assert(!m_started);

×

UNCOV

205

  m_outputController = outputController;

×

206

×

208

void Kernel::setIdentificationController(IdentificationController* identificationController)

×

210

  assert(isEventLoopThread());

×

211

  assert(!m_started);

×

UNCOV

212

  m_identificationController= identificationController;

×

213

×

215

void Kernel::start()

×

217

  assert(isEventLoopThread());

×

UNCOV

218

  assert(m_ioHandler);

×

UNCOV

219

  assert(!m_started);

×

222

  m_globalPower = TriState::Undefined;

×

223

  m_emergencyStop = TriState::Undefined;

×

224

  m_addressToSlot.clear();

×

225

  m_slots.clear();

×

226

  m_pendingSlotMessages.clear();

×

UNCOV

227

  m_inputValues.fill(TriState::Undefined);

×

228

  m_outputValues.fill(OutputPairValue::Undefined);

×

UNCOV

230

  if(m_config.listenOnly)

×

231

    Log::log(logId, LogMessage::N2006_LISTEN_ONLY_MODE_ACTIVATED);

×

UNCOV

233

  m_thread = std::thread(

×

234

    [this]()

×

236

      setThreadName("loconet");

×

237

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

×

UNCOV

238

      m_ioContext.run();

×

239

});

×

UNCOV

241

  if(m_config.fastClock == LocoNetFastClock::Master)

×

242

    enableClockEvents();

×

UNCOV

244

  m_ioContext.post(

×

245

    [this]()

×

UNCOV

247

      if(m_config.pcap)

×

UNCOV

248

        startPCAP(m_config.pcapOutput);

×

252

        m_ioHandler->start();

×

254

      catch(const LogMessageException& e)

×

UNCOV

256

        EventLoop::call(

×

257

          [this, e]()

×

259

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

×

260

            error();

×

261

});

×

UNCOV

262

        return;

×

UNCOV

263

×

267

  m_started = true;

×

269

×

271

void Kernel::stop()

×

273

  assert(isEventLoopThread());

×

275

  disableClockEvents();

×

UNCOV

277

  m_ioContext.post(

×

278

    [this]()

×

280

      m_waitingForEchoTimer.cancel();

×

281

      m_waitingForResponseTimer.cancel();

×

282

      m_fastClockSyncTimer.cancel();

×

283

      m_ioHandler->stop();

×

UNCOV

284

      m_pcap.reset();

×

285

});

×

287

  m_ioContext.stop();

×

UNCOV

289

  m_thread.join();

×

292

  m_started = false;

×

294

×

296

void Kernel::started()

×

298

  assert(isKernelThread());

×

UNCOV

300

  if(m_config.fastClock == LocoNetFastClock::Master)

×

301

    setFastClockMaster(true);

×

UNCOV

303

  if(m_config.fastClockSyncEnabled)

×

304

    startFastClockSyncTimer();

×

UNCOV

306

  for(uint8_t slot = SLOT_LOCO_MIN; slot <= m_config.locomotiveSlots; slot++)

×

307

    send(RequestSlotData(slot), LowPriority);

×

UNCOV

309

  KernelBase::started();

×

310

×

312

void Kernel::receive(const Message& message)

×

UNCOV

314

  assert(isKernelThread());

×

315

  assert(isValid(message)); // only valid messages should be received

×

UNCOV

317

  if(m_pcap)

×

318

    m_pcap->writeRecord(&message, message.size());

×

UNCOV

320

  if(m_config.debugLogRXTX)

×

321

    EventLoop::call([this, msg=toString(message)](){ Log::log(logId, LogMessage::D2002_RX_X, msg); });

×

UNCOV

323

  bool isResponse = false;

×

324

  if(m_waitingForEcho && message == lastSentMessage())

×

326

    m_waitingForEcho = false;

×

UNCOV

327

    m_waitingForEchoTimer.cancel();

×

328

    if(!m_waitingForResponse)

×

UNCOV

330

      m_sendQueue[m_sentMessagePriority].pop();

×

UNCOV

331

      sendNextMessage();

×

334

  else if(m_waitingForResponse)

×

UNCOV

336

    isResponse = isValidResponse(lastSentMessage(), message);

×

339

  switch(message.opCode)

×

UNCOV

341

    case OPC_GPON:

×

342

      if(m_globalPower != TriState::True)

×

344

        m_globalPower = TriState::True;

×

345

        if(m_onGlobalPowerChanged)

×

UNCOV

346

          EventLoop::call(

×

347

            [this]()

×

UNCOV

349

              m_onGlobalPowerChanged(true);

×

350

});

×

352

      break;

×

UNCOV

354

    case OPC_GPOFF:

×

355

      if(m_globalPower != TriState::False)

×

357

        m_globalPower = TriState::False;

×

358

        if(m_onGlobalPowerChanged)

×

UNCOV

359

          EventLoop::call(

×

360

            [this]()

×

UNCOV

362

              m_onGlobalPowerChanged(false);

×

363

});

×

365

      break;

×

UNCOV

367

    case OPC_IDLE:

×

368

      if(m_emergencyStop != TriState::True)

×

370

        m_emergencyStop = TriState::True;

×

371

        if(m_onIdle)

×

UNCOV

372

          EventLoop::call(

×

373

            [this]()

×

UNCOV

375

              m_onIdle();

×

376

});

×

378

      break;

×

UNCOV

380

    case OPC_LOCO_SPD:

×

381

      if(m_decoderController)

×

UNCOV

383

        const auto& locoSpd = static_cast<const LocoSpd&>(message);

×

384

        if(LocoSlot* slot = getLocoSlot(locoSpd.slot))

×

386

          if(!slot->isAddressValid())

×

388

            send(RequestSlotData(locoSpd.slot));

×

390

          else if(slot->speed != locoSpd.speed)

×

392

            slot->speed = locoSpd.speed;

×

UNCOV

394

            EventLoop::call(

×

395

              [this, address=slot->address, speed=slot->speed]()

×

397

                if(auto decoder = getDecoder(address))

×

UNCOV

398

                  updateDecoderSpeed(decoder, speed);

×

UNCOV

399

});

×

403

      break;

×

UNCOV

405

    case OPC_LOCO_DIRF: // direction and F0-F4

×

406

      if(m_decoderController)

×

UNCOV

408

        const auto& locoDirF = static_cast<const LocoDirF&>(message);

×

409

        if(LocoSlot* slot = getLocoSlot(locoDirF.slot))

×

411

          if(!slot->isAddressValid())

×

UNCOV

413

            send(RequestSlotData(locoDirF.slot));

×

417

            if(slot->direction != locoDirF.direction())

×

419

              slot->direction = locoDirF.direction();

×

UNCOV

421

              EventLoop::call(

×

422

                [this, address=slot->address, direction=locoDirF.direction()]()

×

424

                  if(auto decoder = getDecoder(address))

×

UNCOV

425

                    decoder->direction.setValueInternal(direction);

×

UNCOV

426

});

×

UNCOV

429

            updateFunctions<0, 4>(*slot, locoDirF);

×

433

      break;

×

UNCOV

435

    case OPC_LOCO_SND: // F5-F8

×

436

      if(m_decoderController)

×

UNCOV

438

        const auto& locoSnd = static_cast<const LocoSnd&>(message);

×

439

        if(LocoSlot* slot = getLocoSlot(locoSnd.slot))

×

441

          if(!slot->isAddressValid())

×

UNCOV

443

            send(RequestSlotData(locoSnd.slot));

×

UNCOV

447

            updateFunctions<5, 8>(*slot, locoSnd);

×

451

      break;

×

UNCOV

453

    case OPC_LOCO_F9F12:

×

454

      if(m_decoderController)

×

UNCOV

456

        const auto& locoF9F12 = static_cast<const LocoF9F12&>(message);

×

457

        if(LocoSlot* slot = getLocoSlot(locoF9F12.slot))

×

459

          if(!slot->isAddressValid())

×

461

            send(RequestSlotData(locoF9F12.slot));

×

UNCOV

463

          updateFunctions<9, 12>(*slot, locoF9F12);

×

466

      break;

×

UNCOV

468

    case OPC_INPUT_REP:

×

469

      if(m_inputController)

×

UNCOV

471

        const auto& inputRep = static_cast<const InputRep&>(message);

×

472

        if(inputRep.isControlSet())

×

UNCOV

474

          const auto value = toTriState(inputRep.value());

×

475

          if(m_inputValues[inputRep.fullAddress()] != value)

×

477

            if(m_config.debugLogInput)

×

UNCOV

478

              EventLoop::call(

×

479

                [this, address=1 + inputRep.fullAddress(), value=inputRep.value()]()

×

UNCOV

481

                  Log::log(logId, LogMessage::D2007_INPUT_X_IS_X, address, value ? std::string_view{"1"} : std::string_view{"0"});

×

482

});

×

484

            m_inputValues[inputRep.fullAddress()] = value;

×

UNCOV

486

            EventLoop::call(

×

487

              [this, address=1 + inputRep.fullAddress(), value]()

×

UNCOV

489

                m_inputController->updateInputValue(InputChannel::Input, address, value);

×

UNCOV

490

});

×

494

      break;

×

UNCOV

496

    case OPC_SW_REQ:

×

497

      if(m_outputController)

×

UNCOV

499

        const auto& switchRequest = static_cast<const SwitchRequest&>(message);

×

500

        if(switchRequest.on())

×

UNCOV

502

          const auto value = switchRequest.dir() ? OutputPairValue::Second : OutputPairValue::First;

×

503

          if(m_outputValues[switchRequest.address() - accessoryOutputAddressMin] != value)

×

505

            m_outputValues[switchRequest.address() - accessoryOutputAddressMin] = value;

×

UNCOV

507

            EventLoop::call(

×

508

              [this, address=switchRequest.address(), value]()

×

UNCOV

510

                m_outputController->updateOutputValue(OutputChannel::Accessory, address, value);

×

UNCOV

511

});

×

515

      break;

×

UNCOV

517

    case OPC_SW_REP:

×

518

      break; // unimplemented

×

520

    case OPC_SL_RD_DATA:

×

UNCOV

522

      const uint8_t slot = *(reinterpret_cast<const uint8_t*>(&message) + 2);

×

523

      if(m_decoderController && isLocoSlot(slot))

×

UNCOV

525

        const auto& slotReadData = static_cast<const SlotReadData&>(message);

×

526

        if(slotReadData.isFree())

×

UNCOV

528

          clearLocoSlot(slotReadData.slot);

×

UNCOV

529

          break;

×

UNCOV

532

        LocoSlot* locoSlot = getLocoSlot(slotReadData.slot, false);

×

533

        assert(locoSlot);

×

UNCOV

535

        if(!locoSlot->isAddressValid())

×

536

          m_addressToSlot[slotReadData.address()] = slot;

×

UNCOV

538

        bool changed = locoSlot->isAddressValid() && locoSlot->address != slotReadData.address();

×

539

        if(changed)

×

541

          if(auto it = m_addressToSlot.find(locoSlot->address); it != m_addressToSlot.end() && it->second == slotReadData.slot)

×

UNCOV

542

            m_addressToSlot.erase(locoSlot->address);

×

543

          locoSlot->invalidate();

×

545

        locoSlot->address = slotReadData.address();

×

547

        if(changed)

×

UNCOV

549

          EventLoop::call(

×

550

            [this, address=locoSlot->address, speed=locoSlot->speed, direction=locoSlot->direction]()

×

552

              if(auto decoder = getDecoder(address))

×

554

                updateDecoderSpeed(decoder, speed);

×

555

                decoder->direction.setValueInternal(direction);

×

UNCOV

556

×

UNCOV

557

});

×

UNCOV

560

        updateFunctions<0, 8>(*locoSlot, slotReadData);

×

563

        if(auto it = m_pendingSlotMessages.find(locoSlot->address); it != m_pendingSlotMessages.end())

×

565

          std::byte* p = it->second.data();

×

UNCOV

566

          size_t size = it->second.size();

×

567

          while(size > 0)

×

569

            Message& slotMassage =  *reinterpret_cast<Message*>(p);

×

570

            setSlot(slotMassage, slot);

×

571

            updateChecksum(slotMassage);

×

572

            send(slotMassage);

×

UNCOV

573

            p += slotMassage.size();

×

574

            size -= slotMassage.size();

×

UNCOV

576

          m_pendingSlotMessages.erase(it);

×

587

      break;

×

UNCOV

589

    case OPC_BUSY:

×

590

      break; // unimplemented

×

592

    case OPC_LONG_ACK:

×

UNCOV

594

      const auto& longAck = static_cast<const LongAck&>(message);

×

595

      if(longAck.respondingOpCode() == OPC_LOCO_ADR && longAck.ack1 == 0)

×

UNCOV

597

        EventLoop::call(

×

598

          [this]()

×

UNCOV

600

            Log::log(logId, LogMessage::C2004_CANT_GET_FREE_SLOT);

×

601

});

×

603

      else if(longAck.respondingOpCode() == OPC_RQ_SL_DATA && longAck.ack1 == 0 && lastSentMessage().opCode == OPC_RQ_SL_DATA)

×

605

        const uint8_t slot = static_cast<const RequestSlotData&>(lastSentMessage()).slot;

×

607

        if(isLocoSlot(slot))

×

UNCOV

609

          EventLoop::call(

×

610

            [this, slot]()

×

UNCOV

612

              Log::log(logId, LogMessage::W2006_COMMAND_STATION_DOES_NOT_SUPPORT_LOCO_SLOT_X, slot);

×

613

});

×

615

        else if(slot == SLOT_FAST_CLOCK)

×

617

          m_fastClockSupported = false;

×

UNCOV

618

          if(m_config.fastClockSyncEnabled)

×

619

            stopFastClockSyncTimer();

×

UNCOV

621

          EventLoop::call(

×

622

            [this, stoppedFastClockSyncTimer=m_config.fastClockSyncEnabled]()

×

624

              Log::log(logId, LogMessage::W2007_COMMAND_STATION_DOES_NOT_SUPPORT_THE_FAST_CLOCK_SLOT);

×

625

              if(stoppedFastClockSyncTimer)

×

UNCOV

626

                Log::log(logId, LogMessage::N2003_STOPPED_SENDING_FAST_CLOCK_SYNC);

×

UNCOV

627

});

×

630

      else if(m_lncvActive && m_onLNCVReadResponse &&

×

UNCOV

631

          longAck.respondingOpCode() == OPC_IMM_PACKET && longAck.ack1 == 0x7F &&

×

632

          Uhlenbrock::LNCVWrite::check(lastSentMessage()))

×

UNCOV

634

        const auto& lncvWrite = static_cast<const Uhlenbrock::LNCVWrite&>(lastSentMessage());

×

635

        if(lncvWrite.lncv() == 0)

×

UNCOV

637

          m_lncvModuleAddress = lncvWrite.value();

×

UNCOV

640

        EventLoop::call(

×

641

          [this, lncvWrite]()

×

UNCOV

643

            m_onLNCVReadResponse(true, lncvWrite.lncv(), lncvWrite.value());

×

644

});

×

646

      break;

×

UNCOV

648

    case OPC_SLOT_STAT1:

×

649

      break; // unimplemented

×

UNCOV

651

    case OPC_CONSIST_FUNC:

×

652

      break; // unimplemented

×

UNCOV

654

    case OPC_UNLINK_SLOTS:

×

655

      break; // unimplemented

×

UNCOV

657

    case OPC_LINK_SLOTS:

×

658

      break; // unimplemented

×

UNCOV

660

    case OPC_MOVE_SLOTS:

×

661

      break; // unimplemented

×

UNCOV

663

    case OPC_RQ_SL_DATA:

×

664

      break; // unimplemented

×

UNCOV

666

    case OPC_SW_STATE:

×

667

      break; // unimplemented

×

UNCOV

669

    case OPC_SW_ACK:

×

670

      break; // unimplemented

×

UNCOV

672

    case OPC_LOCO_ADR:

×

673

      break; // unimplemented

×

675

    case OPC_MULTI_SENSE:

×

UNCOV

677

      const auto& multiSense = static_cast<const MultiSense&>(message);

×

678

      if(multiSense.isTransponder())

×

UNCOV

680

        EventLoop::call(

×

681

          [this, multiSenseTransponder=static_cast<const MultiSenseTransponder&>(multiSense)]()

×

683

            m_identificationController->identificationEvent(

×

685

              1 + multiSenseTransponder.sensorAddress(),

×

UNCOV

686

              multiSenseTransponder.isPresent() ? IdentificationEventType::Present : IdentificationEventType::Absent,

×

UNCOV

687

              multiSenseTransponder.transponderAddress(),

×

690

});

×

692

      break;

×

UNCOV

694

    case OPC_D4:

×

695

      if(m_decoderController)

×

UNCOV

697

        const auto* bytes = reinterpret_cast<const uint8_t*>(&message);

×

698

        if(bytes[1] == 0x20)

×

700

          switch(bytes[3])

×

702

            case 0x08:

×

UNCOV

704

              const auto& locoF13F19 = static_cast<const LocoF13F19&>(message);

×

705

              if(LocoSlot* slot = getLocoSlot(locoF13F19.slot))

×

707

                if(!slot->isAddressValid())

×

709

                  send(RequestSlotData(locoF13F19.slot));

×

711

                updateFunctions<13, 19>(*slot, locoF13F19);

×

713

              break;

×

715

            case 0x05:

×

UNCOV

717

              const auto& locoF12F20F28 = static_cast<const LocoF12F20F28&>(message);

×

718

              if(LocoSlot* slot = getLocoSlot(locoF12F20F28.slot))

×

720

                if(!slot->isAddressValid())

×

UNCOV

722

                  send(RequestSlotData(locoF12F20F28.slot));

×

726

                  slot->functions[12] != locoF12F20F28.f12() ||

×

UNCOV

727

                  slot->functions[20] != locoF12F20F28.f20() ||

×

728

                  slot->functions[28] != locoF12F20F28.f28();

×

730

                if(changed)

×

732

                  slot->functions[12] = toTriState(locoF12F20F28.f12());

×

UNCOV

733

                  slot->functions[20] = toTriState(locoF12F20F28.f20());

×

734

                  slot->functions[28] = toTriState(locoF12F20F28.f28());

×

UNCOV

736

                  EventLoop::call(

×

737

                    [this, address=slot->address, f12=locoF12F20F28.f12(), f20=locoF12F20F28.f20(), f28=locoF12F20F28.f28()]()

×

739

                      if(auto decoder = getDecoder(address))

×

741

                        decoder->setFunctionValue(12, f12);

×

742

                        decoder->setFunctionValue(20, f20);

×

743

                        decoder->setFunctionValue(28, f28);

×

UNCOV

744

×

UNCOV

745

});

×

748

              break;

×

750

            case 0x09:

×

UNCOV

752

              const auto& locoF21F27 = static_cast<const LocoF21F27&>(message);

×

753

              if(LocoSlot* slot = getLocoSlot(locoF21F27.slot))

×

755

                if(!slot->isAddressValid())

×

757

                  send(RequestSlotData(locoF21F27.slot));

×

759

                updateFunctions<21, 27>(*slot, locoF21F27);

×

UNCOV

761

              break;

×

766

      break;

×

768

    case OPC_MULTI_SENSE_LONG:

×

UNCOV

770

      const auto& multiSense = static_cast<const MultiSenseLong&>(message);

×

771

      if(multiSense.code() == MultiSenseLong::Code::ReleaseTransponder || multiSense.code() == MultiSenseLong::Code::DetectTransponder)

×

UNCOV

773

        EventLoop::call(

×

774

          [this, multiSense]()

×

776

            m_identificationController->identificationEvent(

×

778

              1 + multiSense.sensorAddress(),

×

UNCOV

779

              multiSense.code()  == MultiSenseLong::Code::DetectTransponder ? IdentificationEventType::Present : IdentificationEventType::Absent,

×

UNCOV

780

              multiSense.transponderAddress(),

×

783

});

×

785

      break;

×

UNCOV

787

    case OPC_E4:

×

788

      if(static_cast<const Uhlenbrock::Lissy&>(message).type() == Uhlenbrock::Lissy::Type::AddressCategoryDirection)

×

UNCOV

790

        EventLoop::call(

×

791

          [this, lissy=static_cast<const Uhlenbrock::LissyAddressCategoryDirection&>(message)]()

×

793

            m_identificationController->identificationEvent(

×

795

              lissy.sensorAddress(),

×

797

              lissy.decoderAddress(),

×

UNCOV

799

              lissy.category());

×

800

});

×

802

      break;

×

UNCOV

804

    case OPC_PEER_XFER:

×

805

      if(isResponse)

×

807

        if(Uhlenbrock::ReadSpecialOptionReply::check(message))

×

809

          [[maybe_unused]] const auto& readSpecialOptionReply = static_cast<const Uhlenbrock::ReadSpecialOptionReply&>(message);

×

811

        else if(m_onLNCVReadResponse && Uhlenbrock::LNCVReadResponse::check(message))

×

UNCOV

813

          const auto& lncvReadResponse = static_cast<const Uhlenbrock::LNCVReadResponse&>(message);

×

814

          if(lncvReadResponse.lncv() == 0)

×

UNCOV

816

            m_lncvActive = true;

×

UNCOV

817

            m_lncvModuleAddress = lncvReadResponse.value();

×

UNCOV

820

          EventLoop::call(

×

821

            [this, lncvReadResponse]()

×

UNCOV

823

              m_onLNCVReadResponse(true, lncvReadResponse.lncv(), lncvReadResponse.value());

×

UNCOV

824

});

×

827

      break;

×

UNCOV

829

    case OPC_IMM_PACKET:

×

830

      if(m_decoderController)

×

832

        if(isSignatureMatch<LocoF9F12IMMShortAddress>(message))

×

834

          const auto& locoF9F12 = static_cast<const LocoF9F12IMMShortAddress&>(message);

×

UNCOV

835

          if(LocoSlot* slot = getLocoSlotByAddress(locoF9F12.address()))

×

836

            updateFunctions<9, 12>(*slot, locoF9F12);

×

838

            send(LocoAdr(locoF9F12.address()));

×

840

        else if(isSignatureMatch<LocoF9F12IMMLongAddress>(message))

×

842

          const auto& locoF9F12 = static_cast<const LocoF9F12IMMLongAddress&>(message);

×

UNCOV

843

          if(LocoSlot* slot = getLocoSlotByAddress(locoF9F12.address()))

×

844

            updateFunctions<9, 12>(*slot, locoF9F12);

×

846

            send(LocoAdr(locoF9F12.address()));

×

848

        else if(isSignatureMatch<LocoF13F20IMMShortAddress>(message))

×

850

          const auto& locoF13F20 = static_cast<const LocoF13F20IMMShortAddress&>(message);

×

UNCOV

851

          if(LocoSlot* slot = getLocoSlotByAddress(locoF13F20.address()))

×

852

            updateFunctions<13, 20>(*slot, locoF13F20);

×

854

            send(LocoAdr(locoF13F20.address()));

×

856

        else if(isSignatureMatch<LocoF13F20IMMLongAddress>(message))

×

858

          const auto& locoF13F20 = static_cast<const LocoF13F20IMMLongAddress&>(message);

×

UNCOV

859

          if(LocoSlot* slot = getLocoSlotByAddress(locoF13F20.address()))

×

860

            updateFunctions<13, 20>(*slot, locoF13F20);

×

862

            send(LocoAdr(locoF13F20.address()));

×

864

        else if(isSignatureMatch<LocoF21F28IMMShortAddress>(message))

×

866

          const auto& locoF21F28 = static_cast<const LocoF21F28IMMShortAddress&>(message);

×

UNCOV

867

          if(LocoSlot* slot = getLocoSlotByAddress(locoF21F28.address()))

×

868

            updateFunctions<21, 28>(*slot, locoF21F28);

×

870

            send(LocoAdr(locoF21F28.address()));

×

872

        else if(isSignatureMatch<LocoF21F28IMMLongAddress>(message))

×

874

          const auto& locoF21F28 = static_cast<const LocoF21F28IMMLongAddress&>(message);

×

UNCOV

875

          if(LocoSlot* slot = getLocoSlotByAddress(locoF21F28.address()))

×

876

            updateFunctions<21, 28>(*slot, locoF21F28);

×

UNCOV

878

            send(LocoAdr(locoF21F28.address()));

×

881

      break; // unimplemented

×

UNCOV

883

    case OPC_WR_SL_DATA:

×

UNCOV

884

      break; // unimplemented

×

887

  if(m_waitingForResponse && isResponse)

×

889

    m_waitingForResponse = false;

×

890

    m_waitingForResponseTimer.cancel();

×

UNCOV

891

    m_sendQueue[m_sentMessagePriority].pop();

×

892

    sendNextMessage();

×

894

×

896

void Kernel::setState(bool powerOn, bool run)

×

UNCOV

898

  assert(isEventLoopThread());

×

899

  m_ioContext.post(

×

900

    [this, powerOn, run]()

×

902

      if(!powerOn) // disable power

×

904

        if(m_emergencyStop != TriState::True)

×

UNCOV

906

          send(Idle(), HighPriority); // estop trains

×

908

        if(m_globalPower != TriState::False)

×

UNCOV

910

          send(GlobalPowerOff(), HighPriority);

×

915

        if(m_globalPower != TriState::True) // enable power

×

917

          send(GlobalPowerOn(), HighPriority);

×

919

        if(run && m_emergencyStop != TriState::False)

×

921

          EventLoop::call(std::bind_front(&Kernel::resume, this));

×

923

        else if(!run && m_emergencyStop != TriState::True)

×

925

          send(Idle(), HighPriority); // estop trains

×

928

});

×

UNCOV

929

×

931

void Kernel::resume()

×

UNCOV

933

  assert(isEventLoopThread());

×

UNCOV

935

  auto& list = *m_decoderController->decoders.value();

×

936

  for(const auto& decoder : list)

×

UNCOV

938

    decoderChanged(*decoder, DecoderChangeFlags::EmergencyStop | DecoderChangeFlags::Direction | DecoderChangeFlags::Throttle | DecoderChangeFlags::SpeedSteps, 0);

×

940

    if(decoder->hasFunction(5) ||

×

941

        decoder->hasFunction(6) ||

×

UNCOV

942

        decoder->hasFunction(7) ||

×

943

        decoder->hasFunction(8))

×

945

      decoderChanged(*decoder, DecoderChangeFlags::FunctionValue, 5); // trigger F5-F8 update

×

947

    if(decoder->hasFunction(9) ||

×

948

        decoder->hasFunction(10) ||

×

UNCOV

949

        decoder->hasFunction(11) ||

×

950

        decoder->hasFunction(12))

×

UNCOV

952

      decoderChanged(*decoder, DecoderChangeFlags::FunctionValue, 9); // trigger F9-F12 update

×

954

    if(decoder->hasFunction(13) ||

×

UNCOV

955

        decoder->hasFunction(14) ||

×

956

        decoder->hasFunction(15) ||

×

957

        decoder->hasFunction(16) ||

×

UNCOV

958

        decoder->hasFunction(17) ||

×

959

        decoder->hasFunction(18) ||

×

960

        decoder->hasFunction(19) ||

×

UNCOV

961

        decoder->hasFunction(20))

×

963

      decoderChanged(*decoder, DecoderChangeFlags::FunctionValue, 13); // trigger F13-F20 update

×

965

    if(decoder->hasFunction(21) ||

×

UNCOV

966

        decoder->hasFunction(22) ||

×

967

        decoder->hasFunction(23) ||

×

UNCOV

968

        decoder->hasFunction(24) ||

×

969

        decoder->hasFunction(25) ||

×

970

        decoder->hasFunction(26) ||

×

UNCOV

971

        decoder->hasFunction(27) ||

×

972

        decoder->hasFunction(28))

×

UNCOV

974

      decoderChanged(*decoder, DecoderChangeFlags::FunctionValue, 21); // trigger F21-F28 update

×

UNCOV

977

×

UNCOV

979

bool Kernel::send(std::span<uint8_t> packet)

×

UNCOV

981

  assert(isEventLoopThread());

×

983

  if(reinterpret_cast<Message*>(packet.data())->size() != packet.size() + 1) // verify packet length, must be all bytes excluding checksum

×

UNCOV

984

    return false;

×

986

  std::vector<uint8_t> data(packet.data(), packet.data() + packet.size());

×

987

  data.push_back(calcChecksum(*reinterpret_cast<Message*>(data.data())));

×

UNCOV

989

  if(!isValid(*reinterpret_cast<Message*>(data.data())))

×

UNCOV

990

    return false;

×

UNCOV

992

  m_ioContext.post(

×

993

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

×

UNCOV

995

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

×

UNCOV

996

});

×

998

  return true;

×

999

×

1001

bool Kernel::immPacket(std::span<const uint8_t> dccPacket, uint8_t repeat)

×

UNCOV

1003

  assert(isEventLoopThread());

×

UNCOV

1005

  if(dccPacket.size() > ImmPacket::dccPacketSizeMax || repeat > ImmPacket::repeatMax)

×

UNCOV

1006

    return false;

×

1008

  postSend(ImmPacket(dccPacket, repeat));

×

1009

  return true;

×

UNCOV

1012

void Kernel::decoderChanged(const Decoder& decoder, DecoderChangeFlags changes, uint32_t functionNumber)

×

UNCOV

1014

  assert(isEventLoopThread());

×

UNCOV

1016

  if(has(changes, DecoderChangeFlags::EmergencyStop | DecoderChangeFlags::Throttle))

×

UNCOV

1018

    const auto speedStep = Decoder::throttleToSpeedStep<uint8_t>(decoder.throttle, SPEED_MAX - 1);

×

1019

    if(m_emergencyStop == TriState::False || decoder.emergencyStop || speedStep == SPEED_STOP)

×

UNCOV

1022

      LocoSpd message{static_cast<uint8_t>(decoder.emergencyStop ? SPEED_ESTOP : (speedStep > 0 ? 1 + speedStep : SPEED_STOP))};

×

1023

      postSend(decoder.address, message);

×

UNCOV

1027

  if(has(changes, DecoderChangeFlags::FunctionValue | DecoderChangeFlags::Direction))

×

1029

    if(functionNumber <= 4 || has(changes, DecoderChangeFlags::Direction))

×

UNCOV

1033

        decoder.getFunctionValue(0),

×

UNCOV

1034

        decoder.getFunctionValue(1),

×

1035

        decoder.getFunctionValue(2),

×

1036

        decoder.getFunctionValue(3),

×

UNCOV

1037

        decoder.getFunctionValue(4)};

×

1038

      postSend(decoder.address, message);

×

1040

    else if(functionNumber <= 8)

×

UNCOV

1043

        decoder.getFunctionValue(5),

×

1044

        decoder.getFunctionValue(6),

×

UNCOV

1045

        decoder.getFunctionValue(7),

×

1046

        decoder.getFunctionValue(8)};

×

UNCOV

1047

      postSend(decoder.address, message);

×

1049

    else if(functionNumber <= 28)

×

1051

      switch(m_config.f9f28)

×

1053

        case LocoNetF9F28::IMMPacket:

×

1055

          const bool longAddress = decoder.protocol == DecoderProtocol::DCCLong;

×

1057

          if(functionNumber <= 12)

×

UNCOV

1059

            if(longAddress)

×

UNCOV

1061

              postSend(

×

1062

                LocoF9F12IMMLongAddress(

×

UNCOV

1064

                  decoder.getFunctionValue(9),

×

1065

                  decoder.getFunctionValue(10),

×

1066

                  decoder.getFunctionValue(11),

×

1067

                  decoder.getFunctionValue(12)));

×

1071

              postSend(

×

1072

                LocoF9F12IMMShortAddress(

×

UNCOV

1074

                  decoder.getFunctionValue(9),

×

1075

                  decoder.getFunctionValue(10),

×

UNCOV

1076

                  decoder.getFunctionValue(11),

×

1077

                  decoder.getFunctionValue(12)));

×

1080

          else if(functionNumber <= 20)

×

1082

            if(longAddress)

×

1084

              postSend(

×

1085

                LocoF13F20IMMLongAddress(

×

1087

                  decoder.getFunctionValue(13),

×

1088

                  decoder.getFunctionValue(14),

×

1089

                  decoder.getFunctionValue(15),

×

UNCOV

1090

                  decoder.getFunctionValue(16),

×

UNCOV

1091

                  decoder.getFunctionValue(17),

×

UNCOV

1092

                  decoder.getFunctionValue(18),

×

1093

                  decoder.getFunctionValue(19),

×

1094

                  decoder.getFunctionValue(20)));

×

1098

              postSend(

×

1099

                LocoF13F20IMMShortAddress(

×

1101

                  decoder.getFunctionValue(13),

×

1102

                  decoder.getFunctionValue(14),

×

1103

                  decoder.getFunctionValue(15),

×

UNCOV

1104

                  decoder.getFunctionValue(16),

×

UNCOV

1105

                  decoder.getFunctionValue(17),

×

1106

                  decoder.getFunctionValue(18),

×

UNCOV

1107

                  decoder.getFunctionValue(19),

×

1108

                  decoder.getFunctionValue(20)));

×

UNCOV

1111

          else if(functionNumber <= 28)

×

1113

            if(longAddress)

×

1115

              postSend(

×

1116

                LocoF21F28IMMLongAddress(

×

1118

                  decoder.getFunctionValue(21),

×

UNCOV

1119

                  decoder.getFunctionValue(22),

×

UNCOV

1120

                  decoder.getFunctionValue(23),

×

1121

                  decoder.getFunctionValue(24),

×

1122

                  decoder.getFunctionValue(25),

×

1123

                  decoder.getFunctionValue(26),

×

1124

                  decoder.getFunctionValue(27),

×

1125

                  decoder.getFunctionValue(28)));

×

UNCOV

1129

              postSend(

×

1130

                LocoF21F28IMMShortAddress(

×

UNCOV

1132

                  decoder.getFunctionValue(21),

×

1133

                  decoder.getFunctionValue(22),

×

1134

                  decoder.getFunctionValue(23),

×

1135

                  decoder.getFunctionValue(24),

×

1136

                  decoder.getFunctionValue(25),

×

1137

                  decoder.getFunctionValue(26),

×

1138

                  decoder.getFunctionValue(27),

×

UNCOV

1139

                  decoder.getFunctionValue(28)));

×

1142

          break;

×

1144

        case LocoNetF9F28::UhlenbrockExtended:

×

1145

          if(functionNumber <= 12)

×

1148

              decoder.getFunctionValue(9),

×

UNCOV

1149

              decoder.getFunctionValue(10),

×

1150

              decoder.getFunctionValue(11),

×

UNCOV

1151

              decoder.getFunctionValue(12)};

×

1152

            postSend(decoder.address, message);

×

UNCOV

1154

          else if(functionNumber <= 19)

×

UNCOV

1157

              decoder.getFunctionValue(13),

×

1158

              decoder.getFunctionValue(14),

×

UNCOV

1159

              decoder.getFunctionValue(15),

×

1160

              decoder.getFunctionValue(16),

×

UNCOV

1161

              decoder.getFunctionValue(17),

×

1162

              decoder.getFunctionValue(18),

×

UNCOV

1163

              decoder.getFunctionValue(19)};

×

1164

            postSend(decoder.address, message);

×

1166

          else if(functionNumber == 20 || functionNumber == 28)

×

UNCOV

1169

              decoder.getFunctionValue(12),

×

1170

              decoder.getFunctionValue(20),

×

1171

              decoder.getFunctionValue(28)};

×

UNCOV

1172

            postSend(decoder.address, message);

×

1173

×

1174

          else if(functionNumber <= 27)

×

1177

              decoder.getFunctionValue(21),

×

UNCOV

1178

              decoder.getFunctionValue(22),

×

1179

              decoder.getFunctionValue(23),

×

1180

              decoder.getFunctionValue(24),

×

1181

              decoder.getFunctionValue(25),

×

UNCOV

1182

              decoder.getFunctionValue(26),

×

1183

              decoder.getFunctionValue(27)};

×

1184

            postSend(decoder.address, message);

×

UNCOV

1186

          break;

×

UNCOV

1188

        default:

×

UNCOV

1189

          assert(false);

×

1194

×

1196

bool Kernel::setOutput(OutputChannel channel, uint16_t address, OutputValue value)

×

1198

  assert(isEventLoopThread());

×

1200

  switch(channel)

×

1202

    case OutputChannel::Accessory:

×

1203

      if(!inRange(address, accessoryOutputAddressMin, accessoryOutputAddressMax))

×

UNCOV

1204

        return false;

×

1206

      m_ioContext.post(

×

1207

        [this, address, dir=std::get<OutputPairValue>(value) == OutputPairValue::Second]()

×

UNCOV

1209

          send(SwitchRequest(address, dir, true));

×

1210

});

×

1211

      return true;

×

UNCOV

1213

    case OutputChannel::DCCext:

×

1215

        inRange(address, DCC::Accessory::addressMin, DCC::Accessory::addressMax) &&

×

UNCOV

1216

        inRange<int16_t>(std::get<int16_t>(value), std::numeric_limits<uint8_t>::min(), std::numeric_limits<uint8_t>::max()) &&

×

1217

        immPacket(DCC::SetAdvancedAccessoryValue(address, static_cast<uint8_t>(std::get<int16_t>(value))), 2);

×

1219

    default: /*[[unlikely]]*/

×

1220

      assert(false);

×

1226

void Kernel::simulateInputChange(uint16_t address, SimulateInputAction action)

×

1228

  assert(isEventLoopThread());

×

1229

  assert(inRange(address, inputAddressMin, inputAddressMax));

×

UNCOV

1230

  if(m_simulation)

×

1231

    m_ioContext.post(

×

UNCOV

1232

      [this, fullAddress=address - 1, action]()

×

UNCOV

1234

        switch(action)

×

1236

            case SimulateInputAction::SetFalse:

×

1237

              if(m_inputValues[fullAddress] != TriState::False)

×

UNCOV

1238

                receive(InputRep(fullAddress, false));

×

1239

              break;

×

1241

            case SimulateInputAction::SetTrue:

×

1242

              if(m_inputValues[fullAddress] != TriState::True)

×

UNCOV

1243

                receive(InputRep(fullAddress, true));

×

1244

              break;

×

1246

            case SimulateInputAction::Toggle:

×

1247

              receive(InputRep(fullAddress, m_inputValues[fullAddress] != TriState::True));

×

1248

              break;

×

1250

});

×

1251

×

1253

void Kernel::lncvStart(uint16_t moduleId, uint16_t moduleAddress)

×

1255

  assert(isEventLoopThread());

×

UNCOV

1256

  m_ioContext.post(

×

1257

    [this, moduleId, moduleAddress]()

×

1259

      if(m_lncvActive)

×

UNCOV

1260

        return;

×

1262

      m_lncvActive = true;

×

UNCOV

1263

      m_lncvModuleId = moduleId;

×

1264

      m_lncvModuleAddress = moduleAddress;

×

1265

      send(Uhlenbrock::LNCVStart(m_lncvModuleId, m_lncvModuleAddress), HighPriority);

×

1267

×

1269

void Kernel::lncvRead(uint16_t lncv)

×

1271

  assert(isEventLoopThread());

×

1272

  m_ioContext.post(

×

1273

    [this, lncv]()

×

UNCOV

1275

      if(m_lncvActive)

×

1276

        send(Uhlenbrock::LNCVRead(m_lncvModuleId, m_lncvModuleAddress, lncv), HighPriority);

×

UNCOV

1277

});

×

1278

×

1280

void Kernel::lncvWrite(uint16_t lncv, uint16_t value)

×

UNCOV

1282

  assert(isEventLoopThread());

×

1283

  m_ioContext.post(

×

1284

    [this, lncv, value]()

×

1286

      if(m_lncvActive)

×

1287

        send(Uhlenbrock::LNCVWrite(m_lncvModuleId, lncv, value), HighPriority);

×

1288

});

×

UNCOV

1289

×

1291

void Kernel::lncvStop()

×

UNCOV

1293

  assert(isEventLoopThread());

×

1294

  m_ioContext.post(

×

UNCOV

1295

    [this]()

×

UNCOV

1297

      if(!m_lncvActive)

×

1298

        return;

×

UNCOV

1300

      send(Uhlenbrock::LNCVStop(m_lncvModuleId, m_lncvModuleAddress), HighPriority);

×

1301

      m_lncvActive = false;

×

UNCOV

1303

×

1305

void Kernel::setOnLNCVReadResponse(OnLNCVReadResponse callback)

×

UNCOV

1307

  assert(isEventLoopThread());

×

1308

  assert(!m_started);

×

UNCOV

1309

  m_onLNCVReadResponse = std::move(callback);

×

1310

×

1312

Kernel::LocoSlot* Kernel::getLocoSlot(uint8_t slot, bool sendSlotDataRequestIfNew)

×

UNCOV

1314

  assert(isKernelThread());

×

1316

  if(!isLocoSlot(slot))

×

1317

    return nullptr;

×

1319

  auto it = m_slots.find(slot);

×

UNCOV

1320

  if(it == m_slots.end())

×

1322

    if(sendSlotDataRequestIfNew)

×

UNCOV

1323

      send(RequestSlotData(slot));

×

UNCOV

1324

    it = m_slots.emplace(slot, LocoSlot()).first;

×

1327

  return &it->second;

×

1330

Kernel::LocoSlot* Kernel::getLocoSlotByAddress(uint16_t address)

×

UNCOV

1332

  assert(isKernelThread());

×

UNCOV

1334

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

×

1335

    [address](auto& item)

×

1337

      assert(address != LocoSlot::invalidAddress);

×

1338

      return item.second.address == address;

×

UNCOV

1341

  return it != m_slots.end() ? &it->second : nullptr;

×

UNCOV

1344

void Kernel::clearLocoSlot(uint8_t slot)

×

1346

  assert(isKernelThread());

×

UNCOV

1348

  if(auto it = m_slots.find(slot); it != m_slots.end())

×

UNCOV

1349

    m_slots.erase(it);

×

UNCOV

1351

  if(auto it = std::find_if(m_addressToSlot.begin(), m_addressToSlot.end(), [slot](const auto& item){ return item.second == slot; }); it != m_addressToSlot.end())

×

1352

    m_addressToSlot.erase(it);

×

UNCOV

1353

×

UNCOV

1355

std::shared_ptr<Decoder> Kernel::getDecoder(uint16_t address)

×

UNCOV

1357

  assert(isEventLoopThread());

×

1358

  return m_decoderController->getDecoder(DCC::getProtocol(address), address);

×

1361

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

×

1363

  assert(isEventLoopThread());

×

1364

  assert(handler);

×

UNCOV

1365

  assert(!m_ioHandler);

×

UNCOV

1366

  m_ioHandler = std::move(handler);

×

UNCOV

1367

×

UNCOV

1369

void Kernel::send(const Message& message, Priority priority)

×

1371

  assert(isKernelThread());

×

1373

  if(m_config.listenOnly)

×

1374

    return; // drop it

×

UNCOV

1376

  if(!m_sendQueue[priority].append(message))

×

UNCOV

1379

    return;

×

UNCOV

1382

  if(!m_waitingForEcho && !m_waitingForResponse)

×

1383

    sendNextMessage();

×

UNCOV

1386

void Kernel::send(uint16_t address, Message& message, uint8_t& slot)

×

UNCOV

1388

  assert(isKernelThread());

×

UNCOV

1390

  if(auto addressToSlot = m_addressToSlot.find(address); addressToSlot != m_addressToSlot.end())

×

1392

    slot = addressToSlot->second;

×

1394

    if(message.opCode == OPC_LOCO_SPD &&

×

UNCOV

1395

        static_cast<LocoSpd&>(message).speed >= SPEED_MIN &&

×

1396

        static_cast<LocoSpd&>(message).speed == m_slots[slot].speed)

×

UNCOV

1397

      return; // same speed, don't send it (always send ESTOP and STOP)

×

1399

    updateChecksum(message);

×

1400

    send(message);

×

UNCOV

1404

    auto* ptr = reinterpret_cast<std::byte*>(&message);

×

1406

    auto pendingSlotMessage = m_pendingSlotMessages.find(address);

×

UNCOV

1407

    if(pendingSlotMessage == m_pendingSlotMessages.end())

×

UNCOV

1409

      m_pendingSlotMessages[address].assign(ptr, ptr + message.size());

×

UNCOV

1410

      send(LocoAdr{address}, HighPriority);

×

UNCOV

1413

      pendingSlotMessage->second.insert(pendingSlotMessage->second.end(), ptr, ptr + message.size());

×

UNCOV

1417

void Kernel::sendNextMessage()

×

UNCOV

1419

  assert(isKernelThread());

×

1421

  for(Priority priority = HighPriority; priority <= LowPriority; ++priority)

×

1423

    if(!m_sendQueue[priority].empty())

×

UNCOV

1425

      const Message& message = m_sendQueue[priority].front();

×

1427

      if(m_config.debugLogRXTX)

×

UNCOV

1428

        EventLoop::call([this, msg=toString(message)](){ Log::log(logId, LogMessage::D2001_TX_X, msg); });

×

1430

      if(m_ioHandler->send(message))

×

1432

        m_sentMessagePriority = priority;

×

1434

        m_waitingForEcho = true;

×

1435

        m_waitingForEchoTimer.expires_after(boost::asio::chrono::milliseconds(m_config.echoTimeout));

×

UNCOV

1436

        m_waitingForEchoTimer.async_wait(std::bind(&Kernel::waitingForEchoTimerExpired, this, std::placeholders::_1));

×

UNCOV

1438

        m_waitingForResponse = hasResponse(message);

×

1439

        if(m_waitingForResponse)

×

UNCOV

1441

          m_waitingForResponseTimer.expires_after(boost::asio::chrono::milliseconds(m_config.responseTimeout));

×

1442

          m_waitingForResponseTimer.async_wait(std::bind(&Kernel::waitingForResponseTimerExpired, this, std::placeholders::_1));

×

UNCOV

1447

      return;

×

1452

void Kernel::waitingForEchoTimerExpired(const boost::system::error_code& ec)

×

UNCOV

1454

  assert(isKernelThread());

×

1456

  if(ec)

×

1457

    return;

×

UNCOV

1459

  EventLoop::call(

×

UNCOV

1460

    [this]()

×

UNCOV

1462

      Log::log(logId, LogMessage::W2018_TIMEOUT_NO_ECHO_WITHIN_X_MS, m_config.echoTimeout);

×

1463

});

×

1466

void Kernel::waitingForResponseTimerExpired(const boost::system::error_code& ec)

×

1468

  assert(isKernelThread());

×

1470

  if(ec)

×

1471

    return;

×

1473

  if(m_lncvActive && Uhlenbrock::LNCVStart::check(lastSentMessage()))

×

UNCOV

1475

    EventLoop::call(

×

UNCOV

1476

      [this, lncvStart=static_cast<const Uhlenbrock::LNCVStart&>(lastSentMessage())]()

×

1478

        Log::log(logId, LogMessage::N2002_NO_RESPONSE_FROM_LNCV_MODULE_X_WITH_ADDRESS_X, lncvStart.moduleId(), lncvStart.address());

×

1480

        if(m_onLNCVReadResponse && m_lncvModuleId == lncvStart.moduleId())

×

UNCOV

1481

          m_onLNCVReadResponse(false, lncvStart.address(), 0);

×

1482

});

×

UNCOV

1484

    sendNextMessage();

×

1488

    EventLoop::call(

×

UNCOV

1489

      [this]()

×

1491

        Log::log(logId, LogMessage::E2019_TIMEOUT_NO_RESPONSE_WITHIN_X_MS, m_config.responseTimeout);

×

UNCOV

1492

        error();

×

1493

});

×

1497

void Kernel::setFastClockMaster(bool enable)

×

1499

  assert(isKernelThread());

×

1500

  if(enable)

×

1502

    const auto clock = m_fastClock.load();

×

UNCOV

1503

    FastClockSlotWriteData fastClock;

×

UNCOV

1504

    fastClock.clk_rate = clock.multiplier;

×

1505

    fastClock.setHour(clock.hour);

×

UNCOV

1506

    fastClock.setMinute(clock.minute);

×

1507

    fastClock.setValid(true);

×

1508

    fastClock.setId(idTraintastic);

×

1509

    updateChecksum(fastClock);

×

1510

    send(fastClock, HighPriority);

×

1513

    send(FastClockSlotWriteData(), HighPriority);

×

UNCOV

1514

×

1516

void Kernel::disableClockEvents()

×

UNCOV

1518

  m_clockChangeConnection.disconnect();

×

1519

×

1521

void Kernel::enableClockEvents()

×

1523

  if(m_clockChangeConnection.connected() || !m_clock)

×

1524

    return;

×

1526

  m_clockChangeConnection = m_clock->onChange.connect(

×

UNCOV

1527

    [this](Clock::ClockEvent event, uint8_t multiplier, Time time)

×

UNCOV

1529

      m_fastClock.store(FastClock{event == Clock::ClockEvent::Freeze ? multiplierFreeze : multiplier, time.hour(), time.minute()});

×

UNCOV

1530

      if(event == Clock::ClockEvent::Freeze || event == Clock::ClockEvent::Resume)

×

1532

        m_ioContext.post(

×

UNCOV

1533

          [this]()

×

UNCOV

1535

            setFastClockMaster(true);

×

1536

});

×

UNCOV

1538

});

×

1541

void Kernel::startFastClockSyncTimer()

×

UNCOV

1543

  assert(isKernelThread());

×

UNCOV

1544

  assert(m_config.fastClockSyncInterval > 0);

×

UNCOV

1545

  m_fastClockSyncTimer.expires_after(boost::asio::chrono::seconds(m_config.fastClockSyncInterval));

×

1546

  m_fastClockSyncTimer.async_wait(std::bind(&Kernel::fastClockSyncTimerExpired, this, std::placeholders::_1));

×

1547

×

1549

void Kernel::stopFastClockSyncTimer()

×

1551

  assert(isKernelThread());

×

UNCOV

1552

  m_fastClockSyncTimer.cancel();

×

UNCOV

1553

×

UNCOV

1555

void Kernel::fastClockSyncTimerExpired(const boost::system::error_code& ec)

×

1557

  assert(isKernelThread());

×

1559

  if(ec || !m_config.fastClockSyncEnabled || !m_fastClockSupported)

×

1560

    return;

×

1562

  send(RequestSlotData(SLOT_FAST_CLOCK));

×

UNCOV

1564

  startFastClockSyncTimer();

×

1568

bool Kernel::updateFunctions(LocoSlot& slot, const T& message)

×

1570

  assert(isKernelThread());

×

1572

  bool changed = false;

×

UNCOV

1573

  for(uint8_t i = First; i <= Last; ++i)

×

1575

    if(slot.functions[i] != message.f(i))

×

1577

      slot.functions[i] = toTriState(message.f(i));

×

1578

      changed = true;

×

UNCOV

1582

  EventLoop::call(

×

UNCOV

1583

    [this, address=slot.address, message]()

×

1585

      if(auto decoder = getDecoder(address))

×

UNCOV

1586

        for(uint8_t i = First; i <= Last; ++i)

×

1587

          decoder->setFunctionValue(i, message.f(i));

×

1590

  return changed;

×

1593

void Kernel::startPCAP(PCAPOutput pcapOutput)

×

UNCOV

1595

  assert(isKernelThread());

×

UNCOV

1596

  assert(!m_pcap);

×

UNCOV

1598

  const uint32_t DLT_USER0 = 147; //! \todo change to LocoNet DLT once it is registered

×

1602

    switch(pcapOutput)

×

1604

      case PCAPOutput::File:

×

UNCOV

1606

        const auto filename = m_debugDir / logId += dateTimeStr() += ".pcap";

×

UNCOV

1607

        EventLoop::call(

×

1608

          [this, filename]()

×

1610

            Log::log(logId, LogMessage::N2004_STARTING_PCAP_FILE_LOG_X, filename);

×

1611

});

×

1612

        m_pcap = std::make_unique<PCAPFile>(filename, DLT_USER0);

×

UNCOV

1613

        break;

×

1614

×

1615

      case PCAPOutput::Pipe:

×

1617

        std::filesystem::path pipe;

×

UNCOV

1621

        pipe = std::filesystem::temp_directory_path() / "traintastic-server" / logId;

×

1623

        EventLoop::call(

×

1624

          [this, pipe]()

×

1626

            Log::log(logId, LogMessage::N2005_STARTING_PCAP_LOG_PIPE_X, pipe);

×

UNCOV

1627

});

×

1628

        m_pcap = std::make_unique<PCAPPipe>(std::move(pipe), DLT_USER0);

×

1629

        break;

×

UNCOV

1630

×

1633

  catch(const std::exception& e)

×

1635

    EventLoop::call(

×

1636

      [this, what=std::string(e.what())]()

×

UNCOV

1638

        Log::log(logId, LogMessage::E2021_STARTING_PCAP_LOG_FAILED_X, what);

×

UNCOV

1639

});

×

UNCOV

1640

×

UNCOV

1641

×

UNCOV

1644

bool Kernel::SendQueue::append(const Message& message)

×

UNCOV

1646

  const uint8_t messageSize = message.size();

×

UNCOV

1647

  if(m_bytes + messageSize > threshold())

×

UNCOV

1648

    return false;

×

UNCOV

1650

  memcpy(m_front + m_bytes, &message, messageSize);

×

UNCOV

1651

  m_bytes += messageSize;

×

UNCOV

1653

  return true;

×

UNCOV

1656

void Kernel::SendQueue::pop()

×

UNCOV

1658

  const uint8_t messageSize = front().size();

×

UNCOV

1659

  m_front += messageSize;

×

UNCOV

1660

  m_bytes -= messageSize;

×

UNCOV

1662

  if(static_cast<std::size_t>(m_front - m_buffer.data()) >= threshold())

×

UNCOV

1664

    memmove(m_buffer.data(), m_front, m_bytes);

×

UNCOV

1665

    m_front = m_buffer.data();

×

UNCOV

1667

×

UNCOV

1669

void Kernel::SendQueue::clear()

×

UNCOV

1671

  m_bytes = 0;

×

UNCOV

1672

×

traintastic / traintastic / 20392201742

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

traintastic / traintastic / 20392201742

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