? schnelle serielle Verbindung per strings[48] (z.B. Mega <=> Mega, Serial1)

hallo,
ich verzweifle langsam, aber kriegs bisher leider nicht hin:

ich versuche mich an einer 2-Weg UART Verbindung (abwechselnd, half duplex, Mega <-> Mega, per Serial1, bis zu 256000 baud), doch ist diese unglaublich langsam.
Ich will einen byte array[48] oder entspr. String (später evtl. noch etwas länger) zwischen beiden megas hin und her schicken, jeder ändert in meiner testweisen Versuchsanordunung dabei in 1 einzigen Zelle den Inhalt ab (+1), bevor er ihn zurückschickt .

Die Teilnehmer heißen "master" und "slave", obwohl in beide Richtungen auf identische Weise - abwechselnd - gesendet und empfangen wird.

Selbst wenn man den Fehler-Check beim Empfang-Teil abschaltet, bekomme ich nur je 1x pro Sekunde die Arrays einmal hin und einmal zurückgeschickt !

Damit der Array immer ab Zelle 0 gelesen wird ohne dass Verschiebungen auftreten, belege ich Zelle 0 mit einem konstanten Byte (bsync=255) zur Erkennung des Array-Starts. Zelle 1 enthält noch eine optionale zusätzliche Checksum.



Da ich nicht über die 1-sec-Sendetaktgeschwindigkeit hinauskomme und ich auch keine Fehler in meinem Code finde, die dies so langsam machen -

wo finde ich funktionierenden Code, um lange Arrays oder Strings (mindestens 48 Bytes lang) schnell zwischen zwei Arduinos hin- und her zu schicken?
Mindestens 10x pro Sekunde, besser noch viel schneller.

Da muss es doch gute und bewährte Lösungen geben!


Nur zur Info, was ich bisher gemacht habe (nicht durch die Display-Steuerung am Anfang irritieren lassen, ich muss leider mehrere unterschiedliche Displays verwenden können):

Code:

---

/*    Tx master        Transmitter

*/

#include <SPI.h>
#include <SD.h>
#include <UTFTQD.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9340.h>




//================================================================================​=====
// TFT LCD
//================================================================================​=====
#define  UTFT_SmallFont    8 // UTFT 8x10
#define  UTFT_MediumFont  12 // UTFT ++
#define  UTFT_BigFont      18 // UTFT +++
#define  _SmallFont_        1 // 9341 6x9
#define  _MediumFont_      2 // 9341 12x16
#define  _BigFont_          3 // 9341 18x23

int16_t  LCDmaxX , LCDmaxY ;                // display size
int16_t  _curx_, _cury_,                    // last x,y cursor pos on TFT screen
        _maxx_, _maxy_;                    // max. x,y cursor pos on TFT screen     
char    wspace[128];                      // line of white space


// set LCD TFT type
int16_t  LCDTYPE  =  -1;

#define  _LCD1602_    1  // LCD1602  Hitachi HD44780 driver <LiquidCrystal.h>
                          // http://www.arduino.cc/en/Tutorial/LiquidCrystal  //
#define  _SERLCD_    2  // Sparkfun serLCD 16x2 
                          // http://playground.arduino.cc/Code/SerLCD  //
#define  _UTFT_      4  // Henning Karlsen UTFT 2.2-2.4" 220x176 - 320x240 lib
                          // http://henningkarlsen.com/electronics/library.php?id=51  //
#define _ILI9341_    8  // https://github.com/adafruit/Adafruit_ILI9340
                          // https://github.com/adafruit/Adafruit-GFX-Library //
                         
                         
//--------------------------------------------------------------------------------------------------
#define  UTFT_cs      52    // <<<<<<<< adjust!

//UTFT  qdUTFT(Model, SDA=MOSI,  SCL, CS,        RESET,  RS)    // Due: 3 exposed SS pins: 4,10,52
  UTFT  qdUTFT(QD220A,  A2,    A1,  A5,        A4,    A3);  // adjust model parameter and pins!
//UTFT  qdUTFT(QD220A,  50,    49,  UTFT_cs,  0,    51);  // A0->Vc (LED), A4->BoardReset
extern  uint8_t SmallFont[];
//--------------------------------------------------------------------------------------------------
#define    tft_cs    50
#define    tft_dc    49
#define    tft_rst    0
Adafruit_ILI9340  tft = Adafruit_ILI9340(tft_cs, tft_dc, tft_rst);

//--------------------------------------------------------------------------------------------------

int16_t  fontwi= 8;  // default
int16_t  fonthi=10;  // default


void putfonttype(uint8_t fsize) {
  if(LCDTYPE==_UTFT_)  { fontwi= qdUTFT.getFontXsize(); fonthi=qdUTFT.getFontYsize(); }
  else
  if(fsize==_SmallFont_)    { fontwi= 6; fonthi=9; }  // 5x7 + overhead ?
  else
  if(fsize==_MediumFont_)    { fontwi=12; fonthi=16; } // ?
  else
  if(fsize==_BigFont_)      { fontwi=18; fonthi=23; } // ?
 
  _maxx_ = LCDmaxX / fontwi;    // max number of letters x>>
  _maxy_ = LCDmaxY / fonthi;    // max number of letters y^^
  memset(wspace, ' ', _maxx_);  // line of white space
  wspace[_maxx_]='\0';
}



