Esp8266 RGB Wert aus Spiffs

International Deutsch
1

Hallo liebe Community,

ich versuche im Moment aus einer "bitmap.txt" die im Spiffs auf meinem Nodemcu Esp8266 liegt RGB Farbwerte auszulesen.

Pro Bitmap benötige ich 110 RGB Werte die ich gerne als HEX Wert in der Datei haben möchte.

Einzelne Bytes kann ich auslesen. Wenn ich zB nur 0 und 1 pro LED Zustand in der Datei habe kann ich diese problemlos auslesen und in ein Char speichern.

Wie bekomme ich es jetzt aber hin daß ich einen RGB HEX Wert auslesen kann? Dafür muss ich ja 3Byte auslesen und zusammen fassen. Und genau hier hänge ich im Moment.

Ich würde die 110 Werte in der .txt gerne so schreiben: FFFFFF, FFFFFF,...

Kann mir jemand ein paar Tipps geben wie ich das auslesen machen kann?

Vielen Dank für Eure Hilfe :-)!

Liebe Grüße,
Björn

2

habs noch nicht verstanden.

Stell deine bitmap.txt hier ein,

und mach ein Beispiel in welcher Variable du welchen Wert haben möchtest konkret bezogen auf einen Wert in deiner bitmap.txt

FFFFFF, FFFFFF

klingt nicht gerade nach dem, was ich unter bitmap verstehe...

3

Wenn esw immer 110 werte sind, kannst Du die , weglassen. Also FF00FF sind 3 Werte oder ist das 1 Wert?.
Da 110 nicht ohne Rest durch 3 teilbar ist, vermute ich 1 Wert besteht aus 3 Byte.

Code ohne ,

File f = SPIFFS.open("bitmap.txt");
if (f) {
  for(int i=0; i<110;i++) {
    byte rot = f.read();
    byte gruen = f.read();
    byte blau ) f.read();
  }
   f.close();
}

So könnte man es tun, ich weiß ja nicht, wie Du es weiter verarbeiten willst.

Gruß Tommy

4

Hey,

danke für Eure Antworten.

Die bitmap.txt soll so aussehen:

*Heart
#000000,#000000,#FF0000,#FF0000,#FF0000,#000000,#000000,#FF0000,#FF0000,#FF0000,#000000,#000000,
#000000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#000000,
#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,
#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,
#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,
#000000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#000000,
#000000,#000000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#000000,#000000,
#000000,#000000,#000000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#FF0000,#000000,#000000,#000000,
#000000,#000000,#000000,#000000,#FF0000,#FF0000,#FF0000,#FF0000,#000000,#000000,#000000,#000000,
#000000,#000000,#000000,#000000,#000000,#FF0000,#FF0000,#000000,#000000,#000000,#000000,#000000
*Hier kommt das nächste Bitmap...

Als erstes kommt der Icon Name und in den nächsten 10 Zeilen kommen kommen jeweils 11 Werte = 110 RGB HEX Werte. Wobei die Werte auch alle in einer Reihe stehen können.. Danach kommt wieder der Icon Name und die nächsten Hex Werte.

Das # Symbol habe ich jetzt nur zur Verdeutlichung der Hexwerte geschrieben. Das muss später nicht in der Datei stehen.

Diese würde ich gerne in ein Array einlesen um es später weiter zu. D.h. ich möchte zB in led_color[0] 0x000000 stehen haben.

@Tommy
Ja genau es sind immer 110 Werte nie mehr und nie weniger. Du liegst mit deiner Vermutung absolut richtig. Ein Wert besteht aus 3 Byte. Kann ich mit deiner Variante die drei ausgelesenen Werte zusammen führen und dann in ein Array schreiben?

Vielen Dank für Eure Hilfe :-)!
Liebe Grüße,
Björn

5

google

atoi hex

hat mich auf strtoul gebracht.

http://www.cplusplus.com/reference/cstdlib/strtoul/

void setup() {
  Serial.begin(115200);
  Serial.println(F("\nStart"));
  char buffer[255];

  strcpy(buffer, "0xFF00FF");  // einlesen simu

  uint32_t i= strtoul(buffer, NULL, 16);
  Serial.println(i, HEX);
}

void loop() {

}

davor halt Zeilenweise einlesen, mit strtok teilen, durchiterieren...

das # würde ich weglassen.

6

Dann etwas anders:

File f = SPIFFS.open("bitmap.txt");
if (f) {
char puffer[4];
unsigned long ul;
  for(int i=0; i<110;i++) {
    puffer[0] = f.read();
    puffer[1] = f.read();
    puffer[2] = f.read();
    puffer[3] = '\0';
    ul = strtoul(puffer, NULL, 16);
    // mache was mit ul
  }
   f.close();
}

