KM3NeT_Acoustic_Link.cpp

Go to the documentation of this file.

#include "KM3NeT_Acoustic_Link.h"

#ifdef DEBUG_KM3NET_ACOUSTIC_LINK
#include <stdlib.h>
#include <iostream>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <Tools/KM3NeT_Debug.h>
#define DEBUG_MSG(str,lev) do { if (((uint8_t)lev)>=KM3NeT_Acoustic_Link::DEBUG_LEVEL) { DBG_MSG << boost::posix_time::microsec_clock::local_time() << " ACOUSTIC_LINK(" << (void*)this << "): "<< str << '\n'; } }while( false )
#else
#define DEBUG_MSG(str,lev) do { } while ( false )
#endif

/**
 * \author fsimeone
 */

KM3NeT_Acoustic_Link::KM3NeT_Acoustic_Link(     boost::asio::io_service& io_service,\
                                                                                        std::map<std::size_t,pDOM>& doms,\
                                                                                        uint32_t buffer_size\
                                                                                        ):      strand_(io_service),\
                                                                                                socket_(io_service),\
                                                                                                dom_map_(doms)
{
        DEBUG_MSG("Constructor",3);
        data_size_=AUDIO_PACKET_FIXED_SIZE;
        buffer_size_=buffer_size;
        buffer_=(uint8_t*)malloc(buffer_size_);
        header_received_=false;
}

KM3NeT_Acoustic_Link::~KM3NeT_Acoustic_Link()
{
        DEBUG_MSG("Destructor",3);
        Disconnect();
        free(buffer_);
}

void KM3NeT_Acoustic_Link::Disconnect(bool soft)
{
        DEBUG_MSG("Disconnect",3);
        if (soft)
        {
                boost::system::error_code l_ignore;
                socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, l_ignore);
        }
        socket_.close();
}

void KM3NeT_Acoustic_Link::Start_reading()
{
        if (buffer_size_<data_size_)
        {
                DEBUG_MSG("Realloc: free " << (void*) buffer_<<" - "<<buffer_size_<<" byte",1);
                free(buffer_);
                buffer_size_=data_size_;
                buffer_=(uint8_t*)malloc(buffer_size_);
                DEBUG_MSG("Realloc: alloc " << (void*) buffer_<<" - "<<buffer_size_<<" byte",1);
        }

        async_read(socket_,boost::asio::buffer(buffer_,buffer_size_),boost::asio::transfer_exactly(data_size_),strand_.wrap(boost::bind(&KM3NeT_Acoustic_Link::Read_completed, shared_from_this(), _1, _2)));
}

void KM3NeT_Acoustic_Link::Read_completed(const boost::system::error_code& error, std::size_t transferred)
{
  if (!error)
  {
        DEBUG_MSG("Read completed " << transferred << " bytes ",1);
        if (!header_received_)
        {
                header_received_=true;
                Audio_Header* l_pheader=(Audio_Header*)buffer_;
                DEBUG_MSG("h seconds="<<l_pheader->Common_Header.Time_Stamp_seconds,0);
                DEBUG_MSG("h tick="<<l_pheader->Common_Header.Time_Stamp_ticks,0);
                data_size_=l_pheader->Common_Header.Frame_Length-sizeof(Audio_Header);
                dom_id_=l_pheader->Common_Header.DOM_Identifier;
                
                std::map<std::size_t,pDOM>::iterator i=dom_map_.find(dom_id_);
                if (i!=dom_map_.end())  i->second->Check_time_async(*l_pheader);
        }
        else
        {
                std::map<std::size_t,pDOM>::iterator i=dom_map_.find(dom_id_);
                if (i!=dom_map_.end())  
                {
                        uint8_t* tmp_buffer=(uint8_t*)malloc(transferred);
            memcpy(tmp_buffer,buffer_,transferred);
                        i->second->Handle_samples_async(tmp_buffer,transferred);
                }
                data_size_=AUDIO_PACKET_FIXED_SIZE;
                header_received_=false;
        }
        Start_reading();
  }
  else
  {
          DEBUG_MSG("Read completed err " << error <<" "<< transferred << " bytes",3);
          Disconnect();
  }
}