INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
extrem langsame UART Verbindung (Mega-Mega, Serial1)
04.09.2015, 17:02 (Dieser Beitrag wurde zuletzt bearbeitet: 04.09.2015 17:03 von HaWe.)
Beitrag #1
extrem langsame UART Verbindung (Mega-Mega, Serial1)
hallo,
ich versuche mich an einer UART Verbindung (Mega-Mega, Serial1, 256000 baud), doch ist diese unglaublich langsam.
Ich will einen byte array[8] zwischen beiden megas hin und her schicken, jeder ändert 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 etwa alle 5 Sekunden die Arrays einmal hin und einmal zurückgeschickt - mit Fehlern in manchen Array-Zellen!
Mit Fehlercheck ist es nicht wesentlich langsamer, aber dafür 100% genau.

Damit der Array immer ab Zelle 0 gelesen wird, belege ich Zelle 0 mit einem konstanten Byte (bsync=255) zur Erkennung des Array-Starts.
Mache ich das nicht, verschieben sich irgendwann die Zellen-Inhalte komplett.

Zelle 1 enthält die optionale zusätzliche Checksum.

Vertrackt - ich komme aber nicht auf die Stelle, wo der Bremsklotz sitzt.

Trotzdem müsste es doch schneller gehen - wo liegt mein Denkfehler?

Code:
/*    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=8;
uint8_t  bsync=255;
uint8_t  val[]={bsync,1,2,3,0,5,0,7};
uint8_t  inval[bwidth];

//================================================================================​=====
#define UARTclock  256000

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);

}

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

uint8_t checksum(uint8_t array[]) {
  uint32_t  sum=0;
  for(int i=2; i<bwidth; ++i) sum+=(array[i]);
  return (byte)(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<bwidth; ++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=checksum(val);
  val[1]=chk;
  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));

  if (Serial1.available()) {
    delay(10); //allows all serial sent to be received together
    while(Serial1.available() && cnt<bwidth) {
      ibuf[cnt++] = Serial1.read();
    }
  }  

  
  if( ibuf[0]==bsync ) {                       // byte 0 == syncbyte ?
     displayvalues(60, "Received...:", ibuf);
     chk=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:
/*     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=8;
uint8_t  bsync=255;
uint8_t  val[bwidth];
uint8_t  inval[bwidth];


//================================================================================​=====
#define UARTclock  256000

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);


}


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

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<bwidth; ++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();

}


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


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



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


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


  cnt=0;
  memset(ibuf, 0, sizeof(ibuf));

  if (Serial1.available()) {
    delay(10); //allows all serial sent to be received together
    while(Serial1.available() && cnt<bwidth) {
      ibuf[cnt++] = Serial1.read();
    }
  }
  if( ibuf[0]==bsync ) {                          // byte 0 == syncbyte ?
     displayvalues(20, "Received...:", ibuf);
     chk=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=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);

    

}


//================================================================================​=====
//================================================================================​=====
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.09.2015, 19:00
Beitrag #2
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
Hallo,

nimm doch für "UARTclock" mal 57600 statt 256000 und berichte ob es dann 50 Sekunden dauert für die beiden Arrays einmal hin und her zu schicken.

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.09.2015, 20:26 (Dieser Beitrag wurde zuletzt bearbeitet: 04.09.2015 20:52 von HaWe.)
Beitrag #3
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
ja, danke für den Tipp!
ich bin sogar runter bis auf 9600 - keine Geschwindigkeitsänderung.

Dann habe ich den Lese-Code geändert, und siehe da: unabhängig von der Arraylänge (8 bis 48 bytes) geht es jetzt sogar im Sekundentakt, ebenfalls schon bei geringer Taktfrequenz.

Aber schneller geht's immer noch nicht, ich hatte mir mehr versprochen (wenigstens 10x pro Sekunde)... Undecided


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);
  Serial.flush();

  
  //     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);
  Serial.flush();
  
      
  
}


//================================================================================​=====
//================================================================================​=====
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.09.2015, 20:53 (Dieser Beitrag wurde zuletzt bearbeitet: 04.09.2015 20:57 von fraju.)
Beitrag #4
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
Hallo
Ich würde mal versuchen alles rausschmeißen und nur die Sende und Empfangsroutinen belassen.
Senden/empfangen zählen.
Dieser Test ist Controller unabhängig,den einfachen Ardu Syntax wirst du besser kennen als ichWink

Edit:
Ach so, ich würde mit einer Ende Kennung arbeiten.

Nicht jeder Neuling in einem Forum hat keine Ahnung über die Materie!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
04.09.2015, 21:38
Beitrag #5
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
ja, danke, habe ich auch schon probiert: alle Displayanzeigen auskommentiert, nur nen Counter laufen lassen:
auch keine wesentliche schnellere Übertragung.

Jetzt habe ich noch nen anderen Fehler entdeckt:
wenn ich die checksum-Tests drin lasse, blockiert er ab Checksum=128 (64+64 in den Zellen).
Wenn ich den Check rausschmeiße, zählt er locker weiter bis 256, dann kommt erst Überlauf, aber auch dann zählt er ab 0 wieder neu hoch.
Sehr seltsam.

Immerhin die Fehlerzahl ist jetzt auch ohne checks fast immer = null.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.09.2015, 08:09 (Dieser Beitrag wurde zuletzt bearbeitet: 05.09.2015 08:10 von HaWe.)
Beitrag #6
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
ich kriegs nicht hin.

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!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.09.2015, 10:58
Beitrag #7
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
Hi,
apropos UART Speed, in der Doku unter arduino.cc sind nur Baudraten bis 128KBit definiert.
lgbk

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
05.09.2015, 11:19
Beitrag #8
RE: extrem langsame UART Verbindung (Mega-Mega, Serial1)
Das Problem mit der 128 hört sich für mich nach einem signed/unsigned Problem an:
Ein char beim AVR ist mit Vorzeichen (Wertebereich -128...+127). Am besten verwendest Du den Typ uint8_t (unsigned int mit 8 Bit) wenn Du eine Zahl zwischen 0 und 255 verarbeiten möchstest...
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Datenübertragung vom Arduino Mega 2560 zu Hterm Datatom 1 99 13.11.2016 23:08
Letzter Beitrag: hotsystems
  Arduino Mega 2560 läuft nicht Wolfgang50 6 185 13.11.2016 10:50
Letzter Beitrag: Wolfgang50
  Arduino Mega 2560 Manfred1981 4 196 11.11.2016 18:07
Letzter Beitrag: hotsystems
  Attiny45 Bootloader brennen mit Funduino Mega toto1975 63 2.216 23.10.2016 17:08
Letzter Beitrag: hotsystems
Question Mega 2560 defekt? triode 11 365 29.09.2016 07:21
Letzter Beitrag: hotsystems
  If-Bedingung funktioniert nicht bei Serial1.write Datatom 6 226 16.09.2016 20:36
Letzter Beitrag: Datatom
  nrf24 an Mega 2560 jgrothe 2 164 10.09.2016 13:39
Letzter Beitrag: jgrothe
Question Keine Verbindung via USB nach flashen des Programms chaoscrack 5 203 23.08.2016 14:58
Letzter Beitrag: hotsystems
  Arduino mega 2560 mit TFT LCD Touch Shield V1 Clemens55555 17 940 02.08.2016 20:51
Letzter Beitrag: Clemens55555
  Mega: Hardware i2c bus speed (Wire.) verändern? HaWe 10 2.936 14.07.2016 20:09
Letzter Beitrag: Mathias

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste