Здесь есть что раскрыть, поэтому я постараюсь быть кратким.

Когда узел получает сообщение по теме, он не вызывает автоматически функцию обратного вызова. Вам необходимо создать исполнителя, который будет вызывать обратные вызовы подписок, таймеров, серверов служб, серверов действий и т. д. для входящих сообщений и событий.

Дополнительную информацию об исполнителях см. в документации по исполнителям.

Поскольку классы FlightController и Motor наследуют от rclcpp::Node, все экземпляры FlightController и Motor будут разными узлами. Все эти узлы должны быть запущены исполнителем для вызова функций обратного вызова. Вращение объекта контроллера полета не приводит к автоматическому вращению узлов двигателя.

Объекты двигателей полностью инкапсулированы внутри вашего класса FlightController, что делает невозможным вращение этих двигателей снаружи FlightController.

Есть несколько решений этой проблемы

1. Отделение создания объекта от использования объекта

Если вы отделите создание моторных объектов от их использования, у вас не возникнет проблем с вращением узлов. Например, если вы измените FlightController, чтобы он принимал указатели на объекты двигателей в его конструкторе, вот так.

class FlightController : public rclcpp::Node
{
public:
    FlightController(std::shared_ptr<Motor> motor_fl,
                     std::shared_ptr<Motor> motor_fr,
                     std::shared_ptr<Motor> motor_bl,
                     std::shared_ptr<Motor> motor_br)
        : motor_fl_{motor_fl}
        , motor_fr_{motor_fr}
        , motor_bl_{motor_bl}
        , motor_br_{motor_br}
    {
        // do other constructor stuff here.
    }

private:
    std::shared_ptr<Motor> motor_fl_;
    std::shared_ptr<Motor> motor_fr_;
    std::shared_ptr<Motor> motor_bl_;
    std::shared_ptr<Motor> motor_br_;
};

Затем вы можете добавить все узлы к одному исполнителю и запустить его.

int main(int argc, char const* argv[])
{
    rclcpp::init(argc, argv);
    auto motor_fl = std::make_shared<Motor>(/* constructor args for motor */);
    auto motor_fr = std::make_shared<Motor>(/* constructor args for motor */);
    auto motor_bl = std::make_shared<Motor>(/* constructor args for motor */);
    auto motor_br = std::make_shared<Motor>(/* constructor args for motor */);
    auto flight_controller = std::make_shared<FlightController>(motor_fl, motor_fr, motor_bl, motor_br);

    rclcpp::executors::StaticSingleThreadedExecutor executor;
    executor.add_node(motor_fl);
    executor.add_node(motor_fr);
    executor.add_node(motor_br);
    executor.add_node(motor_bl);
    executor.add_node(flight_controller);
    executor.spin();

    rclcpp::shutdown();
}

2. Использование объекта узла в качестве входных данных для вашего конструктора.

Вы не обязаны наследовать от rclcpp::Node. Вы можете легко использовать узел в качестве аргумента конструктора. Например, вы можете изменить классы Motor и FlightController следующим образом.

class Motor // Not inheriting from rclcpp::Node anymore
{
public:
    // Constructor now takes a pointer to a node object.
    Motor(std::shared_ptr<rclcpp::Node> node) : node_{node}
    {
        // Use the pointer to create publishers, subscribers, etc.
        speed_subscription_ = node_->create_subscribtion</*message type*/>(...);
    }

private:
    void speed_callback(const std_msgs::msg::Float64::SharedPtr msg);

    std::shared_ptr<rclcpp::Node> node_;
    rclcpp::Subscription<std_msgs::msg::Float64>::SharedPtr speed_subscription_;
};

class FlightController
{
public:
    FlightController(std::shared_ptr<rclcpp::Node> node)
        : motor_fl_{node}
        , motor_fr_{node}
        , motor_bl_{node}
        , motor_br_{node}
        , node_{node}
    {
        // do other constructor stuff here.
    }

private:
    std::shared_ptr<Motor> motor_fl_;
    std::shared_ptr<Motor> motor_fr_;
    std::shared_ptr<Motor> motor_bl_;
    std::shared_ptr<Motor> motor_br_;
    std::shared_ptr<rclcpp::Node> node_;
};

Затем в вашем основном цикле вы можете создать один объект rclcpp::Node и передать его нескольким классам, например:

int main(int argc, char const* argv[])
{
    rclcpp::init(argc, argv);
    auto node = std::make_shared<rclcpp::Node>("node name");
    auto flight_controller = std::make_shared<FlightController>(node);
    rclcpp::spin(node)

    rclcpp::shutdown();
}

Обратите внимание, что при этом создается только один узел вместо отдельных.

3. Вращайте узлы двигателя внутри вашего FlightController.

Поскольку ваш FlightController имеет метод update, я предполагаю, что вы периодически вызываете этот метод из основного цикла. Вы можете расширить метод update, чтобы в конце вращать двигательные узлы.

void FlightController::update()
{
    // Implementation for updating flight status or performing periodic checks

    rclcpp::spin_some(motor_fl_);
    rclcpp::spin_some(motor_fr_);
    rclcpp::spin_some(motor_bl_);
    rclcpp::spin_some(motor_br_);
}

Дополнительную информацию о spin_some смотрите в этом сообщении на форумах ROS.

4. Создайте отдельные исполняемые файлы.

Функциональность управления двигателем можно выделить в отдельный исполняемый файл. Используя файлы запуска, вы можете легко запустить этот исполняемый файл 4 раза с разными параметрами.

Затем вы можете создать исполняемый файл контроллера полета.

заключение

Я бы рекомендовал комбинацию вариантов 1 и 2, поскольку варианты 3 и 4 влекут за собой большие вычислительные затраты и замедляют работу вашей программы.