hybrid_controller.cpp

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later

 
#include "protocol/protocol_oob.h"
#include "redac/calibration.h"
#include "run/run_manager.h"
 
#include <Arduino.h>
 
#include <build/distributor.h>
#include <daq/daq.h>
#include <lucidac/front_panel_signaling.h>
#include <lucidac/lucidac.h>
#include <mode/mode.h>
#include <net/auth.h>
#include <net/settings.h>
#include <plugin/static.h>
#include <protocol/handler.h>
#include <protocol/jsonl_logging.h>
#include <protocol/jsonl_server.h>
#include <protocol/protocol.h>
#include <protocol/registry.h>
#include <redac/redac.h>
#include <utils/crash_report.h>
#include <utils/hashflash.h>
#include <utils/logging.h>
 
void setup() {
  // Initialize serial communication
  Serial.begin(0);
  // while (!Serial && millis() < 4000) {
  //  Wait for Serial, but not forever
  //}
 
  msg::Log::get().sinks.add_Serial();
  msg::Log::get().sinks.add(&msg::StartupLog::get());
 
  bus::init();
 
  LOG_ALWAYS(dist::ident());
  LOGV("Flash image (%d bytes) sha256 sum: %s\n", loader::flashimage::len(),
       loader::flashimage::sha256sum().to_string().c_str());
 
  utils::check_and_log_crash();
 
  // Initialize carrier board
  // TODO, _ERROR_OUT_ shall not be used, see #116
  LOG(ANABRID_DEBUG_INIT, "Detecting and Initializing carrier board...");
  auto &carrier_ = carrier::Carrier::get();
  auto carrier_init_result = carrier_.init();
  if (!carrier_init_result) {
    LOG_ERROR("Error initializing carrier board.");
    LOG_ERROR(carrier_init_result.err_value().c_str());
    leds::indicate_error();
  }
 
  // all LEDs on: Both visual self-test and showing that now ethernet search takes place.
  leds::set(0xFF);
 
  LOG(ANABRID_DEBUG_INIT, "Starting up Ethernet...");
  net::register_settings();
  auto &netconf = net::StartupConfig::get();
  int net_error = netconf.begin_ip();
  if (!net_error && netconf.enable_mdns) {
    LOG_ALWAYS("Starting MDNS");
    netconf.begin_mdns();
  }
  if (!net_error && netconf.enable_jsonl)
    msg::ApplicationServer::get().begin();
  //if (!net_error && netconf.enable_webserver)
  //  web::LucidacWebServer::get().begin();
 
  // Initialize things related to runs
  // TODO: I think mode control must be initialized somewhere here?
  /*
  if (!mode::FlexIOControl::init(mode::DEFAULT_IC_TIME, mode::DEFAULT_OP_TIME)) {
    LOG_ERROR("Error initializing FlexIO mode control.");
    leds::indicate_error();
  }
  */
 
  auto &reg = msg::handlers::Registry::get();
  reg.init(carrier_); // registers all commonly known messages
 
  msg::Broker::get(); // init json lines protocol
 
  // Initialize data acquisition before it's used later
  daq::init();
  if (!daq::calibrate(carrier_)) {
    LOG_ALWAYS("Warning: Error during DAQ calibration. Machine will continue with reduced accuracy.");
  }
 
  // Reset overload line
  carrier_.reset(entities::ResetAction::OVERLOAD_RESET);
 
  // Set computer into IC mode at startup
  mode::RealManualControl::to_ic();
 
  // Run calibration
  LOG(ANABRID_DEBUG_INIT, "Executing self-calibration, this may take a few moments...");
  auto mblock_calibrate_result = carrier_.calibrate_m_blocks();
  if (!mblock_calibrate_result) {
    // Right now, self-calibration is still not well tested and the error handling
    // suggest it fails despite it most likely does not. Therefore, do not make
    // the output so harsh.
    //
    // LOG_ERROR("Error during self-calibration. Machine will continue with reduced accuracy.");
    // leds::indicate_error();
    //
    // instead, do this:
 
    LOG_ALWAYS(mblock_calibrate_result.err_value().c_str());
    LOG_ALWAYS("Info: Startup self-calibration apparently did not succeed. The calibration scheme is by "
               "default not used in this build anyway.");
 
    // For a quick fix, reset machine here because calibration routines exit
    // early which *do* result in a machine in an unusable state.
    carrier_.reset(entities::ResetAction::CIRCUIT_RESET | entities::ResetAction::OVERLOAD_RESET);
    (void)carrier_.write_to_hardware();
  }
 
  // Done.
  LOG(ANABRID_DEBUG_INIT, "Initialization done.");
 
  static_plugin::setup();
 
  platform::CalibrationBase::begin();
 
  // visual effect to show that booting has been done
  leds::ease_out();
}
 
void loop() {
 
  auto &netconf = net::StartupConfig::get();
 
  if (netconf.enable_jsonl)
    msg::ApplicationServer::get().loop();
 
  if (Serial.available()) {
    auto input_stream = std::make_shared<transport::DelimitedInputStream<Stream*>>(&Serial);
    auto output_stream = std::make_shared<transport::DelimitedMessageOutputStream<Stream*>>(&Serial);
    transport::Transport transport(std::move(input_stream), output_stream, std::move(output_stream));
    msg::Broker::get().process(transport);
  }
 
  run::RunManager::get().try_run_next(carrier::Carrier::get());
  static_plugin::loop();
}