void setlcdorient(int8_t orient) {
  if(LCDTYPE==_ILI9341_) {
      tft.setRotation(orient);
      LCDmaxX=tft.width();
      LCDmaxY=tft.height();       
  }
}

void lcdcls()  {                                                       
  if(LCDTYPE==_UTFT_)      { qdUTFT.clrScr();                } 
  if(LCDTYPE==_ILI9341_)  { tft.fillScreen(ILI9340_BLACK);  }
  _curx_ =0;  _cury_ =0;
}

void curlf()  {                                                       
  _curx_=0;
  if( _cury_ <=(LCDmaxY-10) ) _cury_+=fonthi;
  else _cury_=0; 
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(0, _cury_); } 
}



void curxy(int16_t  x,  int16_t  y) {
  _curx_ = x;
  _cury_ = y;
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(x, y); }
}


void lcdprintxy(int16_t x, int16_t y, char * str) {
  if(LCDTYPE==_UTFT_)    { qdUTFT.print(str,x,y); _curx_=x+strlen(str)*fontwi; _cury_=y; }
  else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(x,y);  tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
  }
}


void lcdprint(char * str) {
    if(LCDTYPE==_UTFT_)    { qdUTFT.print(str, _curx_, _cury_); _curx_=_curx_+strlen(str)*fontwi; }
    else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(_curx_, _cury_); tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
    }
}


void initlcd(uint8_t orient) { // 0,2==Portrait  1,3==Landscape
  if(LCDTYPE==_UTFT_) {
      qdUTFT.InitLCD();
      LCDmaxX=qdUTFT.getDisplayXSize();
      LCDmaxY=qdUTFT.getDisplayYSize();
      qdUTFT.setFont(SmallFont);
      putfonttype(UTFT_SmallFont);
      fontwi=qdUTFT.getFontXsize();
      fonthi=qdUTFT.getFontYsize();
  }
  else
  if(LCDTYPE==_ILI9341_) {
      tft.begin();
      setlcdorient(orient);     
      tft.setTextSize(_SmallFont_);
      putfonttype(_SmallFont_);
  } 
} 






//================================================================================​=====
//================================================================================​=====

const  uint8_t  bwidth=48;
uint8_t  bsync=255;
uint8_t  val[bwidth];
uint8_t  inval[bwidth];

//================================================================================​=====
#define UARTclock  128000

void setup() {
  char sbuf[128]; 
  int32_t  i=0;
       
  // Serial
  Serial.begin(115200);      // USB terminal
  Serial1.begin(UARTclock);  // RX-TX UART
  Serial1.parseInt();        //clear any garbage in the buffer.
 
 
  // TFT LCD
  LCDTYPE = _UTFT_;
  initlcd(1); 
  sprintf(sbuf, "LCD=%d wi%d x hi%d",LCDTYPE,LCDmaxX,LCDmaxY);
  lcdcls(); lcdprint(sbuf);
 
 
  sprintf(sbuf, "setup(): done.");
  curlf(); curlf(); lcdprint(sbuf);
 
  lcdcls();
 
  sprintf(sbuf, "Tx master, clock= %ld", UARTclock );
  lcdprintxy(0, 0, sbuf);

}


//================================================================================​=====
//================================================================================​=====


int checksum(uint8_t array[]) {
  int32_t  sum=0;
  for(int i=2; i<bwidth; ++i) sum+=(array[i]);
  return (sum & 0x00ff); 
} 


//================================================================================​=====

void displayvalues(int line, char * caption, uint8_t array[]) {
  int cnt;
  char sbuf[128];
 
  sprintf(sbuf, "%s cks=%4d", caption, array[1]);
  lcdprintxy(0, line, sbuf); 
  //Serial.println(sbuf);
  for(cnt=0; cnt<8; ++cnt) {
    sprintf(sbuf, "%3d ", array[cnt]);      // print on TFT
    lcdprintxy(cnt*3*8, line+10, sbuf);
    //Serial.print(sbuf);                      // Print value to the Serial Monitor
  }   
  //Serial.println();
 
} 


//================================================================================​=====
//================================================================================​=====

void loop()
{
  char    sbuf[128], chk;   
  static  int cnt=0;
  uint8_t  ibuf[bwidth];
 

  //  send to Rx slave Arduino
 
  //Serial.println(); 
  chk=(byte)checksum(val);
  val[1]=chk; 
  val[0]=bsync;
  for(cnt=0; cnt<bwidth; ++cnt) {       
    Serial1.write(val[cnt]);        // Send value to the Rx Arduino       
  }       
  displayvalues(20, "Transmitted...: ", val);
 
  //    Receive from Rx slave Arduino
 
  cnt=0;
  memset(ibuf, 0, sizeof(ibuf)); 
   
  while ( (Serial1.available() < bwidth)  ) ;
  if(Serial1.available() >= bwidth)  {
    for(int cnt=0; cnt<bwidth; cnt++)  ibuf[cnt] = Serial1.read(); // Then: Get them.
  }
   
  if( ibuf[0]==bsync ) {                      // byte 0 == syncbyte ?
    displayvalues(60, "Received...:", ibuf);
    chk=(byte)checksum(ibuf);                     
    //if(chk==ibuf[1]) {                        // chksum ok? <<<<<<<<<<< outcomment ?
        memcpy(inval, ibuf, sizeof(ibuf));
        displayvalues(100, "checked...:", inval);
   
        // change invalues to send back!
        memcpy(val, inval, sizeof(val));      // copy inbuf to outbuf
        val[0]=bsync; 
        val[4]+=1;                            // change [4] to send back
    //}
  } 

}

//================================================================================​=====
//================================================================================​=====

---

Code:

---

/*    Rx slave      Receiver

*/

#include <SPI.h>
#include <SD.h>
#include <UTFTQD.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9340.h>





//================================================================================​=====
// TFT LCD
//================================================================================​=====
#define  UTFT_SmallFont    8 // UTFT 8x10
#define  UTFT_MediumFont  12 // UTFT ++
#define  UTFT_BigFont      18 // UTFT +++
#define  _SmallFont_        1 // 9341 6x9
#define  _MediumFont_      2 // 9341 12x16
#define  _BigFont_          3 // 9341 18x23

int16_t  LCDmaxX , LCDmaxY ;                // display size
int16_t  _curx_, _cury_,                    // last x,y cursor pos on TFT screen
        _maxx_, _maxy_;                    // max. x,y cursor pos on TFT screen     
char    wspace[128];                      // line of white space


// set LCD TFT type
int16_t  LCDTYPE  =  -1;

#define  _LCD1602_    1  // LCD1602  Hitachi HD44780 driver <LiquidCrystal.h>
                          // http://www.arduino.cc/en/Tutorial/LiquidCrystal  //
#define  _SERLCD_    2  // Sparkfun serLCD 16x2 
                          // http://playground.arduino.cc/Code/SerLCD  //
#define  _UTFT_      4  // Henning Karlsen UTFT 2.2-2.4" 220x176 - 320x240 lib
                          // http://henningkarlsen.com/electronics/library.php?id=51  //
#define _ILI9341_    8  // https://github.com/adafruit/Adafruit_ILI9340
                          // https://github.com/adafruit/Adafruit-GFX-Library //
                         
                         
//--------------------------------------------------------------------------------------------------
#define  UTFT_cs      52    // <<<<<<<< adjust!

//UTFT  qdUTFT(Model, SDA=MOSI,  SCL, CS,        RESET,  RS)    // Due: 3 exposed SS pins: 4,10,52
  UTFT  qdUTFT(QD220A,  A2,    A1,  A5,        A4,    A3);  // adjust model parameter and pins!
//UTFT  qdUTFT(QD220A,  50,    49,  UTFT_cs,  0,    51);  // A0->Vc (LED), A4->BoardReset
extern  uint8_t SmallFont[];
//--------------------------------------------------------------------------------------------------
#define    tft_cs    50
#define    tft_dc    49
#define    tft_rst    0
Adafruit_ILI9340  tft = Adafruit_ILI9340(tft_cs, tft_dc, tft_rst);

//--------------------------------------------------------------------------------------------------

int16_t  fontwi= 8;  // default
int16_t  fonthi=10;  // default


void putfonttype(uint8_t fsize) {
  if(LCDTYPE==_UTFT_)  { fontwi= qdUTFT.getFontXsize(); fonthi=qdUTFT.getFontYsize(); }
  else
  if(fsize==_SmallFont_)    { fontwi= 6; fonthi=9; }  // 5x7 + overhead ?
  else
  if(fsize==_MediumFont_)    { fontwi=12; fonthi=16; } // ?
  else
  if(fsize==_BigFont_)      { fontwi=18; fonthi=23; } // ?
 
  _maxx_ = LCDmaxX / fontwi;    // max number of letters x>>
  _maxy_ = LCDmaxY / fonthi;    // max number of letters y^^
  memset(wspace, ' ', _maxx_);  // line of white space
  wspace[_maxx_]='\0';
}



void setlcdorient(int8_t orient) {
  if(LCDTYPE==_ILI9341_) {
      tft.setRotation(orient);
      LCDmaxX=tft.width();
      LCDmaxY=tft.height();       
  }
}

void lcdcls()  {                                                       
  if(LCDTYPE==_UTFT_)      { qdUTFT.clrScr();                } 
  if(LCDTYPE==_ILI9341_)  { tft.fillScreen(ILI9340_BLACK);  }
  _curx_ =0;  _cury_ =0;
}

void curlf()  {                                                       
  _curx_=0;
  if( _cury_ <=(LCDmaxY-10) ) _cury_+=fonthi;
  else _cury_=0; 
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(0, _cury_); } 
}



void curxy(int16_t  x,  int16_t  y) {
  _curx_ = x;
  _cury_ = y;
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(x, y); }
}


void lcdprintxy(int16_t x, int16_t y, char * str) {
  if(LCDTYPE==_UTFT_)    { qdUTFT.print(str,x,y); _curx_=x+strlen(str)*fontwi; _cury_=y; }
  else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(x,y);  tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
  }
}


void lcdprint(char * str) {
    if(LCDTYPE==_UTFT_)    { qdUTFT.print(str, _curx_, _cury_); _curx_=_curx_+strlen(str)*fontwi; }
    else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(_curx_, _cury_); tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
    }
}


