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

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

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
RGB-OLED 96x64 0,95" und Laufschrift
11.10.2017, 15:09
Beitrag #17
RE: RGB-OLED 96x64 0,95" und Laufschrift
Hallo Tommy

Danke für den Hinweis.
Dann werde ich darauf wohl verzichten müssen.

Gruß Bernd
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.10.2017, 15:30
Beitrag #18
RE: RGB-OLED 96x64 0,95" und Laufschrift
(11.10.2017 15:09)Behagen schrieb:  Hallo Tommy

Danke für den Hinweis.
Dann werde ich darauf wohl verzichten müssen.

Gruß Bernd
Ich schreibe gerade an einer gekapselten Version.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.10.2017, 16:35
Beitrag #19
RE: RGB-OLED 96x64 0,95" und Laufschrift
Hallo Tommy

Vielen Dank für Deinen Einsatz.

Allerdings --- im Moment verstehe ich die Welt nicht mehr.
Ich habe nun noch etwas rumprobiert und bin auf folgendes Phänomen gestoßen.
Seit ich die neue Variante für die Kommunikation nutze, ist es nicht mehr nötig die
Einträge
display.setTextColor(BLACK, BLACK);
display.setTextSize(2);
display.setCursor(0, 20);
im Bereich Bildschirm löschen, nach der Anweisung: display.print(scroll()); zu benutzen.
Das Ergebnis ist das selbe, mit oder ohne diese Einträge.
Übrigens habe ich es nun auch geschafft das ganze mit der 13XX.h von sumotoy zum laufen zu bringen.
Bringt aber so keinen Vorteil, im Gegenteil am rechten Bildschirmrand bleiben "Pixelreste" stehen.
Aber sicher wird es durch Anpassungen ein besseres Ergebnis geben können.
Da muss ich aber noch etwas forschen.

Gruß Bernd
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.10.2017, 18:47 (Dieser Beitrag wurde zuletzt bearbeitet: 11.10.2017 18:47 von Tommy56.)
Beitrag #20
RE: RGB-OLED 96x64 0,95" und Laufschrift
Da ich kein OLED habe, muss ich Dir die Forschung überlassen.
Hier mal eine in einer Klasse gekapselte Version eines Scrolltextes, so dass man mehrere davon haben kann.
Da der Speicher in der Klasse dynamisch zur Laufzeit angelegt wird, kann der Compiler diesen nicht mit in den RAM-Verbrauch einrechnen.
Das Headerfile Ltext.h
Code:
#ifndef _LTEXT_H_
#define _LTEXT_H_

#include <Arduino.h>
/********************************************************************************​********
Copyright by Thomas Kühnert. All rights reserved.

This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details. https://www.gnu.org/licenses/lgpl-3.0.en.html
********************************************************************************​*********/

