Werte als Statusbar und Linien Grafik auf dem Display anzeigen lassen

fony · January 14, 2024, 9:37am

Deshalb habe den Tipp mit STRG+ T gegeben

 u8g2.clearBuffer();

Löscht den LCD

u8g2.sendBuffer();

nur am ende vom schreiben auf den LCD .
Jedoch könne das verhalten bei geänderten werten nicht

power-dodge · January 14, 2024, 9:41am

Ja ist mit bekannt, zu viele kann eigentlich nicht sein. Ist nur einer im Loop am Anfang.
Und schreiben am Ende auch einer.
Mit einem Graphen funktionierte es damit eigentlich flott.

2 Graphen seeeeehr langsam, oder habe ich damit die CPU und oder den RAM zur seinen Grenzen gebracht? Ist eigentlich doch nicht wildes...

Paar Werte abspeichern, auslesen und darstellen, der Analyzer lief echt flott, daher vermute den Display da jetzt nicht.

Danke euch sehr für die Tipps

fony · January 14, 2024, 9:42am

Wie ist die Auslastung vom RAM nach kompilieren?

power-dodge · January 14, 2024, 9:53am

Der Sketch verwendet 282477 Bytes (21%) des Programmspeicherplatzes. Das Maximum sind 1310720 Bytes.
Globale Variablen verwenden 24664 Bytes (7%) des dynamischen Speichers, 303016 Bytes für lokale Variablen verbleiben. Das Maximum sind 327680 Bytes.

fony · January 14, 2024, 9:58am

Das ist fast nichts

power-dodge · January 14, 2024, 10:02am

Dann schafft er nicht das alles zu berechnen?
Oder ich vermute das es einfach zu blöde zusammen kopiert ist, das erst bei 2 Graphen, sollen eigentlich 6 sein

Übrigens auch mal mit einem Graphen bleibt das ding mal hängen...

fony · January 14, 2024, 10:05am

Wie schon oben geschrieben kann nicht testen.
Wen es langsam geworden ist, ist was Faul im Sketch.
Allgemein verstehe nicht was du vorhast, nur das man will was Anzeigen.

power-dodge · January 14, 2024, 10:39am

Was ich will, mehrere Displays ins Auto einbauen.
Habe schon mehrere Themen dazu erstellt gehabt, Ihr klopft sonst auf die Finger wenn es nicht zum Thema passt.
Da habe ich ein Menü, mit dem unter anderen hatte ich vor 6 Graphen insgesamt auf 3 Displays darstellen zu lassen. Die Daten kommen dann von dem Motorsteuergerät.

Die Daten mit anderen Sketch kann ich schon abrufen, testweise habe ich es erst getrennt versucht auf zu bauen. Damit ich im Menü nicht fummeln muss und mehr kaputt mache wie sonst was, habe immer so verfahren, wenn ein Sketch fertig war, danach diesen in das Menü eingepflegt.

Glaube hatte schon mal was gezeigt gehabt, jetzt zum Thema ist das jetzt auch nicht soooo wichtig. Falls ich Links zum TikTok hier einstellen dürfte, bei Interesse könnte ich auch Video zeigen.

Grüße

power-dodge · January 14, 2024, 6:00pm

Niemand ne Idee, warum es so langsam geworden ist?

Vielleicht weil dieses Arbeitsspeicher im Kreis abgerufen wird und er das gleichzeitig für 2 Werte nicht kann?

fony · January 14, 2024, 6:19pm

Zeige mall letzten Stand.

power-dodge · January 14, 2024, 7:06pm

Daß ist er wie im Post #38

Da ist nur das Loop Problem noch nicht gelöst.
Nach der Lösung hat er ja beide angezeigt nur eben wirklich in Zeitlupe auf einmal.

Seit dem bin ich nicht weiter gekommen

fony · January 14, 2024, 8:05pm

Versucht mall damit, und gebe mall die Werte was im SerMon werden angezeigt

