/*===============================*\
# 7x10 RGB dot display for        #
#  displaying Xmas date/countdown #
\*===============================*/

#define Version "2.5.2" 

/*
 * A snake of WS2812b dot-RGB LEDs for a 10 width x 8 height display

 - bugfixes
  Simple display the first few days, and last day
  [Done] Cleanup Marquee code, so it cycles properly
  Date scene better timeinterval.
  Snow to be non-random
 - nicetohave now
  [Done]Advent picture on Sundays  (dates not to be hardcoded)
  Lucia picture on 13th
 - major enhancments
  [Done]Real RTC
  static scene for pre,1st post 24th  
  "Movie" and/or crossfade (using real RGB)
  ...

*/
#include "Timer.h"     // Timers and Clock
#include "Display.h"   // W1228b output
#include "Scenes.h"    // 

Timer TmrOne ;         // timer that toggles between scenes
byte Scene = 0;        // Start Scene
byte LstImg=1 ;        // last image, for looping images
int DBG=0 ;            // something to aid in debugging

void setup() {
  Serial.begin(115200/*9600*/);  // Highspeed for ANSI display
  delay(10); // seems the Serial needs a time to settle?
  Serial.print("Version ");Serial.println(Version);
  Display.setup() ;
  Clock.start();
  Serial.println("\033[H\033[2JGo");
}

void loop() {
  Clock.loop() ;

  switch ( Scene ) {
    case 0: Display.test() ; Display.refresh() ; delay(1000) ; // powerup test sequence
            Scene++ ;                                          // drop through to scene 1
    case 1: Display.clear(RGB6(0,2,2)); Serial.println(FirstAdvent()) ; 
            if ( Clock.Day>24 ) Scene = 6 ; // skip to pictures if after 24th
            Scene++ ; break ;
    
    case 2: Date.start() ; Scene++ ; break ;
    case 3: if ( Date.loop() ) Scene++ ;
           break ;

    case 4: //Picture or special day  (hardcoded for 2021)
            if ( ! (Clock.Day == 5 || Clock.Day == 12 || Clock.Day == 19 ) ) 
              { Scene = 7 ; break ; }
            // if ( Clock.Day == 13 ) Scene = ?
            Scene++ ; // advent drop thru

    case 5: Advent.start(Clock.Day/7+2) ;        // kludgy signal 2, 3 or 4th advent
            Scene++ ; break ;
    case 6: if ( Advent.loop() ) {
            Advent.stop() ;  Scene=2 ;           // ** only date and candles in advent
            }
            break ;

    case 7: Picture.start(LstImg) ; TmrOne.Set(10000) ; Scene++ ; break ;
    case 8: Picture.loop() ; if ( TmrOne.Chk() ) { 
              if ( ++LstImg >= sizeof(IMG)/(XX*YY) ) LstImg=1 ; 
              Scene++ ;
            }
           break ;

    case 9: GodJul.start() ; TmrOne.Set(8000) ; 
            Display.clear(RGB6(0,2,0)); Scene++ ; break ;
    case 10: GodJul.loop() ; if ( TmrOne.Chk() ) {
                GodJul.stop() ; Scene++ ; }
           break ;
    default: Date.stop() ; GodJul.stop() ; Snow.stop() ; Scene = 1 ;
  }
  Display.refresh() ;
  // Display.test() ; while(1) ;
}

int FirstAdvent() {
  // we have from the 27thNov to the 3rdDec inclusive as candiates, returned as -3..3
  int First = Clock.Day ;
Serial.print(First);Serial.print(',');
  if ( First >=27 ) First -= 30 ;  // negative daynumber in november
Serial.print(First);Serial.print(',');
  while ( First > 3 ) First -= 7 ; // Skip weeks backward until 1st week
Serial.print(First);Serial.print(',');
  First -= Clock.Weekday ;         // Go back to previous Sunday
Serial.print(First);Serial.print(',');
  if ( First < -3 ) First += 7 ;   // adjust a week forward if before 27thNov
Serial.print('.') ;
  return First ;
}

disp8x10.ino

diagram.json

/*==================*\
# Display services  #
\*==================*/

// Handles output to the display, and a few utility draw-buildups
// Colours: We use a 6x6x6 Cube; Colour value of a channel maps 0-5 to 0,1,3,10,33,66
// so "100" => channel indexes 2,4,4 => RGB:[3,33,33]

//#define ANSIOut              // place pixel output on Serial with colourcode. Undefine for only SPI output

#include <SPI.h>

const int XX = 10 ;          // Width  (X subscript, left right)
const int YY =  8 ;          // Height (Y subscript, top bottom)

// Colour mapping
const byte Gamma[6] = { 0, 1, 3, 10, 33, 66 } ; 
#define RGB6(r,g,b) ((r*6+g)*6+b)

#include "Symbols.h"         // character/ikon shapes

class { 
  private:
    byte Frame[XX][YY] ;      // One complete frame of indexes

// ========================
void sendByte (byte b)  {
  // send one byte to the Neopixels - note that the "off" gap is partly handled by the loop overhead
  //   gaps measured empirically to be 1.7 µs to 2 µs, so we don't need to add any more of our own
  for (byte bit = 0; bit < 8; bit++) {
    if (b & 0x80) // is high-order bit set?
      SPI.transfer (0b11111100);  // 1 bit - 750 ns on + 250 ns off (acceptable "on" range 550 ns to 850 ns)
    else
      SPI.transfer (0b11100000);  // 0 bit - 375 ns on + 625 ns off (acceptable "on" range 200 ns to 500 ns)
    b <<= 1; // shift next bit into high-order position
  } // end of for each bit
}

// ========================

void sendPixel (const byte P) {
  byte Pg = P/6 ;
  // I sure hope the compiler makes some nice tight code here 
  sendByte (Gamma[Pg%6]);   // NeoPixel wants colors in green-then-red-then-blue order
  sendByte (Gamma[(Pg/6)%6]);
  sendByte (Gamma[P%6]);
}

// ========================
  public:

// ========================
void setup() {
  SPI.begin ();
  SPI.beginTransaction(SPISettings(16000000L, MSBFIRST, SPI_MODE3));  // MOSI normally low.
  delayMicroseconds (50);       // make all(?!) pixels black
  sendPixel(0);
  delayMicroseconds (50);
}

void refresh() {
// This function is timecritical! Must be very efficient in calling sendPixel
#ifndef ANSIOut
  //noInterrupts() ;
  for (int y=0; y<YY; y+=2) {
    for ( int x=XX ; --x>=0 ; ) {
      sendPixel(Frame[x][y]) ;         }
    if ( y<YY-1 ) for ( int x=0; x<XX ; x++ ) {
      sendPixel(Frame[x][y+1]) ;
    }
  }
  //interrupts() ;
  delayMicroseconds (50);      // 50us silence => latch data
#else // ANSIOut
  Serial.print("\033[H");
  for (int y=0; y<YY; y++ ) {
    for ( int x=0; x<XX; x++ ) {
      //(https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit)
      Serial.print("\033[48;5;");
      Serial.print(16+Frame[x][y]);
      Serial.print("m  ");
      //if ( Frame[x][y]<0x10 ) Serial.print(' '); Serial.print(Frame[x][y],HEX); 
      //Serial.print(' ');
    }
    Serial.println() ;
  }
  Serial.println("\033[0m");
  delay(200); // to avoid the Serial/USB getting flooded, and limit debug output
#endif      
}


// ======================== 
void clear(const byte P) {
  fill(0,0,XX,YY,P) ;
}

// ======================== 
void fill(const byte x1, const byte y1, const byte x2, const byte y2,
          const byte P ) {
  for (int y=max(0,y1); y<min(YY,y2+1); y++) 
    for ( int x=max(0,x1) ; x<min(XX,x2+1) ; x++ ) {
      Frame[x][y] = P ;
    }
}

// ========================
void dot(const byte x, const byte y, const byte P ) {
  if ( 0 <= x && x < XX && 0 <= y && y < YY ) {
    Frame[x][y] = P ;
  }
}

// ========================
void sym(const byte code, const char col, const byte P ) {
  // allow character partially offscreen, ie -ve col
  for ( int x=0; x<5; x++ ) 
    for ( int y=0; y<YY; y++) {
      byte Bits = pgm_read_byte_near(SYM+code*5+(4-x)) ;
      if ( Bits & B10000000>>y 
           && 0 <= col+x && col+x < XX ) // filter out offscreen columns
        Frame[col+x][y] = P ;
    }
}

void copy(const byte img, const char dstx, const char dsty, const byte sizx, const byte sizy) {
  // dstx/dsty can be -ve, and image partially offscreen
  for ( int x=0; x<sizx; x++ ) {
    for (int y=0; y<sizy; y++) 
      if ( 0 <= x+dstx && x+dstx < XX && 0 <= y+dsty && y+dsty < YY ) 
        Frame[x+dstx][y+dsty] = IMG[img][y][x] ;
    }
}

void test () {
  int R=0,G=0,B=0 ;
  for (int y=0; y<YY; y++) {
    for ( int x=0; x<XX ; x++ ) {
      /*Serial.print(RGB6(R,G,B));Serial.print('=');
      Serial.print(R);Serial.print(',');
      Serial.print(G);Serial.print(',');
      Serial.print(B);Serial.print(' ');*/
      Frame[x][y]=RGB6(R,G,B) ;
      if ((R+=2)>5) { R=0 ; if ((G+=2)>5) { G=0 ; if ((B+=2)>5) B=0 ; } }
    }
    //Serial.println() ;
  }
}

// ================== End of class

} Display ;