void initlcd(uint8_t orient) { // 0,2==Portrait  1,3==Landscape
  if(LCDTYPE==_UTFT_) {
      qdUTFT.InitLCD();
      LCDmaxX=qdUTFT.getDisplayXSize();
      LCDmaxY=qdUTFT.getDisplayYSize();
      qdUTFT.setFont(SmallFont);
      putfonttype(UTFT_SmallFont);
      fontwi=qdUTFT.getFontXsize();
      fonthi=qdUTFT.getFontYsize();
  }
  else
  if(LCDTYPE==_ILI9341_) {
      tft.begin();
      setlcdorient(orient);     
      tft.setTextSize(_SmallFont_);
      putfonttype(_SmallFont_);
  } 
} 



//================================================================================​=====
//================================================================================​=====

const    uint8_t  bwidth=48;
uint8_t  bsync=255;
uint8_t  val[bwidth];
uint8_t  inval[bwidth];


//================================================================================​=====
#define UARTclock  128000

void setup() {
  char sbuf[128]; 
  int32_t  i=0;
       
  // Serial
  Serial.begin(115200);  // USB terminal
  Serial1.begin(UARTclock);  // RX-TX UART
  Serial.parseInt();      // clear any garbage in the buffer.
 
  // GPIO pins default = INPUT_PULLUP, 13 for LED13
  Serial.println();
  Serial.println("GPIO pin mode default: INPUT_PULLUP");
  for ( i= 2; (i<=13); ++i)  pinMode(i, INPUT_PULLUP);
  pinMode(13, OUTPUT);
  for ( i=22; (i<=53); ++i)  pinMode(i, INPUT_PULLUP);
 
 
  // TFT LCD
  Serial.println();
  LCDTYPE = _UTFT_;
  Serial.print("init LCD...");
  initlcd(1); 
  Serial.println(" done.");  lcdcls();
  sprintf(sbuf, "LCD=%d wi%d x hi%d",LCDTYPE,LCDmaxX,LCDmaxY);
  Serial.println(sbuf);
  Serial.println();
  lcdcls(); lcdprint(sbuf);
 
  sprintf(sbuf, "setup(): done.");
  Serial.println(); Serial.println(sbuf); 
  curlf(); curlf(); lcdprint(sbuf);

  lcdcls();
 
  sprintf(sbuf, "Rx slave, clock= %ld", UARTclock );;
  lcdprintxy(0, 0, sbuf);


}


//================================================================================​=====
//================================================================================​=====


int checksum(uint8_t array[]) {
  uint32_t  sum=0;
  for(int i=2; i<bwidth; ++i) sum+=(array[i]);
  return (sum & 0x00ff); 
} 


//================================================================================​=====

void displayvalues(int line, char * caption, uint8_t array[]) {
  int cnt;
  char sbuf[128];
 
  sprintf(sbuf, "%s cks=%d", caption, array[1]);
  lcdprintxy(0, line, sbuf); 
  //Serial.println(sbuf);
  for(cnt=0; cnt<8; ++cnt) {
    sprintf(sbuf, "%3d ", array[cnt]);      // print on TFT
    lcdprintxy(cnt*3*8, line+10, sbuf);
    //Serial.print(sbuf);                      // Print value to the Serial Monitor
  }   
  //Serial.println(); 
 
} 




//================================================================================​=====


void loop(){
  char    sbuf[128], chk;   
  static  int cnt=0;
  uint8_t  ibuf[bwidth];

 
  cnt=0;
  memset(ibuf, 0, sizeof(ibuf));
   
  while ( (Serial1.available() < bwidth)  ) ;
  if(Serial1.available() >= bwidth)  {
    for(int cnt=0; cnt<bwidth; cnt++)  ibuf[cnt] = Serial1.read(); // Then: Get them.
  }
 
  if( ibuf[0]==bsync ) {                          // byte 0 == syncbyte ?
    displayvalues(20, "Received...:", ibuf);
    chk=(byte)checksum(ibuf);
    //if(chk==ibuf[1]) {                        // chksum ok? <<<<<<<<<<< outcomment ?
        displayvalues(60, "checked...:", ibuf);
        memcpy(inval, ibuf, sizeof(ibuf));
        // change values to send back!
        memcpy(val, inval, sizeof(val));          // copy inbuf to outbuf
        val[0]=bsync; 
        val[6]+=1;                                // change [6] to send back
    //}
  }   
   
 
  // array send back to master:
 
  //Serial.println(); 
  chk=(byte)checksum(val);
  val[1]=chk; 
  for(cnt=0; cnt<bwidth; ++cnt) {       
    Serial1.write(val[cnt]);        // Send value to the Rx Arduino       
  }
  displayvalues(100, "back to master...:", val);
 
     
 
}


//================================================================================​=====
//================================================================================​=====

---

- - - Aktualisiert - - -

ps, nur als Ergänzung:

auch wenn ich die Displayausgaben komplett auskommentiere und nur einen Counter zur Fortschrittskontrolle anzeige, wird es nicht merklich schneller.

Zitat:

---

.. ich verzweifle langsam, aber kriegs bisher leider nicht hin .. 2-Weg UART .. bis zu 256000 baud ..

---

Hohe Baudraten hat der T..el erfunden - aber man kann sie in Griff kriegen. Theoretisch sieht das bei ATMEL-8Bittern und Deinen 256 kBd so aus:

Code:

---

          UBRR-        Aus UBRR        Ziel-            Fehler
        Vorgabe        errechnete      Baudrate           
        bei 20 MHz      Baudraten       
                                                       
            5          208333,33      256000          -18,62%
            4          250000,00      256000          -2,34%
            3          312500,00      256000          22,07%
            2          416666,67      256000          62,76%

---

Macht im Prinzip nix, WENN beide Controller den gleichen Takt fahren. Klar - dann haben die ja auch denselben Fehler - oder, andersrum - gleiches UBRR gewährleistet bei gleichem Quarztakt (Controllertakt!) die problemlose Verständigung. Einschränkung (bei mir z.B.) sind natürlich mehrere unterschiedlich bzw. zufällig getaktete Interrupts.

Praktisch fahre ich bis UBRR = 1, das entspricht 625 kBd. Wie geschrieben - trotz etlicher Interrupts und deren ISR. Allerdings habe ich beiderseits stets einen Eingangs- und einen Ausgangspuffer, meist 64 oder 128 Byte, der FIFO organisiert ist. Diese Puffer können bis 255 groß werden. Die eigentliche Kommunikation läuft also "nebenher", im HIntergrund, ab.

Fazit: hohe Taktraten bei AVRmega-8Bitter gehen gut und problemlos, ich habe kein CRC oä, bis UBRR = 1.

Zum Arduino (seiner IDE) kann ich aber nix schreiben, damit arbeite ich nicht.

zur Baudrate: mit 128000 oder 64000 oder 38400 oder 19200 oder 9600: alles genau so lahm.

update: ein paar KLeinigkeiten habe ich jetzt noch hier und da verändert und da und dort was rumprobiert - aber die Geschwindigkeit fürs hin- und her-schicken der Arrays ist nach wie vor unter aller Sau. 2 sec für 48bytes lange Arrays!!
Selbst bei der halben Baudrate (19200 statt 38400) müsste ich 50x so schnell übertragen können!

hier der aktuelle Code wen's interessiert, aber ich denke, ich brauche wirklich was fertiges, funktionierendes!

Zitat:

---

Da muss es doch gute und bewährte Lösungen geben!

---

Code:

---

/*    Tx  master
      ver 0004a 
      IDE 1.6.5
 */

#include <SPI.h>
#include <SD.h>
#include <UTFTQD.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9340.h>

#define  clock()  millis()


//=====================================================================================
// TFT LCD
//=====================================================================================
#define  UTFT_SmallFont    8 // UTFT 8x10
#define  UTFT_MediumFont  12 // UTFT ++
#define  UTFT_BigFont      18 // UTFT +++
#define  _SmallFont_        1 // 9341 6x9
#define  _MediumFont_      2 // 9341 12x16
#define  _BigFont_          3 // 9341 18x23

int16_t  LCDmaxX , LCDmaxY ;                // display size
int16_t  _curx_, _cury_,                    // last x,y cursor pos on TFT screen
        _maxx_, _maxy_;                    // max. x,y cursor pos on TFT screen     
char    wspace[128];                      // line of white space


// set LCD TFT type
int16_t  LCDTYPE  =  -1;

#define  _LCD1602_    1  // LCD1602  Hitachi HD44780 driver <LiquidCrystal.h>
                          // http://www.arduino.cc/en/Tutorial/LiquidCrystal  //
#define  _SERLCD_    2  // Sparkfun serLCD 16x2 
                          // http://playground.arduino.cc/Code/SerLCD  //
#define  _UTFT_      4  // Henning Karlsen UTFT 2.2-2.4" 220x176 - 320x240 lib
                          // http://henningkarlsen.com/electronics/library.php?id=51  //
#define _ILI9341_    8  // https://github.com/adafruit/Adafruit_ILI9340
                          // https://github.com/adafruit/Adafruit-GFX-Library //
                         
                         
//--------------------------------------------------------------------------------------------------
#define  UTFT_cs      52    // <<<<<<<< adjust!

//UTFT  qdUTFT(Model, SDA=MOSI,  SCL, CS,        RESET,  RS)    // Due: 3 exposed SS pins: 4,10,52
  UTFT  qdUTFT(QD220A,  A2,    A1,  A5,        A4,    A3);  // adjust model parameter and pins!
//UTFT  qdUTFT(QD220A,  50,    49,  UTFT_cs,  0,    51);  // A0->Vc (LED), A4->BoardReset
 extern  uint8_t SmallFont[];
//--------------------------------------------------------------------------------------------------
#define    tft_cs    50
#define    tft_dc    49
#define    tft_rst    0
Adafruit_ILI9340  tft = Adafruit_ILI9340(tft_cs, tft_dc, tft_rst);

//--------------------------------------------------------------------------------------------------

int16_t  fontwi= 8;  // default
int16_t  fonthi=10;  // default


void putfonttype(uint8_t fsize) {
  if(LCDTYPE==_UTFT_)  { fontwi= qdUTFT.getFontXsize(); fonthi=qdUTFT.getFontYsize(); }
  else
  if(fsize==_SmallFont_)    { fontwi= 6; fonthi=9; }  // 5x7 + overhead ?
  else
  if(fsize==_MediumFont_)    { fontwi=12; fonthi=16; } // ?
  else
  if(fsize==_BigFont_)      { fontwi=18; fonthi=23; } // ?
 
  _maxx_ = LCDmaxX / fontwi;    // max number of letters x>>
  _maxy_ = LCDmaxY / fonthi;    // max number of letters y^^
  memset(wspace, ' ', _maxx_);  // line of white space
  wspace[_maxx_]='\0';
}



void setlcdorient(int8_t orient) {
  if(LCDTYPE==_ILI9341_) {
      tft.setRotation(orient);
      LCDmaxX=tft.width();
      LCDmaxY=tft.height();       
  }
}

void lcdcls()  {                                                       
  if(LCDTYPE==_UTFT_)      { qdUTFT.clrScr();                } 
  if(LCDTYPE==_ILI9341_)  { tft.fillScreen(ILI9340_BLACK);  }
  _curx_ =0;  _cury_ =0;
}

void curlf()  {                                                       
  _curx_=0;
  if( _cury_ <=(LCDmaxY-10) ) _cury_+=fonthi;
  else _cury_=0; 
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(0, _cury_); } 
}



void curxy(int16_t  x,  int16_t  y) {
  _curx_ = x;
  _cury_ = y;
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(x, y); }
}


void lcdprintxy(int16_t x, int16_t y, char * str) {
  if(LCDTYPE==_UTFT_)    { qdUTFT.print(str,x,y); _curx_=x+strlen(str)*fontwi; _cury_=y; }
  else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(x,y);  tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
  }
}


void lcdprint(char * str) {
    if(LCDTYPE==_UTFT_)    { qdUTFT.print(str, _curx_, _cury_); _curx_=_curx_+strlen(str)*fontwi; }
    else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(_curx_, _cury_); tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
    }
}


void initlcd(uint8_t orient) { // 0,2==Portrait  1,3==Landscape
  if(LCDTYPE==_UTFT_) {
      qdUTFT.InitLCD();
      LCDmaxX=qdUTFT.getDisplayXSize();
      LCDmaxY=qdUTFT.getDisplayYSize();
      qdUTFT.setFont(SmallFont);
      putfonttype(UTFT_SmallFont);
      fontwi=qdUTFT.getFontXsize();
      fonthi=qdUTFT.getFontYsize();
  }
  else
  if(LCDTYPE==_ILI9341_) {
      tft.begin();
      setlcdorient(orient);     
      tft.setTextSize(_SmallFont_);
      putfonttype(_SmallFont_);
  } 
} 






//=====================================================================================
//=====================================================================================

const  uint8_t  bwidth=48;
uint8_t  bsync=255;
uint8_t  val[bwidth];
uint8_t  inval[bwidth];

//=====================================================================================
const uint32_t UARTclock=38400;

void setup() {
  char sbuf[128]; 
  int32_t  i=0;
       
  // Serial
  Serial.begin(115200);      // USB terminal
 
  Serial1.begin(UARTclock);                    // RX-TX UART
  while(Serial1.available())  Serial1.read();  // clear output buffer
  Serial1.setTimeout(1000);
 
 
  // TFT LCD
  LCDTYPE = _UTFT_;
  initlcd(1); 
  sprintf(sbuf, "LCD=%d wi%d x hi%d",LCDTYPE,LCDmaxX,LCDmaxY);
  lcdcls(); lcdprint(sbuf);
 
 
  sprintf(sbuf, "setup(): done.");
  curlf(); curlf(); lcdprint(sbuf);
 
  lcdcls();
 
  sprintf(sbuf, "Tx master, BAUD= %ld", UARTclock );
  lcdprintxy(0, 0, sbuf);

}


//=====================================================================================
//=====================================================================================


uint8_t checksum(uint8_t array[]) {
  int32_t  sum=0;
  for(int i=2; i<bwidth; ++i) sum+=(array[i]);
  return (sum & 0x00ff); 
} 


//=====================================================================================

void displayvalues(int line, char * caption, uint8_t array[]) {
  int cnt;
  char sbuf[128];
 
  sprintf(sbuf, "%s cks=%-4d", caption, array[1]);
  lcdprintxy(0, line, sbuf); 
  //Serial.println(sbuf);
  for(cnt=0; cnt<8; ++cnt) {
    sprintf(sbuf, "%3d ", array[cnt]);      // print on TFT
    lcdprintxy(cnt*3*8, line+10, sbuf);
    //Serial.print(sbuf);                      // Print value to the Serial Monitor
  }   
  //Serial.println();
 
} 


//=====================================================================================
//=====================================================================================

void loop()
{
  char    sbuf[128];   
  static  int cnt=0; 
  uint8_t  ibuf[bwidth], chk;
  uint32_t xtime;
 
  //  send to Rx slave Arduino
 
  //Serial.println(); 
  chk=(byte)checksum(val);
  val[1]=chk; 
  val[0]=bsync;
  for(cnt=0; cnt<bwidth; ++cnt) {       
    Serial1.write(val[cnt]);        // Send value to the Rx Arduino       
  }       
  Serial1.flush();                    // clear output buffer
  displayvalues(20, "Transmitted...: ", val);

 
  //    Receive from Rx slave Arduino
 
  cnt=0;
  memset(ibuf, 0, sizeof(ibuf)); 
   
  while(!Serial1.available() ) {                  // wait for data to come
    if( clock()-xtime >2000)  break;
  }
  if(Serial1.available() )  {
    Serial1.readBytes(ibuf, bwidth);            // Get them.
  }
  while(Serial1.available())  Serial1.read();    // clear input buffer
   
  if( ibuf[0]==bsync ) {                        // byte 0 == syncbyte ?
    displayvalues(60, "Received...:", ibuf);
    chk=(byte)checksum(ibuf);                     
    if( chk == ibuf[1] ) {          // chksum ok? <<<<<<<<<<< outcomment ?
        memcpy(inval, ibuf, sizeof(ibuf));
        //displayvalues(100, "checked...:", inval);
   
        // change invalues to send back!
        memcpy(val, inval, sizeof(val));        // copy inbuf to outbuf
        val[0]=bsync; 
        val[4]+=1;                              // change [4] to send back
    }
  }
 
}