class Ltext {
  public:
    // leerer Konstruktor
    Ltext();
    // Destruktor
    ~Ltext();
    // Setzt die Parameter für den Scrolltext. text = Kompletter Text, len = Laenge des Scrollausschnittes (Scrolltext),
    // intervall = Scrollintervall in Millisekunden
    // Text als Konstante im RAM
    void begin(const char *text, const uint8_t len, const uint32_t intervall);
    // Text als Konstante im PROGMEM
    void begin_P(const char *text, const uint8_t len, const uint32_t intervall);
    // Text mit dem F-Macro
    void begin_F(const __FlashStringHelper *text, const uint8_t len, const uint32_t intervall);
    // aktueller Scrolltext ohne Verschiebung
    char *getAlt();  
    // Schiebt um 1 Zeichen und gibt den Scrolltext zurueck
    char *scroll();
    // setzt ein anderes Scrollintervall (Millisekunden)
    void setIntervall(const uint32_t intervall);
    // gibt das Scrollintervall zurueck (Millisekunden)
    uint32_t getIntervall();    
    // setzt Zeitpunkt der letzten Verschiebung (Millisekunden)
    void setLastMillis(const uint32_t last);
    // gibt Zeitpunkt der letzten Verschiebung zurueck(Millisekunden)
    uint32_t getLastMillis();    
  private:
    // gemeinsame Bestandteile von begin...
    void cpInt(const uint8_t len, const uint32_t intervall);
    // der komplette Text
    char *_text;
    // der Scrolltext
    char *_stueck;
    // Laenge des Scrolltextes
    uint8_t _len;
    // Laenge des Textes
    uint8_t _tlen;
    // Scrollintervall
    uint32_t _intervall;
    // Zeitpunkt der letzten Verschiebung
    uint32_t _last;
};
#endif
Die Methoden Ltext.cpp:
Code:
#include "Ltext.h"
/********************************************************************************​********
Copyright by Thomas Kühnert. All rights reserved.

This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details. https://www.gnu.org/licenses/lgpl-3.0.en.html
********************************************************************************​*********/

    Ltext::Ltext(){
      _text = NULL;
      _stueck = NULL;
      _len = 0;
    };

    Ltext::~Ltext() {
      if (_text != NULL) free(_text);
      if (_stueck != NULL) free(_stueck);
    };

    char *Ltext::getAlt() {
      return _stueck;
    }    
    
    char *Ltext::scroll() {
      char first = _text[0];
      uint8_t idx = 0;
      while (_text[idx++] = _text[idx]);
      _text[_tlen-1]=first;
      // Serial.print(">");Serial.print(_text);Serial.println("<");
      strlcpy(_stueck,_text,_len+1);
      return _stueck;
    }
    
    void Ltext::begin(const char *text, const uint8_t len, const uint32_t intervall) {
      // Wenn Pointer belegt, Speicher frei geben
      if (_text != NULL) free(_text);
      if (_stueck != NULL) free(_stueck);
      _tlen = strlen(text);
      // Speicher für kompletten Text reservieren
      _text = (char *) malloc(_tlen+1);
      // kompletten Text kopieren
      strcpy(_text,text);
      cpInt(len,intervall);
    }

    void Ltext::begin_P(const char *text, const uint8_t len, const uint32_t intervall) {
      if (_text != NULL) free(_text);
      if (_stueck != NULL) free(_stueck);
      _tlen = strlen_P(text);
      _text = (char *) malloc(_tlen+1);
      strcpy_P(_text,text);
      cpInt(len,intervall);
    }

    void Ltext::begin_F(const __FlashStringHelper *text, const uint8_t len, const uint32_t intervall) {
      if (_text != NULL) free(_text);
      if (_stueck != NULL) free(_stueck);
      _tlen = strlen_P((PGM_P)text);
      _text = (char *) malloc(_tlen+1);
      strcpy_P(_text,(PGM_P)text);
      cpInt(len,intervall);
    }

    void Ltext::cpInt(const uint8_t len, const uint32_t intervall) {
      _len = len;
      // Serial.print("SetText: ");Serial.println(_text);      
      _stueck = (char *) malloc(len+2);
      strlcpy(_stueck,_text,_len+1);
      _last = millis();
      _intervall = intervall;      
    }
    
    void Ltext::setIntervall(const uint32_t intervall) {
      _last = millis();
      _intervall = intervall;            
    }
    
    uint32_t Ltext::getIntervall() {
      return _intervall;
    }
    
    void Ltext::setLastMillis(const uint32_t last) {
      _last = last;
    }
    uint32_t Ltext::getLastMillis() {
      return _last;
    }

So kann man das Ganze anwenden:
Code:
/********************************************************************************​********
Copyright by Thomas Kühnert. All rights reserved.

This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details. https://www.gnu.org/licenses/lgpl-3.0.en.html
********************************************************************************​*********/
#include "Ltext.h"

// Text im PROGMEM
const char text2[] PROGMEM = "0123456789abcdefg";

// 3 Lauftexte
Ltext lt1, lt2, lt3;

// Counter
uint8_t counter = 0;

void setup() {
  Serial.begin(115200);
  Serial.println("Start");
  // Direkte Textangabe - der Text steht im RAM
  lt1.begin("Das ist der erste Text",10,1000);
  // Text in einer Variablen im PROGMEM
  lt2.begin_P(text2,5,500);
  // Text im PROGMEM mit dem F-Makro
  lt3.begin_F(F("Mit dem F-Macro"),4,5000);
}

void loop() {
uint32_t aktMillis = millis();
  if (aktMillis - lt1.getLastMillis() >= lt1.getIntervall()) {
    Serial.print(F("Alt 1: ")); Serial.println(lt1.getAlt());
    lt1.setLastMillis(aktMillis);
    Serial.print(F("Neu 1: ")); Serial.println(lt1.scroll());
  }  
  if (aktMillis - lt2.getLastMillis() >= lt2.getIntervall()) {
    Serial.print(F("Alt 2: ")); Serial.println(lt2.getAlt());
    lt2.setLastMillis(aktMillis);
    Serial.print(F("Neu 2: ")); Serial.println(lt2.scroll());
  }  
  if (aktMillis - lt3.getLastMillis() >= lt3.getIntervall()) {
    Serial.print(F("Alt 3: ")); Serial.println(lt3.getAlt());
    lt3.setLastMillis(aktMillis);
    Serial.print(F("Neu 3: ")); Serial.println(lt3.scroll());
  // wir können auch das Intervall ändern
  if (counter <10) counter++;
  else if (counter == 10) lt3.setIntervall(1000);
  }  
}

Viel Spaß beim ausprobieren.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.10.2017, 20:23
Beitrag #21
RE: RGB-OLED 96x64 0,95" und Laufschrift
Hallo Tommy

Da hast Du aber ordentlich in die Tasten gehauen. Cool
Vielen Dank !
Ich werde mich dann mal daranmachen das ganze zu testen.
Sobald ich ein Ergebnis habe melde ich mich.

Gruß Bernd
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
11.10.2017, 20:33
Beitrag #22
RE: RGB-OLED 96x64 0,95" und Laufschrift
(11.10.2017 20:23)Behagen schrieb:  Hallo Tommy

Da hast Du aber ordentlich in die Tasten gehauen. Cool
Vielen Dank !
Ich werde mich dann mal daranmachen das ganze zu testen.
Sobald ich ein Ergebnis habe melde ich mich.

Gruß Bernd
Es hat einfach Spaß gemacht. Besonders die Verarbeitung der 3 Quellen für Texte hat mich interessiert. Der Teil mit dem F-Macro war nicht so einfach zu finden.
Sowas macht aber halt den Spaß beim Programmieren aus.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.10.2017, 13:59 (Dieser Beitrag wurde zuletzt bearbeitet: 12.10.2017 14:12 von Behagen.)
Beitrag #23
RE: RGB-OLED 96x64 0,95" und Laufschrift
Hallo Tommy

Ich habe es nun hinbekommen das eine Ausgabe auf dem Bildschirm erfolgt.
Zuerst hatte ich Schwierigkeiten unter Win10 eine funktionierende Ltext.cpp zu erstellen.
Aber dank Win7 ging es dann.
Das Programm läuft also, nur die Scroll-Geschwindigkeit bereitet mir Kopfzerbrechen.
Zu erst aber mal das Sketch:
Code:
/********************************************************************************​​********
Copyright by Thomas Kühnert. All rights reserved.

This file is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details. https://www.gnu.org/licenses/lgpl-3.0.en.html
********************************************************************************​​*********/
// definieren der Anschlüsse am Arduino
#define sclk 13
#define mosi 11
#define cs   10
#define rst  9
#define dc   8


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

// Bibliotheken festlegen
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1331.h>
#include <SPI.h>
#include "Ltext.h"

Adafruit_SSD1331 display = Adafruit_SSD1331(cs, dc, rst);

// Text im PROGMEM
const char text2[] PROGMEM = "0123456789abcdefg";
// 3 Lauftexte
Ltext lt1, lt2, lt3;

// Counter
uint8_t counter = 0;

void setup() {
   Serial.begin(115200);
   Serial.println("Start");
   display.begin();
    //Display um 180° gedreht
   display.setRotation(2);
    //Hintergrund schwarz füllen
   display.fillScreen(BLACK);
   // Direkte Textangabe - der Text steht im RAM
   lt1.begin("Das ist der erste Text",8,1000);
   // Text in einer Variablen im PROGMEM
   lt2.begin_P(text2,16,500);
   // Text im PROGMEM mit dem F-Makro
   lt3.begin_F(F("Mit dem F-Macro"),16,5000);
  
}

void loop() {
uint32_t aktMillis = millis();

   if (aktMillis - lt1.getLastMillis() >= lt1.getIntervall()) {
     Serial.print(F("Alt 1: ")); Serial.println(lt1.getAlt());
     lt1.setLastMillis(aktMillis);
     Serial.print(F("Neu 1: ")); Serial.println(lt1.scroll());
    
   }  
   if (aktMillis - lt2.getLastMillis() >= lt2.getIntervall()) {
     Serial.print(F("Alt 2: ")); Serial.println(lt2.getAlt());
     lt2.setLastMillis(aktMillis);
     Serial.print(F("Neu 2: ")); Serial.println(lt2.scroll());
    
   }  
   if (aktMillis - lt3.getLastMillis() >= lt3.getIntervall()) {
     Serial.print(F("Alt 3: ")); Serial.println(lt3.getAlt());
     lt3.setLastMillis(aktMillis);
     Serial.print(F("Neu 3: ")); Serial.println(lt3.scroll());
    
   // wir können auch das Intervall ändern
   if (counter <10) counter++;
   else if (counter == 10) lt3.setIntervall(1000);

   // Bildschirm löschen und neue Ausgabe
   //Text 1 ausgeben
    display.setTextColor(YELLOW, BLACK); //Gelber Text und Schwarzer Hintergrundstreifen in Texthöhe
    display.setTextSize(2);
    display.setCursor(0, 0);
    display.print(lt1.scroll());
   //Text 2 ausgeben
    display.setTextColor(GREEN, BLACK); //Grüner Text und Schwarzer Hintergrundstreifen in Texthöhe
    display.setTextSize(1);
    display.setCursor(0, 20);
    display.print(lt2.scroll());
   //Text 3 ausgeben
    display.setTextColor(YELLOW, BLUE); //Gelber Text und Blauer Hintergrundstreifen in Texthöhe
    display.setTextSize(1);
    display.setCursor(0, 40);
    display.print(lt3.scroll());
    
  
   }  
}
Wie man die Länge des ausgegeben Textes beeinflusst habe ich herausbekommen.
Der Wert der dahinter steht soll doch sicher die Scroll-Geschwindigkeit für jeden Text einzeln regeln?
Das funktioniert aber nur für einen Durchlauf, dann werden alle drei Texte mit der gleichen Geschwindigkeit ausgegeben.
Gruß Bernd
Ergänzung:
Die Schrittweite ist auch ein Problem.
Der erste Text macht drei Zeichen Schrittweite.
Der zweite Text macht fünf(wenn ich mich nicht verzählt habe) und der dritte macht
zwei Zeichen Schrittweite.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
12.10.2017, 14:59
Beitrag #24
RE: RGB-OLED 96x64 0,95" und Laufschrift
Du hast es immer noch nicht begriffen. Du darfst die scroll nur ein mal aufrufen, nicht mehrfach. Deine OLED-Ausgaben müssen anstelle der Serial.print eingebaut werden. Langsam könntest Du mal einige Grundlagen lernen, um wenigstens ansatzweise zu verstehen, was Du tust.
Einfach meinen Sketch kopieren ohne etwas zu verstehen macht keinen Sinn. Der zeigt lediglich Aufrufmöglichkeiten. Den Teil mit dem Counter und setIntervall brauchst Du bei Dir überhaupt nicht.
Die Probleme liegen bei Dir, nicht in der Lib.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Grafiken auf OLED-Display darstellen scritch 8 4.292 17.11.2016 13:33
Letzter Beitrag: scritch
  1.8" Serial: UART/I2C/SPI True Color OLED160x128 OLED Module Georg 4 3.282 31.08.2014 19:03
Letzter Beitrag: Georg

Gehe zu:


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