-         

Ergebnis 1 bis 5 von 5

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

  1. #1
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452

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

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    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.
    Geändert von HaWe (05.09.2015 um 11:34 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  2. #2
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    7.557
    .. 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.
    Ciao sagt der JoeamBerg

  3. #3
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452
    zur Baudrate: mit 128000 oder 64000 oder 38400 oder 19200 oder 9600: alles genau so lahm.
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  4. #4
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452
    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!
    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);
          
      
    }
    
    
    //=====================================================================================
    //=====================================================================================
    Geändert von HaWe (06.09.2015 um 11:38 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  5. #5
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    2.452
    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!
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

Ähnliche Themen

  1. [ERLEDIGT] Serielle Kommunikation Mega 16 - Mega 162, für mich unerklärbarer Fehler
    Von #fritz# im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 4
    Letzter Beitrag: 01.04.2012, 23:15
  2. Antworten: 3
    Letzter Beitrag: 03.12.2009, 19:36
  3. RN-Mega 128 Funk keine Verbindung möglich
    Von Chaennoe im Forum Schaltungen und Boards der Projektseite Mikrocontroller-Elektronik.de
    Antworten: 3
    Letzter Beitrag: 02.11.2009, 11:29
  4. Controllerboard für Mega 16, Mega 32 und Mega 644
    Von Teslafan im Forum Konstruktion/CAD/Sketchup und Platinenlayout Eagle & Fritzing u.a.
    Antworten: 4
    Letzter Beitrag: 02.05.2009, 01:01
  5. Wieviele Servos an den Mega 8 oder Mega 16 ?
    Von minium :) im Forum Elektronik
    Antworten: 4
    Letzter Beitrag: 06.10.2006, 19:03

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •