- Akku Tests und Balkonkraftwerk Speicher         
Ergebnis 1 bis 5 von 5

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

  1. 05.09.2015, 11:20 #1
    HaWe
    Gast

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

    Anzeige

     E-Bike
    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)
    ZitierenZitieren
  2. 05.09.2015, 12:09 #2
    oberallgeier
    oberallgeier ist offline
    Erfahrener Benutzer Robotik Visionär Avatar von oberallgeier
    Registriert seit
    01.09.2007
    Ort
    Oberallgäu
    Beiträge
    8.680
    .. 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
    ZitierenZitieren
  3. 05.09.2015, 12:55 #3
    HaWe
    Gast
    zur Baudrate: mit 128000 oder 64000 oder 38400 oder 19200 oder 9600: alles genau so lahm.
    ZitierenZitieren
  4. 05.09.2015, 17:34 #4
    HaWe
    Gast
    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)
    ZitierenZitieren
  5. 06.09.2015, 11:41 #5
    HaWe
    Gast
    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!
    ZitierenZitieren
« Vorheriges Thema | Nächstes Thema »

Ä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. Erweiterung; was ist sinnvoller: Mega 32 oder Mega 128
    Von Xandi11 im Forum Robby RP6
    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/3D-Druck/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

Lesezeichen

Berechtigungen

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

Foren-Regeln


fchao-Sinus-Wechselrichter AliExpress