Display.h

/*==============*\
# Scene handler #
\*==============*/

// Single/anonymous classes handling one "scene" or motionpiece

// =============== Snow (sub scene that overwrites, called by other scenes)
class {
  private:
    boolean Active = false ;
    struct {
      byte x, y ;
    } Flake[5] ;
    Timer Fall ;
    byte Wiggle ;
  
  public:

void start() { 
  Active = true ;
  Fall.Set(70);
  for ( int f=0; f<5; f++ ) {
    if ( Flake[f].x == 0 ) Flake[f].x = f*2 ; // only (re)initialize if zero
    if ( Flake[f].y == 0 ) Flake[f].y = f*3/2 ; 
  }
}

void stop() { 
  Active = false ;
//  Fall.Set(1000);   // avoid something
}

void loop() { 
  if ( Active )               // Show all flakes
    for ( int f=0; f<5; f++)
      Display.dot(Flake[f].x,Flake[f].y,RGB6(3,3,3) ); // (full white too bright)
  // NB: as Snow.loop is called continously, the snow keeps falling in the dark ;-)
  if ( Fall.Chk() ) {          // one flake descend
    byte Rnd = random(5) ;
    if ( ++Flake[Rnd].y > 8 ) Flake[Rnd].y = 0 ; // allow flakes drop out
      if ( random(4)==0 )    // wiggle sideways occasionally
        if ( Flake[Rnd].x & 0x01) Flake[Rnd].x-- ; else  Flake[Rnd].x++ ;
    }
}

} Snow ;

// =============== Display date

class {
  private:

  Timer Tmr ;
  int ViewDate = 0 ;

void twonum(const byte val, const byte rgb) {
  if (val>=20) Display.sym(2,-1,rgb) ;
  else if (val>=10) Display.sym(1,0,rgb) ;
  Display.sym(val%10,val<=9?2:4,rgb) ;
}

  public:

void stop() {
  ViewDate = 0 ;
}

void start() {
  Serial.print("DigBeg_");
  Tmr.Set(0) ; // NB:timer expires immediatly so we show the "next date"
  if ( Clock.Day == 24 ) ViewDate = 23 ; else ViewDate = 0 ;
}    

boolean loop() {
  if ( Clock.Day==ViewDate ) { // only snows on current date
    Display.clear(RGB6(0,2,0));
    twonum(ViewDate,RGB6(4,0,0));
    Snow.loop() ;
  }
  if ( Tmr.Chk() ) {
    ViewDate++ ;
    Serial.print("DigNxt");Serial.print(ViewDate);Serial.print('#');
    Display.clear(RGB6(0,2,0));
    if (Clock.Day==ViewDate) {
      Tmr.Set(4321) ;
      Snow.start() ;
    } else if (Clock.Day>ViewDate) {
      Tmr.Set(940-900*Clock.Day/24) ; // go faster each day, total between 0.9 and 5.5 sec
      twonum(ViewDate,RGB6(3,2,0)); 
    }
    if ( Clock.Day<ViewDate ) {
      Snow.stop() ;
      return true ;
    }
  }
  return false ;
}

} Date ;


