Arduino MCU network (up to 10 together for a bigger project)

 
/* Arduino Net-P (i2c processors network) by Zonca Marco 2020
 * 'netMyNAME' ("UPDATER ") max 8 char, 'netMyID' (p8) max 2 char, 
 *  address='netMyAddress' (0x15) max 0xFF, 'netMyPx' (8)
 * 
 * implemented commands (* = to do): ?, reset
 *
 */
 
#include <Wire.h>

const int netMyPx = 8; // netMyPx 0-9
const int netMyAddress = 0x15;  // i2c address 0x15=HEX 21=DEC
const char *netMyID = "p8";  // netMyID
const char *netMyNAME = "UPDATER ";  // netMyNAME
const int ResetPin=17;  // A3 put low for reset

char _CR[2]="";  // CR
char _BEL[2]="";  // BEL
char _ENQ[2]="";  // ENQ
char _ACK[2]="";  // ACK
char _SPACE[2]="";  // SPACE
char _MYADDR[2]="";  // netMyAddress

char lineString[65]="";
char recCommand[65]="";
byte recAddress=0;
byte recType=0;
char data[2]="";
bool isNetDataWaiting=false;
bool isKnownCommand = false;
bool isBusy=false;


void setup() {
  //Serial.begin(38400);
  Wire.begin(netMyAddress);
  Wire.onReceive(receiveEvent);  // i2c event
  Wire.onRequest(netWhoIsEvent);  // i2c whois
  _CR[0] = 13;  // CR
  _BEL[0] = 7;  // BEL
  _ENQ[0] = 5;  // ENQ
  _ACK[0] = 6;  // ACK
  _SPACE[0] = 32;  // SPACE
  _MYADDR[0] = netMyAddress;
}  // end setup()


void loop() {
  if (isNetDataWaiting == true) {
    execNetCommand();
  }
}  // end loop()


void execNetCommand() {  // executes received command
  isBusy=true;
  char park[65]="";
  if (recType == _BEL[0]) {  // char(7) = BEL command type
    isKnownCommand=false;
    if (s_compare(recCommand,"")==0) {  // empty command just do nothing
      isKnownCommand=true;
      prompt();
    }
    s_substring(park,sizeof(park),recCommand,sizeof(recCommand),0,4);  // reset
    if (s_compare(park,"reset") == 0) {
      isKnownCommand=true;
      reset();
    }
    s_substring(park,sizeof(park),recCommand,sizeof(recCommand),0,0);  // ?
    if (s_compare(park,"?") == 0) {
      isKnownCommand=true;
      sdhelp();
    }
    if (isKnownCommand == false) {
      s_assign(lineString,"unknown command",sizeof(lineString));
      dispLine();
      prompt();
    }
  }  // endif recType
  s_clear(recCommand,sizeof(recCommand));
  recType=0;
  recAddress=0;
  isNetDataWaiting=false;
  isBusy=false;
}  // end execNetCommand()


void reset() {  // ------------------------------------------------------------ RESET
  analogWrite(ResetPin,LOW);
}


void sdhelp() {  // ---------------------------------------------- HELP
  s_assign(lineString, "reset", sizeof(lineString));
  dispLine();
  sprintf(lineString,"(free=%d)",s_freemem());
  dispLine();
  prompt();
}  // end help()


void prompt() {  // prompt, ready for commands
  sprintf(lineString,"%d>",netMyPx);
  dispLine();
}  // end prompt()


void dispLine() {  // print information
  s_concat(lineString, _CR, sizeof(lineString));
  txBackToSender();  // tx
  s_clear(lineString, sizeof(lineString));
  delay(100);
}  // end dispLine()


void receiveEvent(int howMany) {  // i2c event incoming requests
  if (isBusy==false) {
    int counter=0;
    s_clear(recCommand, sizeof(recCommand));  // sender command
    recAddress=0;  // sender address
    recType=0;  // sender cmd type
    if (howMany == 0) {  // ignores empty requests
      isNetDataWaiting=false;
    } else {
      while (Wire.available()) {
        data[0]=Wire.read();
        if (counter==0) { recType = data[0]; } // 1st char = cmd type
        if (counter==1) { recAddress = data[0]; } // 2nd char = sender address
        if (counter >1) { // other chars = command
          s_concat(recCommand, data, sizeof(recCommand)); 
        }
        counter++;
      }
      isNetDataWaiting=true;
    }
  }//endisBusy
}  // end receiveEvent()