/**
    Draws a scrolling graph of a single analog input (set to A0) on the OLED display

    By Jon E. Froehlich
    @jonfroehlich
    http://makeabilitylab.io

*/

#include <SPI.h>
#include <U8g2lib.h>
//#include <Wire.h>


#define SCREEN_WIDTH 124 // Breite der Grafik und Speicherung im RAM
#define SCREEN_HEIGHT 47 // Y Achse unten der Grafik

//U8G2_GP1294AI_256X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/2, /* dc=*/U8X8_PIN_NONE, /* reset=*/15);
U8G2_GP1294AI_256X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/2, /* dc=*/U8X8_PIN_NONE, /* reset=*/15);

const int ANALOG_INPUT_PIN_L = 35;
const int MIN_VALL_L = 0;
const int MAX_VALL_L = 4095;

const int ANALOG_INPUT_PIN_R = 12;
const int MIN_VALL_R = 0;
const int MAX_VALL_R = 4095;


const int DELAY_LOOP_MS = 10; // change to slow down how often to read and graph value

int _circularBuffer_L[SCREEN_WIDTH]; //fast way to store values
int _curWriteIndex_L = 0; // tracks where we are in the circular buffer

int _circularBuffer_R[SCREEN_WIDTH]; //fast way to store values
int _curWriteIndex_R = 0; // tracks where we are in the circular buffer

int _graphHeight = 32;


void setup() {
  Serial.begin(9600);
  u8g2.begin();

  // Clear the buffer
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setCursor(20, 20);
  u8g2.println("Graph Line Test");
  u8g2.sendBuffer();
  delay(2000);

  u8g2.clearBuffer();

}

void loop() {
  unsigned long start = millis();
  // Clear the display on each frame. We draw from the _circularBuffer
  u8g2.clearBuffer();

  // Read and store the analog data into a circular buffer
  int Val_L = analogRead(ANALOG_INPUT_PIN_L);
  int Val_R = analogRead(ANALOG_INPUT_PIN_R);

  _circularBuffer_L[_curWriteIndex_L++] = Val_L;
  _circularBuffer_R[_curWriteIndex_R++] = Val_R;


  Serial.println(Val_L);
  Serial.println(Val_R);
  // Set the circular buffer index back to zero when it reaches the
  // right of the screen
  if (_curWriteIndex_L >= SCREEN_WIDTH) {
    _curWriteIndex_L = 0;
  }

  if (_curWriteIndex_R >= SCREEN_WIDTH) {
    _curWriteIndex_R = 0;
  }



  // Draw the line graph based on data in _circularBuffer
  int xPos_L = 1;
  for (int i = _curWriteIndex_L; i < SCREEN_WIDTH; i++) {
    int Val_L = _circularBuffer_L[i];
    drawLine_1(xPos_L, Val_L);
    xPos_L++;
  }

  // Draw the line graph based on data in _circularBuffer
  int xPos_R = 130;
  for (int i = _curWriteIndex_R; i < SCREEN_WIDTH; i++) {
    int Val_R = _circularBuffer_R[i];
    drawLine_2(xPos_R, Val_R);
    xPos_R++;
  }

  for (int i = 0; i < _curWriteIndex_L; i++) {
    int Val_L = _circularBuffer_L[i];
    drawLine_1(xPos_L, Val_L);
    xPos_L++;;

    for (int i = 0; i < _curWriteIndex_R; i++) {
      int Val_R = _circularBuffer_R[i];
      drawLine_2(xPos_R, Val_R);
      xPos_R++;;
    }
    u8g2.drawLine(0, 47, 125, 47);
    u8g2.drawLine(130, 47, 255, 47);
    u8g2.drawLine(0, 14, 0, 46);
    u8g2.drawLine(125, 14, 125, 46);
    u8g2.drawLine(130, 14, 130, 46);
    u8g2.drawLine(255, 14, 255, 46);
    u8g2.drawLine(1, 14, 3, 14);
    u8g2.drawLine(124, 14, 122, 14);
    u8g2.drawLine(131, 14, 133, 14);
    u8g2.drawLine(254, 14, 252, 14);
    u8g2.sendBuffer();

    //delay(DELAY_LOOP_MS);
  }
  unsigned long ende = millis();
  ende = ende - start;
  Serial.println (ende);
}
/**
   Draw the line at the given x position and analog value
*/
void drawLine_1(int xPos_L, int Val_L) {
  int lineHeight_L = map(Val_L, MIN_VALL_L, MAX_VALL_L, 0, _graphHeight);
  int yPos_L = SCREEN_HEIGHT - lineHeight_L;
  u8g2.drawVLine(xPos_L, yPos_L, lineHeight_L);
}

void drawLine_2(int xPos_R, int Val_R) {
  int lineHeight_R = map(Val_R, MIN_VALL_R, MAX_VALL_R, 0, _graphHeight);
  int yPos_R = SCREEN_HEIGHT - lineHeight_R;
  u8g2.drawVLine(xPos_R, yPos_R, lineHeight_R);
}

fony · January 14, 2024, 8:07pm

Meine Vermutung die for Schleifen bremsen den aus,

power-dodge · January 14, 2024, 9:23pm

Dankeschön für den Versuch: Serielle Ausgabe:

Aber keine Anzeige auf dem Display, dafür laufen die Zahlen recht schnell in dem Seriellen Monitor durch.

Wie ich gesehen hast Du die Display Anzeigen geändert, mit meiner Einstellung kommt auch was auf dem Display, aber verlangsamt:

Hmmmm

wno158 · January 14, 2024, 9:35pm

power-dodge:

  for(int i = 0; i < _curWriteIndex_L; i++){
    int Val_L = _circularBuffer_L[i];
    drawLine_1(xPos_L, Val_L);
    xPos_L++;;

  for(int i = 0; i < _curWriteIndex_R; i++){
    int Val_R = _circularBuffer_R[i];
    drawLine_2(xPos_R, Val_R);
    xPos_R++;;
  }

Ist es wirklich nötig, für jede Linie, die in der äußeren Schleife (Val_L) gezeichnet wird, jeweils alle der inneren (Val_R) nochmal zu zeichnen?

Einmal STRG-T in der IDE drücken könnte das Problem offensichtlich machen.

EDIT:
Dann sieht man auch, dass der DELAY jedesmal ausgeführt wird:

    for (int i = 0; i < _curWriteIndex_L; i++)
    {
        int Val_L = _circularBuffer_L[i];
...
        delay(DELAY_LOOP_MS);
    }

power-dodge · January 14, 2024, 9:38pm

Im ersten Beispiel kommen die werten schon schneller rein ja, glaube mit einem Graphen war es schon deutlich auch da schneller.
Entweder zieht ihn die Berechnung herunter oder Deine Auswertung, da bin ich überfragt. Da keine Erfahrungen mit.

Und irgendwas zum auswerten hast gebastelt für die Sr ausgabe.
Im ersten Beispiel sind es die Zahlen mit 80 im zweiten mit 360.

Du hast den Modus der Anzeige geändert, soweit ich mich erinnern kann. Dann müsste man mit firstpage und nextpage arbeiten, null bei vollen Buffer verwendet man sendbuffer.
Aber ohne Gewähr...

Aber echt, herzlichen Dank Dir, das Du unter die Arme greifst. Ich fülle mich manchmal wie ein kleines Baby, was noch nicht sicher laufen kann...

power-dodge · January 14, 2024, 9:42pm

Vielen Dank für die Antwort,

mit delay 0 auch probiert, ist das selbe.
Aber stimmt da ist ja auch Delay eingebunden, versuche mal morgen diese komplett heraus zu operieren, zumindest testweise.

Ich denke schon das es notwendig sei die 2 Linien auszuwerten.
Val_L ist ein linkes Graphen
Val_R ist ein rechtes Graphen

Also 2 verschiedene mit 2 verschiedenen werten.
Und 6 sollen es werden

wno158 · January 14, 2024, 9:45pm

Das ja.
Aber du malst für jede einzelne Linie des linken Graphen den rechten einmal komplett neu. Das kann eigentlich nicht gewollt sein.

power-dodge · January 14, 2024, 9:48pm

Ich muss ehrlich sagen, ich komme nicht ganz mit...

Dachte es sind dann quasi einzelne Funktionen je Graphen. Einfach ausgedruckt

Oder ist da fehler bei

int = 0 ist bei beiden gleich

wno158 · January 14, 2024, 9:51pm

Bei mir sähe dann die loop()-Funktion so aus (nicht kompiliert oder getestet).
Änderungen:

Die doppelten ;; durch einzelne ; ersetzen
Hinter dem linken Graphen die for-Schleife mit einer Klammer } schließen
Die dann doppelte } am Ende des Sketches entfernen