// =============== Display GodJul

class {
  private:
    Timer Move ;
    int Offset = 0 ;
    const byte BckCol = RGB6(1,1,0) ; // background colour
    const byte IntSpc = 4 ;  // number of empty columns between end to begin

  public:

void stop() {
  Serial.print("GodStp\n");/*dummy*/ ;
}
  
void start() {
  Serial.print("GodBeg");
  Move.Set(150) ;
  Display.clear(BckCol);
  Offset = -IntSpc ;
}    

boolean loop() {
  if ( Move.Chk() ) {
    Serial.print("GodNxt");Serial.print(Offset);Serial.print('#');
    Display.clear(BckCol);
    // The marquee of text
    for ( int x=0; x<XX; x++) {
      int idx = Offset+x ;
      if ( 0 <= idx && idx < sizeof(GODJUL)+XX ) {
        byte Bits = pgm_read_byte_near(GODJUL+idx) ;
        for ( int y=0; y<6; y++) {
          if ( idx>=0 && Bits & B100000>>y )
            Display.dot(x,y+1,RGB6(0,1,4));
        }
      }
    }
    // top/bottom stripe
    for ( int x=0; x<XX; x++ ) {
      Display.dot(x,0,(x+Offset)%5==0?RGB6(0,4,0):RGB6(4,0,0)) ;
      Display.dot(x,YY-1,(x+Offset)%4==0?RGB6(0,4,0):RGB6(4,0,0)) ;
    }
    Offset++ ; 
    if ( Offset > int(sizeof(GODJUL))-XX+IntSpc ) Offset = -IntSpc ;
  }
  // stop of marquee is done by timer in mainloop
}

} GodJul ;

// =============== Show image N , with some blink or snow
class {
  private:
    byte Img, Txy ;
    boolean On ;
    Timer Blink ;
    
  public:


void start(const byte img) {
  Serial.print("ImgBeg");Serial.print(img);Serial.print('!');
  Img = img ;
  // Find entry in linked list
  for (int idx=0, ent=0; idx<sizeof(TXY)/sizeof(TXY[0]); idx++) {
    Serial.print(idx);
    if ( ent==Img ) { Txy = idx ; break ; }
    if ( TXY[idx][0]>253 ) ent++ ;
  }
  if ( TXY[Txy][0]==254 ) Snow.start() ; else Snow.stop() ;
  Blink.Set(10) ; On = false ;
  loop() ; // do an initial display
  Serial.println('|') ;
}

void loop() { 
  Display.copy(Img,0,0,XX,YY) ;
  Snow.loop() ; // ignored if "off"
  if ( On ) {
    for ( int tt=Txy; TXY[tt][0]<254 ; tt++ )   // may occur zero times
      Display.dot(TXY[tt][0],TXY[tt][1],TXY[tt][2]) ;
  }
  if ( Blink.Chk() ) {
    if ( On ) {
      Blink.Set(400) ; // long off time
      On = false ;
    } else {
      Blink.Set(100) ; // short on time
      On = true ;
    }
  }
}

} Picture ;

// =============== Advent candles
class {
  private:
    int Burn ;
    int AdvNr ;
    Timer Down ;
    int Candles[4] ; // used to track flickering
  public:


void start(const byte Nth) {
  Serial.print("AdvBeg");Serial.print(AdvNr);Serial.print('#');
  Burn=-5 ; Down.Set(500) ;
  AdvNr = Nth ;
  for ( int i=0; i<4; i++) Candles[i] = 12 ;
}

void stop() { }

bool loop() { 
  Display.clear(0) ;
  if ( Down.Chk() ) {
    Serial.print("Adv");Serial.print(Burn);Serial.print('#');
    Burn++ ;
    if ( Burn>=-1 ) Down.Set(6000) ; else Down.Set(500) ;
    return Burn>=0 ;
  }
  for ( int i=0; i<4; i++) if ( Candles[i] <=0 ) Candles[i] = random(20) ;


  for ( int x=0; x<XX; x++) Display.dot(x,YY-1,RGB6(0,3,0)) ; // green line at bottom
    for ( int x=0; x<8; x++) for ( int y=1; y<YY ; y++ )
      if ( x%2==1 ) {
        if ( y>AdvNr+Burn-x/2+1 )  Display.dot(x,y,RGB6(3,3,3)) ; // lightgrey candles
        if ( y==AdvNr+Burn-x/2+1 ) {                              // flame
          if ( Candles[x/2]-- > 7 ) Display.dot(x,y,RGB6(4,4,0)) ;//   with flicker
        }
      }
  return false ;   
}

} Advent ;

Scenes.h

/*==================*\
# Time services      #
#  with the RTC chip #
\*==================*/

// Also a simple timer class


#define FakeRTC  // defined if RTC is missing

// =============== Clock ============

#ifndef FakeRTC
// Include the full DS1307 library.
#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 RTC; // create and setup pins // (ToDO name change)
#else
#include "nnnC.h" // Serial parser
#endif

class {
  private:
  int LastMinute = -1 ;
#ifndef FakeRTC
    DateTime Now ;
    int LastMinute = -1 ;
#else
    char C ;
    int V ;
#endif
  
  public:
  int Month, Day, Weekday, Hour, Minute, Second ;

void start() {
#ifndef FakeRTC
// TODO: Setting clock .. done with other program
    
  if ( ! RTC.begin() ) {
    Serial.print(F("RTC not there ? HALTING"));
    while(1) ;
  }
  if ( ! RTC.isrunning() ) {
    Serial.print(F("RTC not running ? HALTING"));
    while(1) ;
  }
  RTC.writeSqwPinMode(0);   // Disable the SqW pulse
#else // faking it - we'll accept NDWHMS from Serial
  Day=22 ; Hour=2; Minute=3 ; Second=4 ;
  Month=11 ; Weekday=5 ;
  Serial.println("Clock static until new value entered nnD nnH nnM nnW nnN") ;
#endif  
} 

void loop() {
#ifndef FakeRTC
  Now = RTC.now() ;
  Day = Now.day() ; Hour = Now.hour() ;
  Minute = Now.minute() ; Second = Now.second() ;
  Weekday = Now.dayOfTheWeek() ; Month=Now.month() ;
#else
  if ( nnnC(&C,&V)) {  
    switch (C) {
      case 'D': Day=V;break ;
      case 'H': Hour=V;break ;
      case 'M': Minute=V;break ;
      case 'S': Second=V;break ;
      case 'W': Weekday=V;break;
      case 'N': Month=V;break;
      default: Serial.println(F("Wrong time setting")) ;
    }
    showtime() ;
  }
#endif
  if ( LastMinute != Minute ) {
    LastMinute = Minute ;
    showtime() ;
  }
}

void showtime() {
  Serial.print("\nDate:");Serial.print(Month);
  Serial.print('/');Serial.print(Day);
  Serial.print('('); Serial.print(Weekday);
  Serial.print(") ");Serial.print(Hour);
  Serial.print(':');Serial.print(Minute);
  Serial.print(':');Serial.println(Second);
}

} Clock ;


// =============== Timer =============

class Timer {
  private:
    int interval ;
    unsigned long starttime  ;
  public:
    
void Set(int interval) {
  this->interval = interval ;
  starttime = millis() ;
//      Serial.print("TmrInt:");Serial.print(this->interval);
}

boolean Chk() {
  unsigned long now = millis() ;
//      Serial.print("TmrChk");
  if ( now - starttime > interval || interval==0 ) {
    starttime = now ;
//        Serial.print("TmrEnd");
    return true ;
  } else return false ;
}
} ; // class Timer

Timer.h