void netWhoIsEvent() {  // i2c event: 11 bytes = 1=char(5) ENQ, 2-9=netMyNAME 10=netMyPx 11=netMyAddress
  if (isBusy==false) {
    char ccommand[65]="";
    char park[3]="";
    s_concat(ccommand, _ENQ, sizeof(ccommand));  // ENQ
    s_concat(ccommand, netMyNAME, sizeof(ccommand));  // netMyNAME
    s_concat(ccommand, itoa(netMyPx,park,10), sizeof(ccommand));  // netMyPx
    s_concat(ccommand, _MYADDR, sizeof(ccommand));  // netMyAddress
    Wire.write(ccommand);
  }
}  // end netWhoIsEvent()


void txBackToSender() {  // tx back to sender
  char ccommand[65]="";
  s_assign(ccommand, _ACK, sizeof(ccommand));  // ACK=answer data
  s_concat(ccommand, _MYADDR, sizeof(ccommand));  // netMyAddress
  s_concat(ccommand, lineString, sizeof(ccommand));  // data
  Wire.beginTransmission (recAddress);
  Wire.write (ccommand);
  Wire.endTransmission (true);
}  // end txBackToSender()


//------------------------------------------------------------------------- CLEAR
void s_clear(char *dest_source_string, const int dest_sizeof) {  // fills-up with NUL=chr(0)
  memset(dest_source_string, 0, dest_sizeof);
}  // end s_clear()

//------------------------------------------------------------------------- ASSIGN
bool s_assign(char *dest_string, const char *source_string, const int dest_sizeof) {  // copies source to dest
  int _LenS=strlen(source_string);  // how many bytes
  if (_LenS > (dest_sizeof - 1)) {
    return true;  // err 1
  } else {
    strcpy(dest_string, source_string);
    return false;  // ok 0
  }
}  // end s_assign()

//------------------------------------------------------------------------- SUBSTRING
bool s_substring(char *dest_string, const int dest_sizeof, const char *source_string, 
 const int source_sizeof, const int source_from, const int source_to) {  // copies source(from, to) to dest
  if ((source_from < 0) || (source_to < source_from) || ((source_to - source_from + 1) > (dest_sizeof - 1)) 
    || (source_to >= (source_sizeof-1)) || ((source_to - source_from + 1) > (strlen(source_string)))) {
    dest_string[0]=0;  // NUL
    return true;  // err 1
  } else {
    int _Count=0;
    for (int i=source_from;i<(source_to+1);i++) {
      dest_string[_Count]=source_string[i];
      _Count++;
    }
    dest_string[_Count]=0;  // ends with NUL
    return false;  // ok 0
  }
}  // end s_substring()

//------------------------------------------------------------------------- CONCAT
bool s_concat(char *dest_string, const char *source_string, const int dest_sizeof) {  // append source to dest
  int _LenS=strlen(source_string);  // how many bytes source
  int _LenD=strlen(dest_string);  // how many bytes dest
  if ((_LenS + _LenD) > (dest_sizeof - 1)) {
    return true;  // err 1
  } else {
    strcat(dest_string, source_string);
    return false;  // ok 0
  }
}  // end s_concat()

//------------------------------------------------------------------------- COMPARE
bool s_compare(const char *dest_string, const char *source_string) {  // compares source with dest
  int _LenS=strlen(source_string);  // how many bytes source
  int _LenD=strlen(dest_string);  // how many bytes dest
  if (_LenS != _LenD) {  // different length
    return true;  // are different 1
  } else {
    if (strcmp(dest_string, source_string) == 0) {
      return false;  // are the same 0
    } else {
      return true;  // are different 1
    }    
  }
}  // end s_compare()