//=====================================================================================
//=====================================================================================

---

Code:

---

/*    Rx  slave     
      ver 0004a
      IDE 1.6.5
 */
 
#include <SPI.h>
#include <SD.h>
#include <UTFTQD.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9340.h>


#define  clock()  millis()


//=====================================================================================
// TFT LCD
//=====================================================================================
#define  UTFT_SmallFont    8 // UTFT 8x10
#define  UTFT_MediumFont  12 // UTFT ++
#define  UTFT_BigFont      18 // UTFT +++
#define  _SmallFont_        1 // 9341 6x9
#define  _MediumFont_      2 // 9341 12x16
#define  _BigFont_          3 // 9341 18x23

int16_t  LCDmaxX , LCDmaxY ;                // display size
int16_t  _curx_, _cury_,                    // last x,y cursor pos on TFT screen
        _maxx_, _maxy_;                    // max. x,y cursor pos on TFT screen     
char    wspace[128];                      // line of white space


// set LCD TFT type
int16_t  LCDTYPE  =  -1;

#define  _LCD1602_    1  // LCD1602  Hitachi HD44780 driver <LiquidCrystal.h>
                          // http://www.arduino.cc/en/Tutorial/LiquidCrystal  //
#define  _SERLCD_    2  // Sparkfun serLCD 16x2 
                          // http://playground.arduino.cc/Code/SerLCD  //
#define  _UTFT_      4  // Henning Karlsen UTFT 2.2-2.4" 220x176 - 320x240 lib
                          // http://henningkarlsen.com/electronics/library.php?id=51  //
#define _ILI9341_    8  // https://github.com/adafruit/Adafruit_ILI9340
                          // https://github.com/adafruit/Adafruit-GFX-Library //
                         
                         
//--------------------------------------------------------------------------------------------------
#define  UTFT_cs      52    // <<<<<<<< adjust!

//UTFT  qdUTFT(Model, SDA=MOSI,  SCL, CS,        RESET,  RS)    // Due: 3 exposed SS pins: 4,10,52
  UTFT  qdUTFT(QD220A,  A2,    A1,  A5,        A4,    A3);  // adjust model parameter and pins!
//UTFT  qdUTFT(QD220A,  50,    49,  UTFT_cs,  0,    51);  // A0->Vc (LED), A4->BoardReset
 extern  uint8_t SmallFont[];
//--------------------------------------------------------------------------------------------------
#define    tft_cs    50
#define    tft_dc    49
#define    tft_rst    0
Adafruit_ILI9340  tft = Adafruit_ILI9340(tft_cs, tft_dc, tft_rst);

//--------------------------------------------------------------------------------------------------

int16_t  fontwi= 8;  // default
int16_t  fonthi=10;  // default


void putfonttype(uint8_t fsize) {
  if(LCDTYPE==_UTFT_)  { fontwi= qdUTFT.getFontXsize(); fonthi=qdUTFT.getFontYsize(); }
  else
  if(fsize==_SmallFont_)    { fontwi= 6; fonthi=9; }  // 5x7 + overhead ?
  else
  if(fsize==_MediumFont_)    { fontwi=12; fonthi=16; } // ?
  else
  if(fsize==_BigFont_)      { fontwi=18; fonthi=23; } // ?
 
  _maxx_ = LCDmaxX / fontwi;    // max number of letters x>>
  _maxy_ = LCDmaxY / fonthi;    // max number of letters y^^
  memset(wspace, ' ', _maxx_);  // line of white space
  wspace[_maxx_]='\0';
}



void setlcdorient(int8_t orient) {
  if(LCDTYPE==_ILI9341_) {
      tft.setRotation(orient);
      LCDmaxX=tft.width();
      LCDmaxY=tft.height();       
  }
}

void lcdcls()  {                                                       
  if(LCDTYPE==_UTFT_)      { qdUTFT.clrScr();                } 
  if(LCDTYPE==_ILI9341_)  { tft.fillScreen(ILI9340_BLACK);  }
  _curx_ =0;  _cury_ =0;
}

void curlf()  {                                                       
  _curx_=0;
  if( _cury_ <=(LCDmaxY-10) ) _cury_+=fonthi;
  else _cury_=0; 
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(0, _cury_); } 
}



void curxy(int16_t  x,  int16_t  y) {
  _curx_ = x;
  _cury_ = y;
  if(LCDTYPE==_ILI9341_)  {tft.setCursor(x, y); }
}


void lcdprintxy(int16_t x, int16_t y, char * str) {
  if(LCDTYPE==_UTFT_)    { qdUTFT.print(str,x,y); _curx_=x+strlen(str)*fontwi; _cury_=y; }
  else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(x,y);  tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
  }
}


void lcdprint(char * str) {
    if(LCDTYPE==_UTFT_)    { qdUTFT.print(str, _curx_, _cury_); _curx_=_curx_+strlen(str)*fontwi; }
    else if(LCDTYPE==_ILI9341_)  {
      tft.setCursor(_curx_, _cury_); tft.print(str);
      _curx_=tft.getCursorX(); _cury_=tft.getCursorY();
    }
}


void initlcd(uint8_t orient) { // 0,2==Portrait  1,3==Landscape
  if(LCDTYPE==_UTFT_) {
      qdUTFT.InitLCD();
      LCDmaxX=qdUTFT.getDisplayXSize();
      LCDmaxY=qdUTFT.getDisplayYSize();
      qdUTFT.setFont(SmallFont);
      putfonttype(UTFT_SmallFont);
      fontwi=qdUTFT.getFontXsize();
      fonthi=qdUTFT.getFontYsize();
  }
  else
  if(LCDTYPE==_ILI9341_) {
      tft.begin();
      setlcdorient(orient);     
      tft.setTextSize(_SmallFont_);
      putfonttype(_SmallFont_);
  } 
} 



//=====================================================================================
//=====================================================================================

const    uint8_t  bwidth=48;
uint8_t  bsync=255;
uint8_t  val[bwidth];
uint8_t  inval[bwidth];


//=====================================================================================
const uint32_t UARTclock=38400;

void setup() {
  char sbuf[128]; 
  int32_t  i=0;
       
  // Serial
  Serial.begin(115200);  // USB terminal
 
  Serial1.begin(UARTclock);                    // RX-TX UART
  while(Serial1.available())  Serial1.read();  // clear output buffer
  Serial1.setTimeout(1000);
 
  // GPIO pins default = INPUT_PULLUP, 13 for LED13
  Serial.println();
  Serial.println("GPIO pin mode default: INPUT_PULLUP");
  for ( i= 2; (i<=13); ++i)  pinMode(i, INPUT_PULLUP);
  pinMode(13, OUTPUT);
  for ( i=22; (i<=53); ++i)  pinMode(i, INPUT_PULLUP);
 
 
  // TFT LCD
  Serial.println();
  LCDTYPE = _UTFT_;
  Serial.print("init LCD...");
  initlcd(1); 
  Serial.println(" done.");  lcdcls();
  sprintf(sbuf, "LCD=%d wi%d x hi%d",LCDTYPE,LCDmaxX,LCDmaxY);
  Serial.println(sbuf);
  Serial.println();
  lcdcls(); lcdprint(sbuf);
 
  sprintf(sbuf, "setup(): done.");
  Serial.println(); Serial.println(sbuf); 
  curlf(); curlf(); lcdprint(sbuf);

  lcdcls();
 
  sprintf(sbuf, "Rx slave, BAUD= %ld", UARTclock );;
  lcdprintxy(0, 0, sbuf);


}


//=====================================================================================
//=====================================================================================


uint8_t checksum(uint8_t array[]) {
  uint32_t  sum=0;
  for(int i=2; i<bwidth; ++i) sum+=(array[i]);
  return (sum & 0x00ff); 
} 


//=====================================================================================

void displayvalues(int line, char * caption, uint8_t array[]) {
  int cnt;
  char sbuf[128];
 
  sprintf(sbuf, "%s cks=%-4d", caption, array[1]);
  lcdprintxy(0, line, sbuf); 
  //Serial.println(sbuf);
  for(cnt=0; cnt<8; ++cnt) {
    sprintf(sbuf, "%3d ", array[cnt]);      // print on TFT
    lcdprintxy(cnt*3*8, line+10, sbuf);
    //Serial.print(sbuf);                      // Print value to the Serial Monitor
  }   
  //Serial.println(); 
 
} 




//=====================================================================================


void loop(){
  char    sbuf[128];   
  static  int cnt=0;
  uint8_t  ibuf[bwidth], chk;
  uint32_t xtime;
 
 
  cnt=0;
  memset(ibuf, 0, sizeof(ibuf));
  xtime=clock(); 
  while(!Serial1.available() ) {                  // wait for data to come
    if( clock()-xtime >2000)  break;
  }                   
  if(Serial1.available() )  {
    Serial1.readBytes(ibuf, bwidth);            // Get them.
  }
  while(Serial1.available())  Serial1.read();    // clear input buffer
 
  if( ibuf[0]==bsync ) {                          // byte 0 == syncbyte ?
    displayvalues(20, "Received...:", ibuf);
    chk=(byte)checksum(ibuf);
    if( chk == ibuf[1] ) {        // chksum ok? <<<<<<<<<<< outcomment ?
        //displayvalues(60, "checked...:", ibuf);
        memcpy(inval, ibuf, sizeof(ibuf));
        // change values to send back!
        memcpy(val, inval, sizeof(val));          // copy inbuf to outbuf
        val[0]=bsync; 
        val[6]+=1;                                // change [6] to send back
    }   
  }   
 
  // array send back to master:
 
  //Serial.println(); 
  chk=(byte)checksum(val);
  val[1]=chk; 
  for(cnt=0; cnt<bwidth; ++cnt) {       
    Serial1.write(val[cnt]);        // Send value to the Rx Arduino       
  }
  Serial1.flush();                    // clear output buffer
  displayvalues(100, "back to master...:", val);
     
 
}


//=====================================================================================
//=====================================================================================

---

keine erfahrenen Arduino-Code-Nutzer hier im Forum, die funktionierenden Code kennen/benutzen ?
Es kann doch nicht sein dass ich der erste bin, der schnell Arrays zwischen 2 Arduinos hin- und wieder zurückschicken will!