/*--------------------------------------------------------------------------------*\
|   nnnC - Number Command input                                                    |
|                                                                                  |
|  Read serial input of simple argument values in format "nnnC"                    |
|   nnn is a series of (ASCII) digits, with optional sign and decimal point        |
|   C is a single character that is the command or argument name terminates string |
|   C is converted to uppercase.                                                   |
|                                                                                  |
| The call is non-blocking, so command interpretation is done in its own "thread", |
| meaning : You can call it as often as you want in the loop()                     |
| Only when it returns true will the the arguments C and V contain valid values.   |
|                                                                                  |
| Example use:                                                                     |
|   static char C ; static int V ;                                                 |
|   if ( nnnC( &C, &V) ) {                                                         |
|     Serial.print("Command ");Serial.print(C);                                    |
|     Serial.print(" : ");Serial.print(V,DEC);                                     |
|     }                                                                            |
| Use "fffC" instead of "nnnC" for float value                                     |
|     "lllC"                       long                                            |
\*--------------------------------------------------------------------------------*/

#include "nnnC.h"

// Integer version
// NB: The "." acts a command character, not part of a number.
boolean nnnC (char * Cmd, int * Val) {
  static boolean Done = true ;
  static boolean Negative = false ;
  if ( Done ) {                        // if a valid value has been returned before
    Negative = Done = false ;          //   reset for new command
    *Val = 0 ;
    }
  while ( Serial.available()>0 ) {     // interpret all serial bytes ...
    *Cmd = Serial.read() ;
  	if (*Cmd == '-')                     // negative value
  	  Negative = true  ;                 //    set flag
    else if ('0' <= *Cmd && *Cmd <= '9') // valid digit
          *Val = (*Val) * 10 + (*Cmd) - '0' ; //    accumulate input
  	else if (*Cmd == '+')                // A "+" sign
      ;                                  // ignore
    else {                             	 // It is a non-numeric character, i.e. the command.
      if ('a' <= *Cmd && *Cmd <= 'z') *Cmd &= B01011111 ; // forces uppercase (for 7bit ASCII)
      if ( Negative ) *Val = -(*Val) ;   // Make it negative, if required
      Done = true ;                      // note we are done
  	  return true ;                      // and exit
      }
    }
  return false ;
}

// Long version
// NB: The "." acts a command character, not part of a number.
boolean lllC (char * Cmd, long * Val) {
  static boolean Done = true ;
  static boolean Negative = false ;
  if ( Done ) {                        // if a valid value has been returned before
    Negative = Done = false ;          //   reset for new command
    *Val = 0 ;
    }
  while ( Serial.available()>0 ) {     // interpret all serial bytes ...
    *Cmd = Serial.read() ;
  	if (*Cmd == '-')                     // negative value
  	  Negative = true  ;                 //    set flag
    else if ('0' <= *Cmd && *Cmd <= '9') // valid digit
          *Val = (*Val) * 10 + (*Cmd) - '0' ; //    accumulate input
  	else if (*Cmd == '+')                // A "+" sign
      ;                                  // ignore
    else {                             	 // It is a non-numeric character, i.e. the command.
      if ('a' <= *Cmd && *Cmd <= 'z') *Cmd &= B01011111 ; // forces uppercase (for 7bit ASCII)
      if ( Negative ) *Val = -(*Val) ;   // Make it negative, if required
      Done = true ;                      // note we are done
  	  return true ;                      // and exit
      }
    }
  return false ;
}

 // Float version
boolean fffC (char * Cmd, float * Val) {
  static boolean Done = true ;
  static boolean Negative  ;
  static byte Fraction ;
  if ( Done ) {                          // reset for new interpretation.
    Negative = Done = false ;
    *Val = 0 ; Fraction = 0 ;
    }
  while ( Serial.available()>0 ) {       // interpret all serial bytes ...
    *Cmd = Serial.read() ;
	  if (*Cmd == '-') {                   // negative value
	    Negative = true ;                  //    set flag
	    return false ;                     //    and exit
	    }
  	if (*Cmd == '.') {                   // decimal point
	    Fraction = 1 ;                     //    start counting, and thus flag decimal seen.
	    return false ;                     //    and exit
	    }
    if ('0' <= *Cmd && *Cmd <= '9') {    // valid digit
      *Val = (*Val) * 10. + (*Cmd) - '0' ;   // accumulate input
	    if ( Fraction > 0 ) Fraction++ ;   // adjusting for after decimal
        return false ;                   // and exit
	    }
  	if (*Cmd == '+')                     // Accept and ignore a "+" sign
	    return false ;
	// It is a non-numeric character - treated as command character
    if ('a' <= *Cmd && *Cmd <= 'z') *Cmd &= B01011111 ; // forces uppercase (for 7bit ASCII)
    if ( Negative ) *Val = -(*Val) ;     // Make it negative, if required
	  for( ; Fraction > 1 ; Fraction-- ) *Val /= 10.0 ; // divide down decimal
    Done = true ;                        // note we are done
	  return true ;
    }
  }


nnnC.cpp

/*--------------------------------------------------------------------------------*\
|   nnnC - Number Command input                                                    |
|                                                                                  |
|  Read serial input of simple argument values in format "nnnC"                    |
|   nnn is a series of (ASCII) digits, with optional sign and decimal point        |
|   C is a single character that is the command or argument name terminates string |
|   C is converted to uppercase.                                                   |
| Call "fffC" instead of "nnnC" for float value (See prototype declaration below)  |
|      "lllC"                       long
|                                                                                  |
| The call is non-blocking, so command interpretation is done in its own "thread", |
| meaning : You can call it as often as you want in the loop()                     |
| Only when it returns true will the the arguments C and V contain valid values.   |
|                                                                                  |
| Example use:                                                                     |
|   static char C ; static int V ;                                                               |
|   if ( nnnC( &C, &V) ) {                                                         |
|     Serial.print("Command ");Serial.print(C);                                    |
|     Serial.print(" : ");Serial.print(V,DEC);                                     |
|     }                                                                            |
\*--------------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------*\
| Not-a-bug; known limitations:                                             |
| Illegal numeric syntax, how the "-", "+" and "." are placed, are accepted |
| If you use both nnnC and fffC only "switch" between them after a command  |
| Note the parameters must be global or static                              |
| the nnnC only takes int - maximum is +/-32767 as usual                    |
| (But it is easy - just change "int" to "long" and yoy can do longs :-) )  |
\*-------------------------------------------------------------------------*/

#ifndef _nnnC
#define _nnnC

#if ARDUINO < 100
#include <WProgram.h>
#else
#include <Arduino.h>
#endif

boolean nnnC( char *, int * ) ;
boolean fffC( char *, float * ) ;
boolean lllC( char *, long * ) ;

#endif



nnnC.h

/*======================*\
# Character/Icon shapes  #
\*======================*/

// ================ Character bit patterns
// they are on their side so one byte is one column, 5 bytes is one character
const byte PROGMEM SYM[] = {  // PROGMEM isn't happy about 2D arrays
    B0111110,  // 0
    B1000001,
    B1000001,
    B0111110,
    B0000000,
    B0000000,  // 1
    B0000001,
    B1111111,
    B0100001,
    B0000000,
    B0110001,  // 2
    B1001001,
    B1000101,
    B0100011,
    B0000000,
    B1100110,  // 3
    B1011001,
    B1001001,
    B1000010,
    B0000000,
    B0001000,  // 4
    B1111111,
    B0101000,
    B0011000,
    B0000000,
    B1001110,  // 5
    B1010001,
    B1010001,
    B1110010,
    B0000000,
    B0100110,  // 6
    B1001001,
    B1001001,
    B0111110,
    B0000000,
    B1110000,  // 7
    B1001100,
    B1000011,
    B1000000,
    B0000000,
    B0110110,  // 8
    B1001001,
    B1001001,
    B0110110,
    B0000000,
    B0111110,  // 9
    B1001001,
    B1001001,
    B0110010,
    B0000000,
    B00000110,   // (10)Tree
    B00101110,
    B11111111,
    B00101110,
    B00000110,
  } ;