//------------------------------------------------------------------------- FREEMEM
int s_freemem() {
  extern int __heap_start,*__brkval;
  int v;
  return (int)&v - (__brkval == 0  ? (int)&__heap_start : (int) __brkval); 
}  // end s_freemem()

/* Arduino Net-P (i2c processors network) by Zonca Marco 2020
 * 'netMyNAME' ("CONSOLE ") max 8 char, 'netMyID' (p0) max p9, address='netMyAddress' max 0xFF, 'netMyPx' (0)
 * 
 * implemented commands (* = to do): scan, ckpower, ?, <pxname> <cmd>, reset
 * 
 * scan:      scan [inquiry i2c bus,
 *            i.e. scan
 *            returns a list of active addresses on the bus in form "DDD (0xEE)"...
 *            ends with "'n' found"]
 * ckpower:   ckpower [inquiry power situation
 *            i.e. ckpower
 *            returns "v3=3.3 v5=5.0 vraw=7.0-12.0"]
 * ?:         ? [ask for the list of commands
 *            i.e. ?
 *            returns a list of available commands on board]
 * reset:     reset [force the MPU to reset
 *            i.e. reset]
 *            
 * <pxname> <cmd>: [sends <cmd> to the processor <pxname>           
 *            i.e. SD dir /
 *            returns result of <cmd> from processor <pxname>]
 *            
 */
 
#include <Adafruit_GFX_AS.h>     // Core graphics library customized
#include <Adafruit_ILI9341_AS.h> // Hardware-specific library customized
#include <SPI.h>
#include <SoftwareSerial.h>
#include <Wire.h>
#include <NewTone.h>
#include <PS2Keyboard.h>

// tft pins used for the MINI PRO, we must use hardware SPI
#define _sclk 13
#define _miso 12 // Not used
#define _mosi 11
#define _cs 10
#define _rst 8
#define _dc  9

// Must use hardware SPI for speed
Adafruit_ILI9341_AS tft = Adafruit_ILI9341_AS(_cs, _dc, _rst);

// The scrolling area must be a integral multiple of TEXT_HEIGHT
#define TEXT_HEIGHT 16 // Height of text to be printed and scrolled
#define BOT_FIXED_AREA 0 // Number of lines in bottom fixed area (lines counted from bottom of screen)
#define TOP_FIXED_AREA 16 // Number of lines in top fixed area (lines counted from top of screen)

#define btTX 4  // to "TX-O" pin of bluetooth terminal
#define btRX 5  // to "RX-I" pin of bluetooth terminal
#define btSPEED 38400  // communication speed both serial/keyboard and bluetooth

SoftwareSerial bluetooth(btTX, btRX);  // bluetooth terminal TX+RX
PS2Keyboard keyboard;

// The initial y coordinate of the top of the scrolling area
uint16_t yStart = TOP_FIXED_AREA;
// yArea must be a integral multiple of TEXT_HEIGHT
uint16_t yArea = 320-TOP_FIXED_AREA-BOT_FIXED_AREA;
// The initial y coordinate of the top of the bottom text line
uint16_t yDraw = 320 - BOT_FIXED_AREA - TEXT_HEIGHT;

// Keep track of the drawing x coordinate
uint16_t xPos = 0;
// For the byte we read from the serial port and display
char data[2] = "";

// We have to blank the top line each time the display is scrolled, but this takes up to 13 milliseconds
// for a full width line, meanwhile the serial buffer may be filling... and overflowing
// We can speed up scrolling of short text lines by just blanking the character we drew
// We keep all the strings pixel lengths to optimise the speed of the top line blanking
int blank[19]; 

// other staff
char lineString[65]="";
char command[65]="";
char recCommand[65]="";
byte recAddress=0;
byte recType=0;
char park[65]="";
char netRegisterNames[10][10]={};

bool displayAlsoOnSerial = false;
bool isKnownCommand = false;
bool isNetDataWaiting = false;
bool isBusy=false;
byte netRegisterAddrs[10] = {};
unsigned long prevSCANBUSmillis=0;

