SFBQLED.h

Go to the documentation of this file.

/*                                             -*- mode:C++; fill-column:100 -*-
  SFBQLED.h - Queuing system to blink the built-in LEDs without blocking
  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 SFBQLED_H
#define SFBQLED_H

#include "SFBTypes.h"     /* For u8 */
#include "SFBConstants.h" /* For FACE_COUNT */

enum SFBQLEDWhenIdleModes {
  QLED_IDLE_OFF,                
  QLED_IDLE_ON,                 
  QLED_IDLE_REFLEX              
};

class SFBQLED {
  enum {
    QLED_BODY_RGB_RED_PIN,
    QLED_BODY_RGB_GREEN_PIN,
    QLED_BODY_RGB_BLUE_PIN,
    QLED_NORTH_LED_PIN,
    QLED_SOUTH_LED_PIN,
    QLED_EAST_LED_PIN,
    QLED_WEST_LED_PIN,
    QLED_NORTH_SIDE_LED_PIN,
    QLED_SOUTH_SIDE_LED_PIN,
    QLED_EAST_SIDE_LED_PIN,
    QLED_WEST_SIDE_LED_PIN,
    QLED_COUNT,
   
    FLAG = 0xff,
    MAX_TICKS=0x7f,
    MS_PER_TICK_BITS = 4,       // Min granularity is 16ms, max single event len=2032ms
    MS_PER_TICK = 1<<MS_PER_TICK_BITS
  };
  struct qentry {
    u8 onOffTime;
    u8 next;
  };

  qentry * queue;
  u16 idleOurs;                // If bit clear, return qled to reflex when idle
  u16 idleOn;                  // if idleOurs, ledSet(idleOn) when idle
  u8 oldest[QLED_COUNT];
  u8 newest[QLED_COUNT];
  u8 freeList;
  u8 freeCount;
  u8 alarm;
  u8 slots;

  u32 indexFromSFBPin(u32 sfbPin) ;
  u8 sfbPinFromIndex(u32 index) ;
  u32 allocEntryIndex() ;
  void freeEntryIndex(u32 index) ;
  void initEmpty() ;
  void initLists() ;
  void initQueue() ;
  void tick(u32 when) ;

  bool isEmpty(u32 idx) { return oldest[idx]==newest[idx]; }

  void addOp(u32 sfbPin, bool on, u32 ms);

  u32 next(u32 index) { ++index; if (index >= slots) index = 0; return index; }
  bool pop(u32 qled) ;

  void makeIdle(u32 qled) ;

  static void alarmHandler(u32 when, void * arg) ;

 public:
  SFBQLED() ;
  
  u32 available() { return freeCount; }

  u32 size() { return slots; }

  void begin() ;

  void begin(u16 * buffer, u32 size) ;

  void end() ;

  void forget(u32 sfbPin) ;

  void whenIdle(u32 sfbPin, u32 mode) ;

  u32 time(u32 sfbPin) ;

  void on(u32 sfbPin, u32 ms) ;

  void off(u32 sfbPin, u32 ms) ;

  void set(u32 sfbPin, u32 ms, bool turnOn) ;

#ifdef TEST_SFBQLED
  void assertOK() ;
  u32 getAlarm() { return alarm; }
  void doTick(u32 w) { tick(w); }
#endif

};

extern SFBQLED QLED;

#endif /* SFBQLED_H */