Subversion Repositories w11

// $Id: RlinkPacketBufRcv.cpp 621 2014-12-26 21:20:05Z mueller $

//

// Copyright 2014- by Walter F.J. Mueller <W.F.J.Mueller@gsi.de>

//

// This program is free software; you may redistribute and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation, either version 2, or at your option any later version.

//

// This program is distributed in the hope that it will be useful, but

// WITHOUT ANY WARRANTY, without even the implied warranty of MERCHANTABILITY

// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for complete details.

// 

// Revision History: 

// Date         Rev Version  Comment

// 2014-12-25   621   1.0.1  Reorganize packet send/revd stats

// 2014-11-30   607   1.0    Initial version

// 2014-11-02   600   0.1    First draft (re-organize PacketBuf for rlink v4)

// ---------------------------------------------------------------------------

/*!

  \file

  \version $Id: RlinkPacketBufRcv.cpp 621 2014-12-26 21:20:05Z mueller $

  \brief   Implemenation of class RlinkPacketBuf.

 */

#include <sys/time.h>

#include "RlinkPacketBufRcv.hpp"

#include "librtools/RosFill.hpp"

#include "librtools/RosPrintf.hpp"

#include "librtools/RosPrintBvi.hpp"

#include "librtools/Rexception.hpp"

using namespace std;

/*!

  \class Retro::RlinkPacketBufRcv

  \brief FIXME_docs

*/

// all method definitions in namespace Retro

namespace Retro {

//------------------------------------------+-----------------------------------

//! Default constructor

RlinkPacketBufRcv::RlinkPacketBufRcv()

  : fRawBufSize(0),

    fRawBufDone(0),

    fRcvState(kRcvIdle),

    fNDone(0),

    fEscSeen(false),

    fNakIndex(-1),