const int buzzerPin = 7;
const int vin3Pin = 14;
const int vin5Pin = 15;
const int vin12Pin = 16;
const int netMyPx = 0; // netMyPx 0-9
const int netMyAddress = 0x0a;  // i2c address
const char *netMyID = "p0";  // netMyID
const char *netMyNAME = "CONSOLE ";  // netMyNAME
const int ps2DataPin = 2;
const int ps2IRQpin =  3;
const int SCANBUSinterval = 30000;
const int ResetPin=17;  // A3 put low for reset

char _CR[2]="";  // CR
char _BEL[2]="";  // BEL
char _ENQ[2]="";  // ENQ
char _ACK[2]="";  // ACK
char _SPACE[2]="";  // SPACE
char _MYADDR[2]="";  // netMyAddress

void setup() {
  //Serial.begin(btSPEED);  // serial/keyboard RX only
  bluetooth.begin(btSPEED);  // bluetooth terminal TX/RX
  keyboard.begin(ps2DataPin, ps2IRQpin);
  Wire.begin(netMyAddress);
  Wire.onReceive(receiveEvent);  // i2c event

  _CR[0] = 13;  // CR
  _BEL[0] = 7;  // BEL
  _ENQ[0] = 5;  // ENQ
  _ACK[0] = 6;  // ACK
  _SPACE[0] = 32;  // SPACE
  _MYADDR[0] = netMyAddress;

  netRegisterAddrs[0]=netMyAddress;
  s_trimall(park,netMyNAME,sizeof(park));
  s_assign(netRegisterNames[0],park,sizeof(netRegisterNames[0]));  // 0 it is me

  // Setup the TFT display
  tft.init();
  tft.setRotation(0);
  tft.fillScreen(ILI9341_BLACK);

  // Setup scroll area
  setupScrollArea(TOP_FIXED_AREA, BOT_FIXED_AREA);

  // Top banner
  tft.setTextColor(ILI9341_BLACK, ILI9341_GREEN);
  tft.fillRect(0,0,240,16, ILI9341_GREEN);
  s_assign(park," Net-P Console ",sizeof(park));
  tft.drawCentreString(park,120,0,2);

  // Change colour for scrolling zone
  tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);

  // Zero the array
  for (byte i = 0; i<18; i++) blank[i]=0;

  delay(2000);  // lets other Px to start before "scanbus"
  scanbus(false);
  sprintf(lineString,"%s\r","Ready");
  dispLine();
  NewTone(buzzerPin,200,50);
  prompt();
}

void loop(void) {
  if ((prevSCANBUSmillis+SCANBUSinterval) < millis()) {  // plug & play 'px'
    scanbus(false);
    prevSCANBUSmillis=millis();
  }
  if (bluetooth.available() > 0) { // one character from bluetooth terminal if any
    data[0]=bluetooth.read();
    if (displayAlsoOnSerial==true) {  // usually false
      //Serial.print((char)data[0]);  // to serial/keyboard
      if (data[0] == '\r') {  // cr=cr+lf
        //Serial.print('\n');
      }
    }
    tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
    dispData();  // send to display
    evaluateCommands();  // send to evaluate commands
  }
  if (keyboard.available()) { // one character from ps2 serial keyboard if any
    data[0] = keyboard.read();
    tft.setTextColor(ILI9341_WHITE, ILI9341_BLACK);
    bluetooth.print((char)data[0]);  // send to bluetooth terminal
    dispData();  // send to display
    evaluateCommands();  // send to evaluate commands
  }
  if (isNetDataWaiting==true) {
    execNetCommand();
  }
}  // end loop()