code hier

void loop()
{
    // Clear the display on each frame. We draw from the _circularBuffer
    u8g2.clearBuffer();

    // Read and store the analog data into a circular buffer
    int Val_L = analogRead(ANALOG_INPUT_PIN_L);
    int Val_R = analogRead(ANALOG_INPUT_PIN_R);

    _circularBuffer_L[_curWriteIndex_L++] = Val_L;
    _circularBuffer_R[_curWriteIndex_R++] = Val_R;

    Serial.println(Val_L);
    Serial.println(Val_R);
    // Set the circular buffer index back to zero when it reaches the
    // right of the screen
    if (_curWriteIndex_L >= SCREEN_WIDTH)
    {
        _curWriteIndex_L = 0;
    }

    if (_curWriteIndex_R >= SCREEN_WIDTH)
    {
        _curWriteIndex_R = 0;
    }

    // Draw the line graph based on data in _circularBuffer
    int xPos_L = 1;
    for (int i = _curWriteIndex_L; i < SCREEN_WIDTH; i++)
    {
        int Val_L = _circularBuffer_L[i];
        drawLine_1(xPos_L, Val_L);
        xPos_L++;
    }

    // Draw the line graph based on data in _circularBuffer
    int xPos_R = 130;
    for (int i = _curWriteIndex_R; i < SCREEN_WIDTH; i++)
    {
        int Val_R = _circularBuffer_R[i];
        drawLine_2(xPos_R, Val_R);
        xPos_R++;
    }

    for (int i = 0; i < _curWriteIndex_L; i++)
    {
        int Val_L = _circularBuffer_L[i];
        drawLine_1(xPos_L, Val_L);
        xPos_L++;
    }

    for (int i = 0; i < _curWriteIndex_R; i++)
    {
        int Val_R = _circularBuffer_R[i];
        drawLine_2(xPos_R, Val_R);
        xPos_R++;
    }

    u8g2.drawLine(0, 47, 125, 47);
    u8g2.drawLine(130, 47, 255, 47);
    u8g2.drawLine(0, 14, 0, 46);
    u8g2.drawLine(125, 14, 125, 46);
    u8g2.drawLine(130, 14, 130, 46);
    u8g2.drawLine(255, 14, 255, 46);
    u8g2.drawLine(1, 14, 3, 14);
    u8g2.drawLine(124, 14, 122, 14);
    u8g2.drawLine(131, 14, 133, 14);
    u8g2.drawLine(254, 14, 252, 14);
    u8g2.sendBuffer();

    delay(DELAY_LOOP_MS);
}

Topic		Replies	Views
Grafik auf Oled Deutsch	3	544	May 6, 2021
Anfänger braucht Hilfe - OLED Display SH1106 128x64 I2C weiss Deutsch	8	7169	May 6, 2021
Suche einfaches Beispiel sketch Deutsch	20	555	November 6, 2023
Mini-Projekt: Pong auf einem 128x32-OLED-I2C-Display Deutsch	6	3287	May 6, 2021
Fehler um Grafik zu zeichnen Deutsch	6	453	May 28, 2021

Werte als Statusbar und Linien Grafik auf dem Display anzeigen lassen

Related topics