Sensorwerte auf 2,4 Zoll Display übertragen.

Guten Morgen,

ich bin neu hier und bin momentan dabei ein Beschleunigungssensor zu programmieren.

Ich habe bereits alles hinbekommen was ich eigentlich vor hatte, nur die Feinheiten möchte ich nun auch noch erledigt haben.

Ich habe ein Arduino Mega und ein 2,4 Zoll Display mit einem ILI9341 Treiber. Als Sensor einen MPU6050.

Nun übertrage ich meine Sensorwerte alle 50ms auf das Display was auch funktioniert. Nur überschreibe ich den "alten" Zahlenwert mit dem gleichen Wert nur mit der Textfarbe des Hintergrunds um den nächsten Wert lesen zu können. Was ich auch schon probiert habe ist ein normales Rechteck über mein bestehenden Wert zu schreiben und anschließend der neue Wert.

Meine Variante hat zur Folge, dass bei jedem "neuen" Sensorwert der Anzeigebereich "flackert", da er ja jedes mal (in meinem Fall Blau) den Hintergrund in diesem Bereich zurücksetzt.

Hat jemand Erfahrung oder einen Tipp wie man die Ausgabe ohne dieses Überschreiben der ganzen Werte realisieren kann das dieses "flackern" nicht mehr zustande kommt?

Als Beispiel:

Hier werden die Werte flüssig übergeben.

Vielen Dank

Freue mich auf jede Antwort

Den Wert alle 50 mSekunden zu übertragen halte ich für sehr grenzwertig. Dann flackert es natürlich ordentlich.
Nimm doch mal eine längere Pause dazwischen.

Danke für die Antwort.

Das Problem ist nicht die Frequenz des "flackerns" sondern die Tatsache das es flackert.

Angenommen eine Uhr:

Die Sekunden zählen von 00 bis 59 und dabei sieht man keinen Übergang von der einen auf die andere Sekunde.

Bei mir würde es jetzt 500ms dauern -> kurz den Wert mit der Hintergrundfarbe überschreiben und anschließend wieder den neuen Wert einfügen. Dabei entsteht logischerweise ein kurzes ausblenden des Wertes.

arduino_aero:
... Hat jemand Erfahrung oder einen Tipp wie man die Ausgabe ohne dieses Überschreiben der ganzen Werte realisieren kann das dieses "flackern" nicht mehr zustande kommt?

Als ich mit meine(m|n) OLED-Display(s) gespielt habe, hatte ich das Flackern nur dann, wenn ich das Display nach dem Löschen eines alten Wertes aktualisiert hatte. Wenn ich das Aktualisieren erst nach Löschen und Schreiben des neuen Wertes (Objektes, Pixelwolke, wasauchimmer) gemacht habe, war das Flackern weg.

Hilfreich wäre Dein Sketch. Wie schreibst Du aufs Display und wie steuerst Du dessen Aktualisierung?

Gruß

Gregor

arduino_aero:
Das Problem ist nicht die Frequenz des "flackerns" sondern die Tatsache das es flackert.

Angenommen eine Uhr:

Die Sekunden zählen von 00 bis 59 und dabei sieht man keinen Übergang von der einen auf die andere Sekunde.

Genau das meine ich, da passiert die Aktualisierung jede Sekunde, nicht 50 mSek.

Bei mir würde es jetzt 500ms dauern -> kurz den Wert mit der Hintergrundfarbe überschreiben und anschließend wieder den neuen Wert einfügen. Dabei entsteht logischerweise ein kurzes ausblenden des Wertes.

Dann wird es an deinem Sketch liegen.
Ich verwende ein 2,2" Display mit dem selben Controller und aktualisiere je Sek. 6 Werte (Temperaturen usw.) und da sehe ich kein Flackern. Mache es genau so wie du.

 /*############################################
* 
* Liabries für Display
* 
*###########################################*/

//Arduino LCD TFT 2,4" Touch Display ILI9341

#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_8bit_AS.h>

/*############################################
* 
* Libaries für MPU
* 
*###########################################*/

#include "I2Cdev.h"
#include "MPU6050.h"
#include "Kalman.h"
#include "Wire.h"

/*############################################
* 
* Variablen für Display
* 
*###########################################*/
#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
#define LCD_RESET A4

#define TS_MINX 150
#define TS_MINY 120
#define TS_MAXX 920
#define TS_MAXY 940


#define BLACK   0xFFFF
#define BLUE    0xFFE0
#define RED     0x07FF
#define GREEN   0xF81F
#define CYAN    0xF800
#define MAGENTA 0x07E0
#define YELLOW  0x001F
#define WHITE   0x0000

char aktuelleSeite;

Adafruit_ILI9341_8bit_AS tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

/*############################################
* 
* Variablen für MPU6050
* 
*###########################################*/

MPU6050 accelgyro;

int16_t ax, ay, az;
int16_t gx, gy, gz;

float gLastZ_max_alt, gLastZ_max_neu=0.0;
float gLastZ_min_alt, gLastZ_min_neu=0.0;

#define OUTPUT_READABLE_ACCELGYRO



void readMPU()
{

   accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);

   
   gLastZ_max_alt=az/2048.0;
   gLastZ_min_alt=az/2048.0;

   pinMode(XM, OUTPUT);
   pinMode(YP, OUTPUT);

   tft.setTextSize(2);
   tft.setCursor(100,100);
   tft.setTextColor(WHITE); 
   tft.print(gLastZ_max_alt);
   delay(500);
   tft.setCursor(100,100);
   tft.setTextColor(BLUE); 
   tft.print(gLastZ_max_alt);
   //tft.fillRect(100,100,60,15,BLUE);
   
   
   
   
   if (gLastZ_max_alt>gLastZ_max_neu)

    {
     gLastZ_max_neu=gLastZ_max_alt;
    }

   if(gLastZ_min_alt<gLastZ_min_neu)
   {
     gLastZ_min_neu=gLastZ_min_alt;
   }
   // these methods (and a few others) are also available
   //accelgyro.getAcceleration(&ax, &ay, &az);
   //accelgyro.getRotation(&gx, &gy, &gz);

   #ifdef OUTPUT_READABLE_ACCELGYRO
   
       // display tab-separated accel/gyro x/y/z values
       
       Serial.print(" Maximale negative Last:  ");
       Serial.print(gLastZ_min_neu);

       Serial.print("   Momentane G-Last:   ");
       Serial.print(gLastZ_max_alt); 
       
       Serial.print("   Maximale Positive Last:  "); Serial.println(gLastZ_max_neu);

           
      
   #endif

   #ifdef OUTPUT_BINARY_ACCELGYRO
       Serial.write((uint8_t)(ax >> 8)); Serial.write((uint8_t)(ax & 0xFF));
       Serial.write((uint8_t)(ay >> 8)); Serial.write((uint8_t)(ay & 0xFF));
       Serial.write((uint8_t)(az >> 8)); Serial.write((uint8_t)(az & 0xFF));
       Serial.write((uint8_t)(gx >> 8)); Serial.write((uint8_t)(gx & 0xFF));
       Serial.write((uint8_t)(gy >> 8)); Serial.write((uint8_t)(gy & 0xFF));
       Serial.write((uint8_t)(gz >> 8)); Serial.write((uint8_t)(gz & 0xFF));
   #endif

   // blink LED to indicate activity
   blinkState = !blinkState;
   digitalWrite(LED_PIN, blinkState);
}

// G-Messer Menü

void gMesser ()
{
 
 tft.fillScreen(BLUE);
 tft.setTextSize(3);
 tft.setCursor(100,10);
 tft.setTextColor(WHITE);
 tft.print("G-MESSER");
 backButton();

 
}



void setup() {

 setupMPU();
 
 Serial.begin(9600);
 pinMode(22, OUTPUT);
 pinMode(53,INPUT);
 tft.reset();
 delay(10);
 
 tft.begin(0x9341);
 tft.fillScreen(BLACK);
 tft.setRotation(3);
 
 
}

void loop() {

 pinMode(XM, OUTPUT);
 pinMode(YP, OUTPUT);
 
 gMesser();
 readMPU();      
   
}

Setze das bitte mal in Code-Tags, dann treten auch keine Formatierungsfehler auf.

Schaltfläche </> oben links im Editor.

Edit:
Außerdem würdest du es uns leichter machen, wenn dein Sketch dokumentiert wäre.

Hallo,

warum hilfst du uns nicht, dir zu helfen ?

Du verwendest den Pin A4 für den LCD-Reset.

Wenn du einen Uno o.ä. verwendest, dann funktioniert das nicht.
Die Pins A4 und A5 werden für I2C verwendet, also für deinen Sensor.

Es sei denn, du hast alles umgebogen, was man dank fehlender Dokumentation nicht erkennen kann.