void evaluateCommands() {  // evaluate commands
  byte x=0;
  byte ln=0;
  char cmd[65]="";
  if (data[0] == 13) {  // CR (eol) pressed
    isKnownCommand=false;
    if (s_compare(command,"")==0) {  // empty command just do nothing
      isKnownCommand=true;
      prompt();
    }
    s_substring(park,sizeof(park),command,sizeof(command),0,4);  // reset
    if (s_compare(park,"reset") == 0) {
      isKnownCommand=true;
      reset();
    }
    s_substring(park,sizeof(park),command,sizeof(command),0,3);  // scanbus
    if (s_compare(park,"scan") == 0) {
      isKnownCommand=true;
      scanbus(true);  // true=displays results, false=mute
    }
    s_substring(park,sizeof(park),command,sizeof(command),0,6);  // checkpower
    if (s_compare(park,"ckpower") == 0) {
      isKnownCommand=true;
      checkpower();
    }
    s_substring(park,sizeof(park),command,sizeof(command),0,0);  // ?
    if (s_compare(park,"?") == 0) {
      isKnownCommand=true;
      help();
    }
    for (x=0;x<10;x++) {  // search processor's name for command
      if (x!=netMyPx && netRegisterNames[x][0] != 0) {  // not me, not unknown
        s_assign(park,netRegisterNames[x],sizeof(park));
        s_concat(park," ",sizeof(park));
        ln=strlen(park);
        s_substring(cmd,sizeof(cmd),command,sizeof(command),0,(ln-1));
        if (s_compare(cmd,park) == 0) {  // known processor name
          isKnownCommand=true;
          s_substring(cmd,sizeof(cmd),command,sizeof(command),ln,strlen(command)-1);  // clean command for target processor
          askCommandOnPx(_BEL[0], x, netRegisterAddrs[x], cmd);  // 7=BEL=cmdtype
        }
      }
    }
    if (isKnownCommand == false) {
      sprintf(lineString,"%s\r","unknown cmd");
      dispLine();
      prompt();
    }
    s_clear(command,sizeof(command));
  }
  if (data[0] > 31 && data[0] < 127) {  // only visible ASCII chars (127=DEL)
    s_concat(command,data,sizeof(command));
  }
}  // end evaluateCommands()


void dispData() {  // display single character at a time
  if (data[0] == _CR[0] || xPos>231) {
    xPos = 0;
    yDraw = scroll_line(); // It takes about 13ms to scroll 16 pixel lines
  }
  if (data[0] > 31 && data[0] < 127) {  // only visible ASCII chars (127=DEL)
    xPos += tft.drawChar(data[0],xPos,yDraw,2);
    blank[(18+(yStart-TOP_FIXED_AREA)/TEXT_HEIGHT)%19]=xPos; // Keep a record of line lengths
  }
}  // end dispData()


void terminalData() {  // send to terminal, serial and bluetooth, single char at a time
  if (displayAlsoOnSerial==true) {  // usually false
    //Serial.print((char)data[0]);  // to serial/keyboard
    if (data[0] == _CR[0]) {  // cr=cr+lf
      //Serial.print('\n');
    }
  }
  bluetooth.print((char)data[0]);  // send to bluetooth terminal
}  // end terminalData()


void dispLine() {  // prepare single char by single char
  byte i=0;  //       for display and serial and bluetooth terminal (for internal generated text)
  for (i=0; i<strlen(lineString); i++) {
  data[0]=lineString[i];
    tft.setTextColor(ILI9341_GREEN, ILI9341_BLACK);
    dispData();
    terminalData();
  }
  s_clear(lineString, sizeof(lineString));
}  // end dispString()


void help() {  // provide a list of available commands
  sprintf(lineString,"%s\r","scan");
  dispLine();
  sprintf(lineString,"%s\r","ckpower");
  dispLine();
  sprintf(lineString,"%s\r","<pxname> <cmd>");
  dispLine();
  sprintf(lineString,"%s\r","reset");
  dispLine();
  sprintf(lineString,"(free=%d)\r",s_freemem());
  dispLine();
  prompt();
}  // end help()

void prompt() {  // prompt, ready for commands
  sprintf(lineString,"%d>\r",netMyPx);
  dispLine();
}  // end prompt()


