SFBByteBuffer.h

Go to the documentation of this file.

/*                                       -*- mode:C++; fill-column: 100 -*-

  SFBByteBuffer.h - Circular byte buffering between the UART interrupt and the 
                    background packet dispatching levels
  Copyright (C) 2009 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it 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.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA

  $Id$
*/

#ifndef SFBBYTEBUFFER_H
#define SFBBYTEBUFFER_H

#include "SFBTypes.h"       /* For u8 etc */
#include "SFBConstants.h"   /* For BYTE_BUFFER_BYTES */

class SFBByteBuffer {

protected:
  u8 (&buf)[BYTE_BUFFER_BYTES];
  u16 oldIndex;
  u16 newIndex;


  SFBByteBuffer(u8 (&buffer)[BYTE_BUFFER_BYTES]) 
    : buf(buffer),
      oldIndex(0),
      newIndex(0)
  { }

  u16 spaceAvailable() {
    return ((BYTE_BUFFER_BYTES-1)-(newIndex-oldIndex))&BYTE_BUFFER_MASK;
  }

  u16 bytesAvailable() {
    return (newIndex-oldIndex)&BYTE_BUFFER_MASK;
  }

  u16 wrap(u16 index) {
    return index&BYTE_BUFFER_MASK;
  }
  void uncheckedStoreByte(u8 data) {
    buf[newIndex] = data;
    newIndex = wrap(newIndex+1);
  }
  u8 uncheckedFetchByte() {
    u8 val = buf[oldIndex];
    oldIndex = wrap(oldIndex+1);
    return val;
  }

  enum {
    BB_ESC = 0xA5,
    BB_EESC = 0x00       // BB_ESC+BB_EESC -> single BB_ESC datum
                         // BB_ESC+anything else -> overflow and/or hw error occurred, anything else==flags
  };

};

class SFBRxByteBuffer : public SFBByteBuffer {
public:

  enum {
    BBFLAG_ERRORBITS= PK_OVERRUN|PK_PARITY|PK_FRAMING|PK_BREAK, 
    BBFLAG_OVERFLOW=  PK_BUFFER, 
    BBFLAG_ZERO=      PK_DELETED|PK_BAD_ESCAPE  
  };

  SFBRxByteBuffer(u8 (&buffer)[BYTE_BUFFER_BYTES]) : SFBByteBuffer(buffer), flags(0) { }

  void resetBG() ;

  int fetchByteBG() ;

  void storeErrorStatusIL(u8 status) {
    flags |= status;            // Just add in the bits, will be flushed in storeByteIL
  }

  void storeByteIL(u8 data) ;

private:
  u8 flags;

};

class SFBTxByteBuffer : public SFBByteBuffer {
public:
  SFBTxByteBuffer(u8 (&buffer)[BYTE_BUFFER_BYTES]) : SFBByteBuffer(buffer), pendingCount(0) { }

  void resetBG() ;

  void storeByteBG(u8 data) ;

  bool canStoreBytesBG(u32 count) ;

  bool shipBytesBG() ;


  int fetchByteIL() ;

private:
  int pendingCount;

};

#endif  /* SFBBYTEBUFFER_H */