driver_base.h

Go to the documentation of this file.

// Copyright 2009-2025:
//   GobySoft, LLC (2013-)
//   Massachusetts Institute of Technology (2007-2014)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Goby Underwater Autonomy Project Libraries
// ("The Goby Libraries").
//
// The Goby Libraries are free software: you can redistribute them and/or modify
// them under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// The Goby Libraries are distributed in the hope that they will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Goby.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef GOBY_ACOMMS_MODEMDRIVER_DRIVER_BASE_H
#define GOBY_ACOMMS_MODEMDRIVER_DRIVER_BASE_H
 
#include <atomic>                    // for atomic
#include <boost/signals2/signal.hpp> // for signal
#include <iosfwd>                    // for ofstream
#include <memory>                    // for shared_ptr, __shared_p...
#include <string>                    // for string
 
#include "goby/acomms/protobuf/driver_base.pb.h" // for DriverCo...
 
namespace goby
{
namespace util
{
class LineBasedInterface;
} // namespace util
 
namespace acomms
{
namespace protobuf
{
class DriverConfig;
class ModemRaw;
class ModemTransmission;
class ModemReport;
} // namespace protobuf
 
class ModemDriverBase
{
  public:
 
 
    virtual void startup(const protobuf::DriverConfig& cfg) = 0;
 
    virtual void update_cfg(const protobuf::DriverConfig& cfg);
 
    virtual void shutdown() = 0;
 
    virtual void do_work() = 0;
 
 
 
 
    virtual void handle_initiate_transmission(const protobuf::ModemTransmission& m) = 0;
 
 
 
    boost::signals2::signal<void(const protobuf::ModemTransmission& message)> signal_receive;
 
    boost::signals2::signal<void(const protobuf::ModemTransmission& message)>
        signal_transmit_result;
 
    boost::signals2::signal<void(protobuf::ModemTransmission* msg)> signal_data_request;
 
    boost::signals2::signal<void(protobuf::ModemTransmission* msg_request)>
        signal_modify_transmission;
 
    boost::signals2::signal<void(const protobuf::ModemRaw& msg)> signal_raw_incoming;
 
    boost::signals2::signal<void(const protobuf::ModemRaw& msg)> signal_raw_outgoing;
 
    virtual ~ModemDriverBase();
 
 
 
    virtual void report(protobuf::ModemReport* report);
 
    int driver_order() { return order_; }
 
    static std::string driver_name(const protobuf::DriverConfig& cfg);
 
  protected:
 
 
    ModemDriverBase();
 
 
 
 
    void modem_write(const std::string& out);
 
    bool modem_read(std::string* in);
 
    void modem_start(const protobuf::DriverConfig& cfg, bool modem_connection_expected = true);
 
    void modem_close();
 
    const std::string& glog_out_group() const { return glog_out_group_; }
    const std::string& glog_in_group() const { return glog_in_group_; }
 
    util::LineBasedInterface& modem() { return *modem_; }
 
  protected:
    static std::atomic<int> count_;
 
  private:
    void write_raw(const protobuf::ModemRaw& msg, bool rx);
 
  private:
    // represents the line based communications interface to the modem
    std::shared_ptr<util::LineBasedInterface> modem_;
 
    std::string glog_out_group_;
    std::string glog_in_group_;
    bool glog_groups_set_{false};
 
    std::shared_ptr<std::ofstream> raw_fs_;
    bool raw_fs_connections_made_{false};
    int order_;
 
    protobuf::DriverConfig cfg_;
};
} // namespace acomms
} // namespace goby
#endif