void checkpower() {  // calculate voltages onboard 3v, 5v and raw (12v)
  float n=0;         // sprintf does not work with float
  float n1=0;        // then I print separate int.dec parts of numbers
  int v3i=0;
  int v3d=0;
  int v5i=0;
  int v5d=0;
  int vrawi=0;
  int vrawd=0;

  n = analogRead(vin3Pin);  // v3
  n1=(((6.60 * n) / 1023.00));
  n=(n1 + ((n1 * 1.0) /100));  // arbitrary correction in %)
  v3i=n;
  v3d=float((n-v3i)*100);

  n = analogRead(vin5Pin);  // v5
  n1=(((6.60 * n) / 1023.00));
  n=(n1 + ((n1 * 1.0) /100));  // arbitrary correction in %)
  v5i=n;
  v5d=float((n-v5i)*100);

  n = analogRead(vin12Pin);  // vraw
  n1=(((13.2 * n) / 1023.00));
  n=(n1 + ((n1 * 3.0) /100));  // arbitrary correction in %)
  vrawi=n;
  vrawd=float((n-vrawi)*100);

  sprintf(lineString, "v3=%d.%02d v5=%d.%02d vraw=%d.%02d\r",v3i,v3d,v5i,v5d,vrawi,vrawd);
  dispLine();
  prompt();
}  // end checkpower


void reset() {  // ------------------------------------------------------------ RESET
  analogWrite(ResetPin,LOW);
}


void scanbus(bool isInteractive) {  // scans i2c bus for active addresses
  byte count = 0;                   // true=interactive and force refresh, false=mute and ask for new only
  byte i=0;
  int px=0;
  if (isInteractive==true) {  // shows it and clear Register -> force refresh
    sprintf(lineString,"%s\r","Scanning...");
    dispLine();
    for (px=0;px<10;px++) {  // clear Register
      netRegisterAddrs[px] = 0;
      s_clear(netRegisterNames[px],sizeof(netRegisterNames[px]));
    }
  }
  for (i = 8; i < 128; i++) {  // addresses 0-7 are reserved (7 bits address)
    Wire.beginTransmission (i);
    delay (10);
    if (Wire.endTransmission (true) == 0 || i==netMyAddress) {  // it blocks here if no i2c available! put pullup resistors and check if a device is blocking to GND pins
      sprintf(lineString,"%3d (0x%02X) ",i,i);
      if (i==netMyAddress) {
        netRegisterAddrs[netMyPx] = netMyAddress;
        s_trimall(netRegisterNames[netMyPx],netMyNAME,sizeof(netRegisterNames[netMyPx]));
        s_concat(lineString,netMyID,sizeof(lineString));
        s_concat(lineString," ",sizeof(lineString));
        s_concat(lineString,netRegisterNames[netMyPx],sizeof(lineString));
        s_concat(lineString," [me]",sizeof(lineString));
      } else {
        px=whois(int(i));  // check address
        if (px < 10) {  // 0-9 is a "p", 99 is unknown
          sprintf(park,"p%d %s",px,netRegisterNames[px]);
          s_concat(lineString,park,sizeof(lineString));
        }
      }
      s_concat(lineString,_CR,sizeof(lineString));
      if (isInteractive==true) { dispLine(); };  // shows it
      count++;
    }
  }
  if (isInteractive==true) {  // shows it
    sprintf(lineString,"%d found\r",count);
    dispLine();
    prompt();
  }
}  // end scanbus()


void askCommandOnPx(const int cmdtype, const int px, const int addrs, const char *cmd) {  // ask target processor to execute a command
  char ccommand[65]="";
  s_assign(ccommand, _BEL, sizeof(ccommand));  // BEL
  s_concat(ccommand, _MYADDR, sizeof(ccommand));  // netMyAddress
  s_concat(ccommand, cmd, sizeof(ccommand));  // cmd
  prompt();
  Wire.beginTransmission (addrs);  // ask
  Wire.write(ccommand);
  Wire.endTransmission (true);
}  // end asksd()


int whois(int address) {  // ask name+ID on i2c net, expecting char(5) ENQ as 1st byte
  byte i=0;
  char xtype=0;
  int xid=0;
  char xaddr=0;
  char park1[65]="";
  s_clear(park,sizeof(park));
  s_clear(park1,sizeof(park1));
  Wire.requestFrom(address, 11);  // send request, dest address + nr of bytes
  delay(10);
  i=0;
  while(Wire.available()) {  // read answer
    data[0]=Wire.read();
    i++;
    if (i==1) { xtype=data[0]; };  // byte 1 = answer type must be char(5) ENQ
    if (i>1 && i<10) {  // bytes 2-9 = name
      park[i-2] = data[0]; 
    }
    if (i==10) { xid=atoi(data); };  // byte 10=id
    if (i==11) { xaddr=data[0]; };  // byte 11=address
  }
  if ((xtype == _ENQ[0]) && (int(xaddr) == address) && (xid < 10)) {  // must be a "p"= 0-9, and 10th byte = address, or unknown/wrong answer
    netRegisterAddrs[int(xid)] = xaddr;  // mem id and address
    s_trimall(park1,park,sizeof(park1));
    s_assign(netRegisterNames[int(xid)],park1,sizeof(netRegisterNames[int(xid)]));
    return xid;  // recognized address as "p"
  } else {
    return 99;  // unknown address or answer
  }
}  // end whois()


void execNetCommand() {  // executes received command
  isBusy=true;
  s_clear(park, sizeof(park));
  s_clear(command, sizeof(command));
  if (recType == _BEL[0]) {  // char(7) = BEL command type ---------------- BEL=incoming request
    isKnownCommand=false;
    if (s_compare(recCommand,"")==0) {  // empty command just do nothing
      isKnownCommand=true;
      prompt();
    }
    s_substring(park,sizeof(park),recCommand,sizeof(recCommand),0,0);  // ?
    if (s_compare(park,"?") == 0) {
      isKnownCommand=true;
      help();
    }
    if (isKnownCommand == false) {
      s_assign(lineString,"unknown cmd",sizeof(lineString));
      dispLine();
      prompt();
    }
  }  // endif recType=BEL
  if (recType == _ACK[0]) {  // char(6) = ACK command type ---------------- ACK=incoming answer
    s_assign(lineString,recCommand,sizeof(lineString));
    dispLine();
  }  // endif recType=ACK
  s_clear(recCommand,sizeof(recCommand));
  recType=0;
  recAddress=0;
  isNetDataWaiting=false;
  isBusy=false;
}  // end execNetCommand()

void receiveEvent(int howMany) {  // i2c event incoming requests
  if (isBusy==false) {
    int counter=0;
    s_clear(recCommand, sizeof(recCommand));  // sender command
    recAddress=0;  // sender address
    recType=0;  // sender cmd type
    if (howMany == 0) {  // ignores empty requests
      isNetDataWaiting=false;
    } else {
      while (Wire.available()) {
        data[0]=Wire.read();
        if (counter==0) { recType = data[0]; } // 1st char = cmd type
        if (counter==1) { recAddress = data[0]; } // 2nd char = sender address
        if (counter >1) { // other chars = command
          s_concat(recCommand, data, sizeof(recCommand)); 
        }
        counter++;
      }
      isNetDataWaiting=true;
    }
  }//endisBusy
}  // end receiveEvent()


//------------------------------------------------------------------------- CLEAR
void s_clear(char *dest_source_string, const int dest_sizeof) {  // fills-up with NUL=chr(0)
  memset(dest_source_string, 0, dest_sizeof);
}  // end s_clear()

//------------------------------------------------------------------------- ASSIGN
bool s_assign(char *dest_string, const char *source_string, const int dest_sizeof) {  // copies source to dest
  int _LenS=strlen(source_string);  // how many bytes
  if (_LenS > (dest_sizeof - 1)) {
    return true;  // err 1
  } else {
    strcpy(dest_string, source_string);
    return false;  // ok 0
  }
}  // end s_assign()

//------------------------------------------------------------------------- SUBSTRING
bool s_substring(char *dest_string, const int dest_sizeof, const char *source_string, 
 const int source_sizeof, const int source_from, const int source_to) {  // copies source(from, to) to dest
  if ((source_from < 0) || (source_to < source_from) || ((source_to - source_from + 1) > (dest_sizeof - 1)) 
    || (source_to >= (source_sizeof-1)) || ((source_to - source_from + 1) > (strlen(source_string)))) {
    dest_string[0]=0;  // NUL
    return true;  // err 1
  } else {
    int _Count=0;
    for (int i=source_from;i<(source_to+1);i++) {
      dest_string[_Count]=source_string[i];
      _Count++;
    }
    dest_string[_Count]=0;  // ends with NUL
    return false;  // ok 0
  }
}  // end s_substring()

