SFBNet.h

Go to the documentation of this file.

/*                                             -*- mode:C++; fill-column:100 -*-
  SFBNet.h - Simple 'functional gradient' network routing
  Copyright (C) 2010 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
*/

#ifndef SFBNET_H_
#define SFBNET_H_

#include <stdarg.h>

#include "SFBConstants.h"       /* For FACE_COUNT, etc */
#include "SFBAlarm.h"           /* For SFBAlarmIndexType */ 
#include "SFBPrint.h"           /* For FacePrinter, etc */ 

class SFBNet {
public:

  bool shouldTakeFirstTie() { return flags&TAKE_FIRST_TIE; }

  void setShouldTakeFirstTie(bool on) { 
    if (on)
      flags |= TAKE_FIRST_TIE;
    else
      flags &= ~TAKE_FIRST_TIE;
  }

  void begin() ;

  bool isActive() { return (flags&NET_ACTIVE)!=0; } 

  void end() ;

  void offer(u8 service) ;

  bool withhold(u8 service) ;

  bool isOfferedByNode (u8 service) ;

  bool isOfferedByNet(u8 service) ;

  void openServiceStream(u8 service) ;

  void printf ( const char * fmt, ...) ;

  void vprintf(const char * fmt, va_list & ap) ;

  void printf(u8 service, const char * fmt, ...) ;

  void setBroadcastPeriod(u32 millis) ;

  void setHorizon(u32 distance) ;

  u32 getHorizon() { return defaultTTL; }

  u32 getServiceStreamFace() {
    return net_printer_face;
  }

  bool neighborActive(u8 face) ;

  enum Sizes {
    MAX_TOTAL_SVCS=64,  
    MAX_LOCAL_SVCS=32,  
    MAX_RETURN_ROUTE_LENGTH=100 
  };

  void printPath(u8 toFace, bool skipFirst = true);

  void dump(u8 face, const u8 * prefix = 0) ;

private:

  enum Flags {
    TAKE_FIRST_TIE=      0x01, 
    RESPONSE_SENT_HEADER=0x02, 
    NET_ACTIVE=          0x04, 
    IN_TRIGGER=          0x08, 
    FLAG_RSRV4=          0x10,
    FLAG_RSRV5=          0x20,
    FLAG_RSRV6=          0x40,
    FLAG_RSRV7=          0x80
  };

  u8 ticks() { return MsToTicks(millis()); }

  u32 ticksToMs(u8 ticks) { return ticks<<8; }

  u32 MsToTicks32(u32 ms) { return ms>>8; }

  u8 MsToTicks(u32 ms) { return (u8) MsToTicks32(ms); }


  bool neighborActive_(u8 face) {
    u8 now = ticks();
    bool ret = IS_LATER8(neighborActiveTicks[face]+MsToTicks(2048),now);
    if (!ret) neighborActiveTicks[face] = now-10; // Pull along inactive faces to avoid wrapping
    return ret;
  }

  static const FacePrinter net_printer;
  static const FacePrinter response_printer;

  void functionPrint(u8 face, u8 byte) ;
  void functionPrintln(u8 face) ;

  void printResponseHeader() ;
  void printResponseHeaderIfNeeded() { if ((flags&RESPONSE_SENT_HEADER)==0) printResponseHeader(); }
  void responsePrint(u8 face, u8 byte) ;
  void responsePrintln (u8 face) ;

  static void NetBcastAlarm(u32) ;
  static void NetPacketHandler(u8 *) ;

  static void NetFunctionPrint(u8 face, u8 byte ) ;
  static void NetFunctionPrintln( u8 face) ;
  static void NetResponsePrint(u8 face, u8 byte) ;
  static void NetResponsePrintln(u8 face) ;

  void broadcastAlarm(u32) ;

  void packetHandler(u8 *) ;

  struct Entry {
    u8 func;                    /* Function. */
    u8 last_update[FACE_COUNT]; /* Bcast ID of last update. */
    u8 hops[FACE_COUNT];        /* Number of hops to provider. */
  };

  /* Pointer to the start of the temp packet in packet_buffer. */
  u8 * net_packet;

  Entry routes[MAX_TOTAL_SVCS];

  SFBAlarmIndexType alarmNumber; /* My alarm number */ 

  u8 last_route;

  u8 offered[MAX_LOCAL_SVCS];
  u8 last_offered;

  u8 bcastPeriodTicks;
  u8 ticksInGeneration;

  u8 defaultTTL;

  u8 neighborActiveTicks[FACE_COUNT];
  u8 bcastGeneration;

  u8 flags;

  /* Temporary packet buffer. */
  u8 packet_buffer[PACKET_PRINTER_PACKET_BUFFER_SIZE];

  /* Currently "open" function. */
  u8 open_function;

  u8 virtual_face;

  u8 packet_printer_face;

  /* Face for the virtual printer for the SFBNet. Dispatches to
   * u8_packet_printer_face. */
  u8 net_printer_face;

  /* The route back to the invoker. */
  u8 response_route[MAX_RETURN_ROUTE_LENGTH];

  /* The length of the route back to the invoker. */
  s8 response_route_len;

  /* The first face in the route back to the invoker. */
  u8 response_src;

  void ship() ;

  void handleBroadcast(u8 *) ;
  void handleInvoke(u8 *) ;

  Entry * lookup(u8 func, bool insert = false) ;

  u8 pickDirection(u8 func, u8 origin) ;

  u8 pickRandomFace(u8 func) ;

  void trigger(u8 * packet, u8 * return_route, u8 hops) ;

};

extern SFBNet Net;

#endif /* SFBNET_H_ */