mac_manager.h

Go to the documentation of this file.

// Copyright 2010-2023:
//   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_AMAC_MAC_MANAGER_H
#define GOBY_ACOMMS_AMAC_MAC_MANAGER_H
 
#include <boost/signals2/signal.hpp>      // for signal
#include <boost/smart_ptr/shared_ptr.hpp> // for shared_ptr
#include <chrono>                         // for seconds
#include <iosfwd>                         // for ostream
#include <list>                           // for list, list<>::ite...
#include <string>                         // for operator==, string
 
#include "goby/acomms/protobuf/amac_config.pb.h"   // for MACConfig
#include "goby/acomms/protobuf/modem_message.pb.h" // for ModemTransmission
#include "goby/time/system_clock.h"                // for SystemClock, Syst...
 
namespace goby
{
namespace acomms
{
 
 
class MACManager : public std::list<protobuf::ModemTransmission>
{
  public:
 
 
    MACManager();
    MACManager(int id);
    ~MACManager();
 
 
 
    void startup(const protobuf::MACConfig& cfg);
 
    void restart();
 
    void shutdown();
 
    void do_work();
 
    void update();
 
    bool running() { return started_up_; }
 
 
 
 
    boost::signals2::signal<void(const protobuf::ModemTransmission& m)>
        signal_initiate_transmission;
 
 
    boost::signals2::signal<void(const protobuf::ModemTransmission& m)> signal_slot_start;
 
 
    unsigned cycle_count() { return std::list<protobuf::ModemTransmission>::size(); }
    time::SystemClock::duration cycle_duration();
 
    const std::string& glog_mac_group() const { return glog_mac_group_; }
 
  private:
    void begin_slot();
    time::SystemClock::time_point next_cycle_time();
 
    void increment_slot();
 
    void restart_timer();
    void stop_timer();
 
    unsigned cycle_sum();
    void position_blank();
 
    // allowed offset from actual end of slot
 
    const time::SystemClock::duration allowed_skew_{std::chrono::seconds(2)};
 
  private:
    MACManager(const MACManager&);
    MACManager& operator=(const MACManager&);
 
    protobuf::MACConfig cfg_;
 
    // start of the next cycle (cycle = all slots)
    time::SystemClock::time_point next_cycle_t_;
    // start of the next slot
    time::SystemClock::time_point next_slot_t_;
 
    std::list<protobuf::ModemTransmission>::iterator current_slot_;
 
    unsigned cycles_since_reference_;
 
    bool started_up_{false};
 
    std::string glog_mac_group_;
    static int count_;
};
 
namespace protobuf
{
inline bool operator==(const ModemTransmission& a, const ModemTransmission& b)
{
    return a.SerializeAsString() == b.SerializeAsString();
}
} // namespace protobuf
 
std::ostream& operator<<(std::ostream& os, const MACManager& mac);
 
} // namespace acomms
} // namespace goby
 
#endif