//------------------------------------------------------------------------- CONCAT
bool s_concat(char *dest_string, const char *source_string, const int dest_sizeof) {  // append source to dest
  int _LenS=strlen(source_string);  // how many bytes source
  int _LenD=strlen(dest_string);  // how many bytes dest
  if ((_LenS + _LenD) > (dest_sizeof - 1)) {
    return true;  // err 1
  } else {
    strcat(dest_string, source_string);
    return false;  // ok 0
  }
}  // end s_concat()

//------------------------------------------------------------------------- COMPARE
bool s_compare(const char *dest_string, const char *source_string) {  // compares source with dest
  int _LenS=strlen(source_string);  // how many bytes source
  int _LenD=strlen(dest_string);  // how many bytes dest
  if (_LenS != _LenD) {  // different length
    return true;  // are different 1
  } else {
    if (strcmp(dest_string, source_string) == 0) {
      return false;  // are the same 0
    } else {
      return true;  // are different 1
    }    
  }
}  // end s_compare()

//------------------------------------------------------------------------- TRIMALL
bool s_trimall(char *dest_string, const char *source_string, const int dest_sizeof) {  // eliminate all 'spaces' from source to dest
  int _LenS=strlen(source_string);  // how many bytes max
  if (_LenS > (dest_sizeof - 1)) {
    return true;  // err 1
  } else {
    int _Count=0;
    for (int i=0;i<(_LenS);i++) {
      if (source_string[i] != _SPACE[0]){
        dest_string[_Count]=source_string[i];
        _Count++;
      }
    }
    dest_string[_Count]=0;  // ends with NUL
    return false;  // ok 0
  }
}  // end s_trimall()

//------------------------------------------------------------------------- FREEMEM
int s_freemem() {
  extern int __heap_start,*__brkval;
  int v;
  return (int)&v - (__brkval == 0  ? (int)&__heap_start : (int) __brkval); 
}  // end s_freemem()



// ##############################################################################################
// Call this function to scroll the display one text line
// ##############################################################################################
int scroll_line() {
  int yTemp = yStart; // Store the old yStart, this is where we draw the next line
  // Use the record of line lengths to optimise the rectangle size we need to erase the top line
  tft.fillRect(0,yStart,blank[(yStart-TOP_FIXED_AREA)/TEXT_HEIGHT],TEXT_HEIGHT, ILI9341_BLACK);

  // Change the top of the scroll area
  yStart+=TEXT_HEIGHT;
  // The value must wrap around as the screen memory is a circular buffer
  if (yStart >= 320 - BOT_FIXED_AREA) yStart = TOP_FIXED_AREA + (yStart - 320 + BOT_FIXED_AREA);
  // Now we can scroll the display
  scrollAddress(yStart);
  return  yTemp;
}

// ##############################################################################################
// Setup a portion of the screen for vertical scrolling
// ##############################################################################################
// We are using a hardware feature of the display, so we can only scroll in portrait orientation
void setupScrollArea(uint16_t TFA, uint16_t BFA) {
  tft.writecommand(ILI9341_VSCRDEF); // Vertical scroll definition
  tft.writedata(TFA >> 8);
  tft.writedata(TFA);
  tft.writedata((320-TFA-BFA)>>8);
  tft.writedata(320-TFA-BFA);
  tft.writedata(BFA >> 8);
  tft.writedata(BFA);
}

// ##############################################################################################
// Setup the vertical scrolling start address
// ##############################################################################################
void scrollAddress(uint16_t VSP) {
  tft.writecommand(ILI9341_VSCRSADD); // Vertical scrolling start address
  tft.writedata(VSP>>8);
  tft.writedata(VSP);
}