    fDropData()

{

  // Statistic setup

  fStats.Define(kStatNRxPktByt, "NRxPktByt", "Rx packet bytes rcvd");

  fStats.Define(kStatNRxDrop,   "NRxDrop",   "Rx bytes dropped");

  fStats.Define(kStatNRxSop,    "NRxSop",    "Rx SOP commas seen");

  fStats.Define(kStatNRxEop,    "NRxEop",    "Rx EOP commas seen");

  fStats.Define(kStatNRxNak,    "NRxNak",    "Rx NAK commas seen");

  fStats.Define(kStatNRxAttn,   "NRxAttn",   "Rx ATTN commas seen");

  fStats.Define(kStatNRxEsc,    "NRxEsc",    "Rx data escapes");

  fStats.Define(kStatNRxClobber,"NRxClobber","Rx clobbered escapes");

}

//------------------------------------------+-----------------------------------

//! Destructor

RlinkPacketBufRcv::~RlinkPacketBufRcv()

{}

//------------------------------------------+-----------------------------------

//! FIXME_docs

int RlinkPacketBufRcv::ReadData(RlinkPort* port, double timeout, RerrMsg& emsg)

{

  if (port == 0)

    throw Rexception("RlinkPacketBufRcv::ReadData()",

                     "Bad state: port not open");

  if (fRawBufDone != fRawBufSize)

    throw Rexception("RlinkPacketBufRcv::ReadData()",

                     "Bad state: called while data pending in buffer");

  fRawBufDone = 0;

  fRawBufSize = 0;

  int irc = port->Read(fRawBuf, sizeof(fRawBuf), timeout, emsg);

  if (timeout == 0 && irc == RlinkPort::kTout) return 0;

  if (irc < 0) {

    if (irc == RlinkPort::kTout) {

      SetFlagBit(kFlagErrTout);

    } else {

      SetFlagBit(kFlagErrIO);

      if (irc == RlinkPort::kEof) {

        emsg.Init("RlinkPacketBuf::ReadData()", "eof on read");

      }

    }

  } else {

    fRawBufSize = size_t(irc);

  }

  return irc;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

bool RlinkPacketBufRcv::ProcessData()

{

  if (fRawBufDone ==fRawBufSize) return false;

  while (fRawBufDone < fRawBufSize) {

    switch (fRcvState) {

    case kRcvIdle:

      ProcessDataIdle();

      break;

    case kRcvFill:

      ProcessDataFill();

      break;

    default:

      return true;

    }

  }

  return true;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void RlinkPacketBufRcv::AcceptPacket()

{

  fPktBuf.clear();

  fCrc.Clear();

  fFlags    = 0;

  fRcvState = kRcvIdle;

  fNDone    = 0;

  fNakIndex = -1;

  fDropData.clear();

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void RlinkPacketBufRcv::FlushRaw()

{

  fRawBufSize = 0;

  fRawBufDone = 0;

  fEscSeen    = false;

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

RlinkPacketBufRcv::pkt_state RlinkPacketBufRcv::PacketState()

{

  if (fRcvState==kRcvIdle || fRcvState==kRcvFill) return kPktPend;

  if (fRcvState==kRcvDone) return TestFlag(kFlagSopSeen) ? kPktResp : kPktAttn;

  return kPktError;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void RlinkPacketBufRcv::GetWithCrc(uint16_t* pdata, size_t count)

{

  uint16_t* pend = pdata + count;

  while (pdata < pend) GetWithCrc(*pdata++);

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void RlinkPacketBufRcv::Dump(std::ostream& os, int ind, const char* text) const

{

  RosFill bl(ind);

  os << bl << (text?text:"--") << "RlinkPacketBufRcv @ " << this << endl;

  os << bl << "  fRawBufSize:   " << RosPrintf(fRawBufSize,"d",4) << endl;

  os << bl << "  fRawBufDone:   " << RosPrintf(fRawBufDone,"d",4) << endl;

  if (fRawBufDone > 0) {

    os << bl << "  fRawBuf[last]: "

       << RosPrintBvi(fRawBuf[fRawBufDone-1],16) << endl;

  }

  os << bl << "  fRcvState:     " << RosPrintf(fRcvState,"d",4) << endl;

  os << bl << "  fNDone:        " << RosPrintf(fNDone,"d",4) << endl;

  os << bl << "  fEscSeen:      " << RosPrintf(fEscSeen) << endl;

  os << bl << "  fNakIndex:     " << RosPrintf(fNakIndex,"d",4) << endl;

  os << bl << "  fDropData(size): " << RosPrintf(fDropData.size(),"d",4);

  size_t ncol  = max(1, (80-ind-4-6)/(2+1));

  for (size_t i=0; i<fDropData.size(); i++) {

    if (i%ncol == 0) os << "\n" << bl << "    " << RosPrintf(i,"d",4) << ": ";

    os << RosPrintBvi(fDropData[i],16) << " ";

  }

  os << endl;

  RlinkPacketBuf::Dump(os, ind, " ^");

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void RlinkPacketBufRcv::ProcessDataIdle()

{

  // loop over buffer

  while (fRawBufDone < fRawBufSize) {

    // handle escapes

    if (fEscSeen) {

      uint8_t ec = GetEcode();

      switch (ec) {

      case kEcSop:

        SetFlagBit(kFlagSopSeen);

        fRcvState = kRcvFill;

        return;

      case kEcAttn:

        SetFlagBit(kFlagAttnSeen);

        fRcvState = kRcvFill;

        return;

      default:

        fDropData.push_back(kSymEsc);

        fDropData.push_back(fRawBuf[fRawBufDone-1]);

        fStats.Inc(kStatNRxDrop, 2.);

        break;

      }

    } //if (fEscSeen)

    // handle plain data (till next escape)

    uint8_t* pi   = fRawBuf+fRawBufDone;

    uint8_t* pend = fRawBuf+fRawBufSize;

    while (pi < pend) {

      uint8_t c = *pi++;

      if (c == kSymEsc) {

        fEscSeen = true;

        break;

      }

      fDropData.push_back(c);

      fStats.Inc(kStatNRxDrop);

    }

    fRawBufDone = pi - fRawBuf;

  } // while (fRawBufDone < fRawBufSize)

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

void RlinkPacketBufRcv::ProcessDataFill()

{

  // loop over buffer

  while (fRawBufDone < fRawBufSize) {

    // handle escapes

    if (fEscSeen) {

      uint8_t ec = GetEcode();

      switch (ec) {

      case kEcEop:                          // EOP seen

        SetFlagBit(kFlagEopSeen);           // -> set eop and return

        fRcvState = kRcvDone;

        fStats.Inc(kStatNRxPktByt, double(PktSize()));

        return;

      case kEcNak:                          // NAK seen

        if (TestFlag(kFlagAttnSeen|kFlagNakSeen)) {  // NAK after ATTN or NAK

          SetFlagBit(kFlagErrFrame);          // -> set frame error and return

          fRcvState = kRcvError;

          return;

        }                                   // else 1st NAK

        SetFlagBit(kFlagNakSeen);             // -> set flag and index; continue

        fNakIndex = fPktBuf.size();

        break;

      // data escapes seen: add escaped char and continue

      case kEcXon:   fPktBuf.push_back(kSymXon);  break;

      case kEcXoff:  fPktBuf.push_back(kSymXoff); break;

      case kEcFill:  fPktBuf.push_back(kSymFill); break;

      case kEcEsc:   fPktBuf.push_back(kSymEsc);  break;

      case kEcClobber:                      // Clobber(ed) escape seen

        SetFlagBit(kFlagErrClobber);        // -> set clobber error and return

        fRcvState = kRcvError;

        return;

      default:                              // unexpected escape (SOP,ATTN)

        SetFlagBit(kFlagErrFrame);          // -> set frame error and return

        fRcvState = kRcvError;

        return;

      }

    } // if (fEscSeen)

    // handle plain data (till next escape)

    uint8_t* pi   = fRawBuf+fRawBufDone;

    uint8_t* pend = fRawBuf+fRawBufSize;

    while (pi < pend) {

      uint8_t c = *pi++;

      if (c == kSymEsc) {

        fEscSeen = true;

        break;

      }

      fPktBuf.push_back(c);

    }

    fRawBufDone = pi - fRawBuf;

  } // while (fRawBufDone < fRawBufSize)

  return;

}

//------------------------------------------+-----------------------------------

//! FIXME_docs

uint8_t RlinkPacketBufRcv::GetEcode()

{

  if (!fEscSeen || fRawBufDone >= fRawBufSize)

    throw Rexception("RlinkPacketBufRcv::GetEcode()", "Bad state");

  fEscSeen = false;

  uint8_t c  = fRawBuf[fRawBufDone++];

  uint8_t ec = c & 0x7;

  if ((c & 0xC0) != kSymEdPref || (((~c)>>3)&0x7) != ec) ec = kEcClobber;

  switch (ec) {

  case kEcSop:     fStats.Inc(kStatNRxSop);     break; // SOP  comma seen

  case kEcEop:     fStats.Inc(kStatNRxEop);     break; // EOP  comma seen

  case kEcNak:     fStats.Inc(kStatNRxNak);     break; // NAK  comma seen

  case kEcAttn:    fStats.Inc(kStatNRxAttn);    break; // ATTN comma seen

  case kEcClobber: fStats.Inc(kStatNRxClobber); break; // clobbered esc seen

  default:         fStats.Inc(kStatNRxEsc);     break; // escaped data seen

  }

  return ec;

}

} // end namespace Retro