Oder so:

File f = SPIFFS.open("bitmap.txt");
if (f) {
char puffer[4];
unsigned long ul;
  for(int i=0; i<110;i++) {
    f.readBytes(puffer,3);
    puffer[3] = '\0';
    ul = strtoul(puffer, NULL, 16);
    // mache was mit ul
  }
   f.close();
}

Gruß Tommy

7

Mit "struct" ist währe das schreiben und wieder einlesen aus dem Spiffs ein Kinderspiel.

Gruß Fips

8

Hallo

irgendwie musst Du dann noch das was Du Icon Name nennst auslesen und auswerten. Auslesen eventuell bis Zeilenende und .... was auch immer damit machen.

Eventuell nimmst Du besser für jedes "ion " eine eigene Datei ,könnte einfacher sein

Heinz

9

Derfips:
Mit "struct" ist währe das schreiben und wieder einlesen aus dem Spiffs ein Kinderspiel.

Was an 110 Werten ist ein struct? (eher ein Array)

Gruß Tommy

10

Tommy56:
Was an 110 Werten ist ein struct? (eher ein Array)

Gruß Tommy

Ein Array aus struct?
Ein struct mit struct?

Als erstes kommt der Icon Name und in den nächsten 10 Zeilen kommen kommen jeweils 11 Werte

Reicht da ein Array?

Gruß Fips

11

Wir haben hier mal wieder ein klassisches Beispiel von Salamitaktik.

Erst gibt es nur 110 Werte, dann sollen die umgerechnet werden, dann kommt noch ein Name dazu.

Ich werde mich erst mal zurücklehnen und warten, wie die Beschreibung in 1 Woche aussieht.

@Fips mit den anderen Daten hast Du mit dem struct natürlich recht und dann würde ich es auch binär speichern und einlesen.

Aber so ist das halt mit den Fragestellern, sie verraten selten alles von Anfang an.

Gruß Tommy

12

Guten Morgen,

nochmals vielen Dank für die tolle Hilfe noiasca und Tommy :slight_smile: . Natürlich auch an alle anderen!

@Tommy: Sorry ich wollte keinesfalls eine "Salamitaktik" anwenden und immer nur Scheibchenweise Informationen geben, wie es werden soll. Ich hab mir mittendrin überlegt, dass ich es toll finden würde wenn ich alle Bitmaps in einer Datei habe und es dazu genommen. Vielleicht hätte ich erst Teilstück 1 lösen sollen und dann nochmal nachfragen.

Ich habe gestern Abend noch lange am Sketch gesessen und ihn zum funktionieren gebracht. Das Ergebnis möchte ich natürlich mit Euch teilen und vielleicht bekomme ich noch den ein oder anderen Verbesserungsvorschlag :).

BitmapSpiffsHex.ino:

#include "FS.h"

uint32_t bitmapFarben[110 + 1];