// This should be a struct with the image and the twinkle x/y list
const byte IMG[][YY][XX] = {
{  // Pretty test, nested rectangles in colours
  { RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(0,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,3,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(0,3,0), RGB6(0,0,2), RGB6(2,2,2), RGB6(4,4,4), RGB6(4,4,4), RGB6(2,2,2), RGB6(0,0,2), RGB6(0,3,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(0,3,0), RGB6(0,0,2), RGB6(2,2,2), RGB6(4,4,4), RGB6(4,4,4), RGB6(2,2,2), RGB6(0,0,2), RGB6(0,3,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(0,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,3,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(4,0,0) }, 
  { RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0), RGB6(4,0,0) }, 
},  {  // XmasTree
  { RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(5,5,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0) }, 
  { RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(0,3,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0) }, 
  { RGB6(1,1,0), RGB6(1,1,0), RGB6(4,0,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0) }, 
  { RGB6(1,1,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0) }, 
  { RGB6(1,1,0), RGB6(1,1,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(4,0,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0) }, 
  { RGB6(1,1,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0) }, 
  { RGB6(0,3,0), RGB6(4,0,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(0,3,0), RGB6(1,1,0), RGB6(2,0,2), RGB6(2,0,2) }, 
  { RGB6(1,1,0), RGB6(1,1,0), RGB6(0,2,0), RGB6(0,3,0), RGB6(0,2,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(1,1,0), RGB6(2,0,2), RGB6(2,0,2) }, 
},  {  // Heart  
  { RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0) }, 
  { RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(3,0,0), RGB6(3,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0), RGB6(0,0,0) }, 
} ,  {  // Star
  { RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(2,2,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2) }, 
  { RGB6(2,2,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(3,3,0), RGB6(3,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2) }, 
  { RGB6(0,0,2), RGB6(2,2,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(2,2,0), RGB6(2,2,0) }, 
  { RGB6(0,0,2), RGB6(0,0,2), RGB6(3,3,0), RGB6(4,4,0), RGB6(4,4,0), RGB6(4,4,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(0,0,2) }, 
  { RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(3,3,0), RGB6(4,4,0), RGB6(4,4,0), RGB6(3,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2) }, 
  { RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(3,3,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(3,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2) }, 
  { RGB6(0,0,2), RGB6(0,0,2), RGB6(2,2,0), RGB6(3,3,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(3,3,0), RGB6(3,3,0), RGB6(0,0,2), RGB6(0,0,2) }, 
  { RGB6(0,0,2), RGB6(2,2,0), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(0,0,2), RGB6(2,2,0), RGB6(2,2,0), RGB6(0,0,2) }, 
},  // next
} ;
const byte TXY[][3] = { // variable length list. X>253:end of variable list, X=254 use Snow.
  { 1,1,RGB6(0,0,0) }, { XX-2,YY-2,RGB6(4,4,4) }, { 255,0,0 },   // Test
  { 254,0,0 },                                                   // XMas Tree
  { 4,2,RGB6(0,0,0) }, { 5,2,RGB6(0,0,0) }, { 4,3,RGB6(0,0,0) }, 
  { 5,3,RGB6(0,0,0) }, { 4,7,RGB6(1,0,0) }, { 5,7,RGB6(1,0,0) }, { 255,0,0 }, // Heart
  { 0,1,RGB6(5,5,5) }, { 8,7,RGB6(5,5,5) }, { 5,0,RGB6(4,4,2) }, { 255,0,0 }, // Star
} ; 

// sideways, like SYM, but so wide it will scroll with marquee
// this will be displayed offset, it's only using 6 rows
const byte PROGMEM GODJUL [] = 
 {  B000100,  // +
    B001110,
    B000100,
    B000000,
    B000000,
    B011110,  // G
    B100001,
    B100101,
    B010110,
    B000000,
    B000110,  // o
    B001001,
    B000110,
    B000000,
    B000110,  // d
    B001001,
    B111111,
    B000000,
    B000000,
    B000010,  // J
    B000001,
    B100001,
    B111110,
    B100000,
    B000111,  // u
    B000001,
    B000111,
    B000000,
    B111111,  // l
    B000001,
    B000000,
    B000000,
    B000100,  // +
    B001110,
    B000100,
} ; 

Symbols.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
RTClib
# ---