HotSystems:
Du verwendest den Pin A4 für den LCD-Reset.

Wenn du einen Uno o.ä. verwendest, dann funktioniert das nicht.
Die Pins A4 und A5 werden für I2C verwendet, also für deinen Sensor.

Es sei denn, du hast alles umgebogen, was man dank fehlender Dokumentation nicht erkennen kann.

arduino_aero:
Ich habe ein Arduino Mega ...


Die Reihenfolge scheint mir unglücklich gewählt:

Anzeige - Warten - Löschen - alle anderen Aktivitäten - Anzeige ...

Versuche stattdessen:

Löschen - Anzeige - Warten - alle anderen Aktivitäten - Löschen - Anzeige ...

agmue:
"Quote from: arduino_aero on Today at 07:22 am
❝Ich habe ein Arduino Mega ..."

Habe ich tatsächlich übersehen, aber geahnt...

Und der Sketch ist grässlich zu lesen... :wink:
Daher wollte ich nicht darauf eingehen.
Aber der TO scheint nicht interessiert zu sein, dass zu ändern.

Mein Tipp dazu, er sollte beide Farben überschreiben:

tft.setTextColor(ILI9341_GREEN, ILI9341_BLACK);

Hintergrund und Text.

Erstmal Danke für alle Tipps.

Ich bin wie gesagt neu in der programmier Welt und habe daher wenig Erfahrung.

Werde wenn ich Zuhause bin mein Sketch kommentieren und in Zukunft den Code formatiert einstellen.

@HotSystems Was meinst du mit TO?

LG

HotSystems:
Aber der TO scheint nicht interessiert zu sein, dass zu ändern.

International gilt: wait a day. Möglicherweise lebt er ja mit dem Kopf nach unten, also in Neuseeland. Ich muß mich auch immer daran erinnern, daß Sprache und Land nicht identisch sind. Und sei es nur, die Einkaufsbedingungen für D A CH sind unterschiedlich.

arduino_aero:
Werde wenn ich Zuhause bin mein Sketch kommentieren und in Zukunft den Code formatiert einstellen.

Du kannst Deine Beiträge auch nachträglich verändern. Code markieren und auf </> klicken.

arduino_aero:
@HotSystems Was meinst du mit TO?

TO = Thread Originator = Themensteller = in Diesem Thema Du :slight_smile:

OK, etwas schwierig zu lesen... was ich aber gesehen habe ist, dass du auch die Beschriftungen immer wieder neu schreibst (hab ich das richtig gesehen?)

Du kannst Text, der sich nie ändert einmal im Setup schrieben und dann unberührt lassen und immer nur die Sensorwerte aktualisieren...

MaHa76:
OK, etwas schwierig zu lesen... was ich aber gesehen habe ist, dass du auch die Beschriftungen immer wieder neu schreibst (hab ich das richtig gesehen?)

Du kannst Text, der sich nie ändert einmal im Setup schrieben und dann unberührt lassen und immer nur die Sensorwerte aktualisieren...

Zumindest wird immer die Hintergrundfarbe neu geschrieben.
Und das ist nicht nötig.

Jetzt ist der Sketch auch lesbarer. Danke

Generell muss man bei sowas seine Werte auf eine konstante Breite formatieren (z.B. mit führenden Leerzeichen) und dann einfach die alte Anzeige überschreiben

Serenifly:
… dann einfach die alte Anzeige überschreiben

Beim LCD ja, beim Grafikdisplay jain. Beim Grafikdisplay werden nur die zum Zeichen gehörenden Punkte gesetzt, wenn man nur die Vordergrundfarbe festlegt. Nutzt man den Standardfont und definiert auch die Hintergrundfarbe, dann ja:

tft.setTextColor(0xFFFF, 0x0000);

Nutzt man einen Font aus Adafruit_GFX\Fonts, verschiebt sich nicht nur der Ursprung des Font, sondern man muß erst Löschen durch Überschreiben mit dem alten Wert. Das Setzen der Hintergrundfarbe funktioniert grundsätzlich auch, allerdings bleiben einzelne Pixel ungelöscht.

Sketch zur Demonstration (bitte an das eigene Display anpassen!):

// Getestet mit Mega2560

#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_TFTLCD.h> // Hardware-specific library
#define FONT FreeMono18pt7b
#include "Fonts/FreeMono18pt7b.h"
#define LCD_CS 31 // Chip Select
#define LCD_CD A15 // Command/Data
#define LCD_WR A14 // LCD Write
#define LCD_RD 30 // LCD Read
#define LCD_RESET 0 // direkt mit Arduinos Resetpin verbunden

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

#include <SPI.h>

const uint8_t chipSelect = SS;      // SD chip select pin

void setup() {
  Serial.begin(9600);
  tft.reset();
  tft.begin(0x9341);
  tft.invert();  // funktioniert nur mit der Bibliotheksanpassung
  tft.setRotation(2);
  tft.fillScreen(0x0000);
  tft.setTextSize(2);
  tft.print(" ");
  tft.setTextSize(4);
  tft.println("Zaehler");
  tft.setTextColor(0xFFFF);         // es entsteht ein weißer Block
  for (byte z = 0; z < 20; z++) {
    tft.setCursor(50, 50);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(100);
  }
  tft.setTextColor(0xFFFF, 0x0000); // so funktioniert es ohne Blinken
  for (byte z = 0; z < 20; z++) {
    tft.setCursor(50, 100);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(100);
  }
  tft.setFont(&FONT);
  tft.setTextSize(3);
  tft.setTextColor(0xFFFF, 0x0000); // es bleiben Pixel ungelöscht
  for (byte z = 0; z < 20; z++) {
    tft.setCursor(50, 200);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(100);
  }
  byte z = 0;
  do {
    tft.setCursor(50, 300);
    tft.setTextColor(0x0000);       // so funktioniert es mit Blinken
    if (z < 10) tft.print(" ");
    tft.print(z);
    z++;
    tft.setCursor(50, 300);
    tft.setTextColor(0xFFFF);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(200);
  } while (z < 19);
}

void loop() {}

Anzeige:

Zähler.png
Ich habe das Bild so groß gemacht, damit die stehengebliebenen Pixel sichtbar werden.

Wenn Dir die Standardschrift genügt, ergänze einfach die Hintergrundfarbe bei setTextColor und es blinkt nicht mehr.

Serenifly:
Generell muss man bei sowas seine Werte auf eine konstante Breite formatieren (z.B. mit führenden Leerzeichen) und dann einfach die alte Anzeige überschreiben

Ich habe das mal fett gemacht. Wenn man eine Schrift mit fester Zeichenbreite verwendet, ist das ein Riesenvorteil für alle Arten der Darstellung nummerischer Werte.

Gruß

Gregor

agmue:

Die Reihenfolge scheint mir unglücklich gewählt:

Anzeige - Warten - Löschen - alle anderen Aktivitäten - Anzeige …

Versuche stattdessen:

Löschen - Anzeige - Warten - alle anderen Aktivitäten - Löschen - Anzeige …

leider auch ohne Erfolg da überschreibt er wieder die vorherigen Pixel.

Serenifly:
Generell muss man bei sowas seine Werte auf eine konstante Breite formatieren (z.B. mit führenden Leerzeichen) und dann einfach die alte Anzeige überschreiben

Wie gesagt bin blutiger Anfänger. Was kann ich mir unter konstante Breite formatieren vorstellen? Bzw wie wird so etwas in der Praxis realisiert?

@agmue

Die Variante, die Hintergrundfarbe hinzuzufügen, war ein voller Erfolg. Nun habe ich einen sauberen Übergang. Vielen Dank hierfür.

Mit den fonds habe ich auch so meine Probleme aber das gehört nicht in dieses Thema mit rein.

Vielen Dank euch allen. Bis demnächst.

arduino_aero:
... Was kann ich mir unter konstante Breite formatieren vorstellen? Bzw wie wird so etwas in der Praxis realisiert? ...

Einer meiner RPis (der zweite Pi, deshalb heißt der pipi) zeigt mir zum Beispiel so etwas ständig an:

Der „Font“ ist ein selbstgebasteltes „Minimal-Föntchen“, das aus einer simplen 7x14-Matrix (oder waren's 7x15? Öh ...) besteht. Die verschiedenen Schriftgrößen bekomme ich durch simples ganzzahliges Vervielfachen der Font-zu-Screen-Pixelmuster hin.

Gruß

Gregor

arduino_aero:
leider auch ohne Erfolg da überschreibt er wieder die vorherigen Pixel.

Stimmt leider, habe ich jetzt auch probiert.

arduino_aero:
Was kann ich mir unter konstante Breite formatieren vorstellen? Bzw wie wird so etwas in der Praxis realisiert?

Es gibt proportionale Fonts wie TimesNewRoman, wo die Buchstaben unterschiedliche Breiten haben. Also ein “i” ist schmaler als ein “m”. Bei anderen Fonts wie CourierNew haben alle Zeichen gleiche Breite, da ist ein “i” genauso breit wie ein “m”:

iiii
mmmm

arduino_aero:
Die Variante, die Hintergrundfarbe hinzuzufügen, war ein voller Erfolg. Nun habe ich einen sauberen Übergang. Vielen Dank hierfür.

Bitte gerne, die Idee habe ich mal hier aus dem Forum gelernt :slight_smile:

arduino_aero:
Mit den fonds habe ich auch so meine Probleme aber das gehört nicht in dieses Thema mit rein.

Darf ich bitte trotzdem? Inzwischen habe ich auch eine blinkfreie Lösung für die Zusatzfonts gefunden. Dazu folgende Überlegung: Es blinkt nur die Ziffer, die inhaltlich unverändert bleibt und daher überflüssigerweise gelöscht wird.

Die Idee: Die Zahl aufteilen in inhaltlich neue und unveränderte. Die unveränderten werden nicht gelöscht, sondern einfach überschrieben, was unsichtbar bleibt. Die neuen werden mit dem alten Wert in Hintergrundfarbe überschrieben, dann mit der Vordergrund der neue Wert.

Folgender Sketch soll meine Überlegungen testen:

// Getestet mit Mega2560

#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_TFTLCD.h> // Hardware-specific library
#define FONT FreeMono18pt7b
#include "Fonts/FreeMono18pt7b.h"
#define LCD_CS 31 // Chip Select
#define LCD_CD A15 // Command/Data
#define LCD_WR A14 // LCD Write
#define LCD_RD 30 // LCD Read
#define LCD_RESET 0 // direkt mit Arduinos Resetpin verbunden

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

#include <SPI.h>

const uint8_t chipSelect = SS;      // SD chip select pin

void setup() {
  tft.reset();
  tft.begin(0x9341);
  tft.invert();  // funktioniert nur mit der Bibliotheksanpassung
  tft.setRotation(2);
  tft.fillScreen(0x0000);
  tft.setTextSize(2);
  tft.print(" ");
  tft.setTextSize(4);
  tft.println("Zaehler");
  tft.setTextColor(0xFFFF);         // es entsteht ein weißer Block
  for (byte z = 0; z < 20; z++) {
    tft.setCursor(50, 50);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(100);
  }
  tft.setTextColor(0xFFFF, 0x0000); // so funktioniert es ohne Blinken
  for (byte z = 0; z < 20; z++) {
    tft.setCursor(50, 100);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(100);
  }
  tft.setFont(&FONT);
  tft.setTextSize(2);
  byte z = 0;
  byte a = z;
  do {
    tft.setCursor(0, 200);
    anzeige(a, z, 0xFFFF, 0x0000, 4);
    a = z;
    z += 1;
    delay(100);
  } while (z < 222);

  z = 0;
  do {
    tft.setCursor(50, 300);
    tft.setTextColor(0x0000);       // so funktioniert es mit Blinken
    if (z < 10) tft.print(" ");
    tft.print(z);
    z++;
    tft.setCursor(50, 300);
    tft.setTextColor(0xFFFF);
    if (z < 10) tft.print(" ");
    tft.print(z);
    delay(100);
  } while (z < 19);
}

void anzeige(uint16_t alt, uint16_t neu, const uint16_t vor, uint16_t hint, byte stellen) {
  uint16_t di = pow(float(10), float(stellen)) + 0.5;  // die 0.5 zum Aufrunden
  while (di > 1) {
    byte ta = alt % di * 10 / di;
    byte tn = neu % di * 10 / di;
    di /= 10;
    if (neu < di) {
      tft.setTextColor(hint, hint);
      tft.print(" ");
    } else {
      if (ta == tn) {
        tft.setTextColor(vor);
        tft.print(tn);
      } else {
        int16_t cx = tft.getCursorX();
        int16_t cy = tft.getCursorY();
        tft.setTextColor(hint);
        tft.print(ta);
        tft.setCursor(cx, cy);
        tft.setTextColor(vor);
        tft.print(tn);
      }
    }
  }
}
void loop() {}

Anmerkungen zu den Zusatzfonts:

  • Der Ursprung ist links unten, bei Standardfont links oben.
  • Zusatsfonts brauchen viel Speicher. Sollen nur Ziffern angezeigt werden, kann man die von der Bibliothek mitgelieferten Dateien kürzen.