bool bitmapSpiffs (const char * bDatei, const char * bName) {

  // Variabeln deklarieren
  File    f;                           // Handelt die Datei
  char bitmapName[20 + 1];             // Name des Bitmaps wie er im txt File seht
  int     c;                           // Aktuell eingelesenes Zeichen
  char puffer[7];                      // Zwischenspeicher für 6 Bytes
  uint32_t ul;                         // Nimmt den umgewandelten Zwischenspeicher auf
  bool bitmapGefunden = 0;             // Gibt Auskunft, ob das gesuchte Bitmap gefunden wurde
  int     i;                           // Zählvariable für Anzahl eingelesener HEX Werte bzw. des Bitmap Namens
  uint16_t bitmapFarben_Anzahl = 0;    // Menge der ausgelesenen HEX Werte

  f = SPIFFS.open (bDatei, "r");       // Öffne die txt im Read-Only Modus

  if (f) {                             // Wenn die Datei geöffnet werden konnte
    c = f.read ();                     // Lese das erste Zeichen ein

    while (c == '*') {                 // Solange das Zeichen ein * (signalisert Bitmap Namen) ist Schleife ausführen
      i = 0;                           // Zählvariable auf 0 setzen

      while (f.available()) {          // Solange Zeichen verfügbar Schleife ausführen
        c = f.read();
        
        if (c == '\r' || c == '\n') {  // Wenn Return oder Newline als Zeichen
          break;                       // Schleife abbrechen
        }

        if (i < 20) {                  // Solange i kleiner wie max. Bitmap Name ist
          bitmapName[i++] = c;         // Bitmap Namen Zeichen für Zeichen auslesen
        }
      }

      bitmapName[i] = '\0';            // Ende markieren vom Bitmap Namen
 
      i = 0;                           // Zählvariable zurücksetzen auf 0
      bitmapFarben_Anzahl     = 0;     // mit 0 initialisieren

      while (f.available()) {          // Solange Zeichen verfügbar Schleife ausführen
        c = f.read();
        
        if (c != '\r' && c != '\n') {  // Ist das Zeichen ungleich Return oder Newline

          if (c == '*') {              // Zeichen entspricht dem Steuerzeichen für den Bitmap Namen
            break;                     // Abbrechen der Schleife
          }

          if (c != ' ' && c != '\t') {  // Zeichen ist ungleich Leerstelle oder TAB

            if (i < 110 + 1) {          // i ist kleiner wie die maximale Bitmap Größe
              puffer[0] = c;            // In c ist durch den Schleifen Aufruf bereits das erste Zeichen
              puffer[1] = f.read();     // Weitere 5 Zeichen auslesen um den HEX Wert bilden zu können
              puffer[2] = f.read();
              puffer[3] = f.read();
              puffer[4] = f.read();
              puffer[5] = f.read();
              puffer[6] = '\0';         // Ende markieren
              ul = strtoul(puffer, NULL, 16); // aus dem Puffer ein unsigned int machen
              bitmapFarben[i++] = ul;         // ul in das Farben Array schreiben
            }
          }
        }
      }

      bitmapFarben[i] = '\0';           // Ende markieren
      bitmapFarben_Anzahl = i;          // i durchläufe == ausgelesene HEX Werte

      if (!strcmp(bitmapName, bName)) { // bitmapName mit dem Namen mit dem die Funktion aufgerufen wurde vergleichen
        bitmapGefunden = 1;             // Prüfvariable für Funktionrückgabewert auf true setzen
        break;                          // Schleife abbrechen
      }
    }
    f.close ();                         // Datei schließen
  }

  if (bitmapGefunden) return true;      // Rückgabewert
  else return false;
}

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

  // Bitmap Funktion testen
  if (bitmapSpiffs("/bitmap.txt", "Osterei")) { // Dieses Bitmap gibt es nicht ...
    Serial.println("Test");
  }

  if (bitmapSpiffs("/bitmap.txt", "Herz")) {   // ... dieses schon - es werden alle Farbwerte in HEX ausgegeben
    for (byte i = 0; i < 110; i++) {
      Serial.print(i); Serial.print(" : "); Serial.println(bitmapFarben[i], HEX);
    }
  }
}

void loop() {
}

bitmap.txt:

*Herz
5a694f5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d
5a694d5a694dFF00FFFF00FFFF00FF5a694dFF00FFFF00FFFF00FF5a694d5a694d
5a694dFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF5a694d
FF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF
FF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF
5a694dFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF5a694d
5a694d5a694dFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF5a694d5a694d
5a694d5a694d5a694dFF00FFFF00FFFF00FFFF00FFFF00FF5a694d5a694d5a694d
5a694d5a694d5a694d5a694dFF00FFFF00FFFF00FF5a694d5a694d5a694d5a694d
5a694d5a694d5a694d5a694d5a694dFF00FF5a694d5a694d5a694d5a694d5a694d
*WBaum
5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d5a694d
5a694d5a694dFF00FFFF00FFFF00FF5a694dFF00FFFF00FFFF00FF5a694d5a694d
5a694dFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF5a694d
FF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF
FF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF
5a694dFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF5a694d
5a694d5a694dFF00FFFF00FFFF00FFFF00FFFF00FFFF00FFFF00FF5a694d5a694d
5a694d5a694d5a694dFF00FFFF00FFFF00FFFF00FFFF00FF5a694d5a694d5a694d
5a694d5a694d5a694d5a694dFF00FFFF00FFFF00FF5a694d5a694d5a694d5a694d
5a694d5a694d5a694d5a694d5a694dFF00FF5a694d5a694d5a694d5a694d5a694d

Da ich die bitmap.txt mit dem Windows Notepad erstellt haben ist natürlich kein zusammenhängender Hex-Wert in der Datei sondern 6 einzelne Zeichen mit jeweils 1 Byte - also muss ich 6 Bytes (anstatt 3 Bytes) in den "puffer" auslesen um diesen im Anschluss umwandeln.

Nach Aufruf der Funktion bitmapSpiffs(Dateiname, BitmapName); kann ich aus dem Array bitmapFarben auf die einzelnen Farbwerte zugreifen.

Liebe Grüße,
Björn

13

Hi

Man könnte Es den Dump eines BMP nennen - die 24-Bit-Happen sind als 6er-Gruppen in HEX-Darstellung im File enthalten - ist somit zumindest 'lesbar' und enthält definitiv keine Steuerzeichen/undruckbare Zeichen.

MfG