Universelles Diagramobjekt erstellen

[Chris J. (Gast)]

Moin!

Vielleicht weiss ja ein Spezi, wie man so ein Problem am besten löst?

Ich möchte in Ansi C für ARM für mein Display ein universelles Histogram 
Objekt erstellen. D.h. verschiedene Messwerte wie Druck, Feuchte, 
Temperatur werden von ein und derselben Routine erledigt. Sieht später 
so aus wie in Histogramm bei der Bildbearbeitung.

Also wurstel ich mir erstmal die Grundstruktur hin, nur ein Entwurf.
Prinzip soll sein, dass das Hauptprogramm einen Struct mit Werten 
vollpackt, dann eine InitRoutine aufruft, die einen Zeiger auf das neue 
Diagramm enthält, d.h. nur die Eckdaten und Werte. Halt so wie in der 
StdperiphLib auch.

Diagramm_t myDiagramm;
myDiagramm.blabla = Wert
myDiagramm.blubb  = Wert
ZeigeraufNeues Diagramm = CreateDiagramm(&myDiagramm);

Womit ich etwas rumeier und noch nicht weiss, wie lösen ist der Umstand 
dass die Werte diverse Datentypen haben. Druck ist float, Temperatur ist 
int8 usw. Ich kann bei 20k nicht mit dem Speicher herumasen, also muss 
ich schon sparen. Klar kann man alle max 200 Elemente float machen aber 
dass sind dann eben 200 x 4 Bytes = 1 kByte. Zzgl noch 1 "valid Byte", 
da ich 0 brauche und 0 nicht als ungültigen Datensatz deklarieren kann.

Also versuche ich für jedes erzeugte Diagramm den Datentyp mit zu geben 
an die Create Routine.

Gibt es da vielleicht etwas Eleganteres als das was ich verbrochen habe?

/* Datenformate */
typedef enum {t_float,
              t_int8,
              t_uint8,
              t_uint16}
DF_t;

typedef union {
    int8_t   zahl_8t;
    uint8_t  zahl_u8t;
    int16_t  zahl_16t;
    uint16_t zahl_u16t;
    float    zahl_f;
} werte_t;


typedef struct {
    uint16_t x_pxLen,       // X Ausdehnung in Pixel /2 teilbar
             y_pxLen,       // Y Ausdehnung in Pixel /2 teilbar
             x_Null,        // Nullpunkt
             y_Null;
    uint16_t entrys;        // Anzahl Einträge
    DF_t     DataFormat;    // Datentype: float, uint16_t, int16_t, uint8_t, int8_t
    uint32_t color;         // Farbe des Histogramms
    werte_t* valptr;        // Zeiger auf Wertetabelle



} DiaParam_t;


DiaParam_t* CreateNewDiagram(DiaParam_t* src)
{
    /* Prüfung auf gerade Zahlen*/
    if (src->x_pxLen & 1)
        return (NULL);

    if (src->y_pxLen & 1)
        return (NULL);

    /* Reserviere Speicher für Infostruct*/
    DiaParam_t* dest = malloc(sizeof(DiaParam_t));
    if (dest == NULL)
        return(NULL);

    /* Kopiere Infos in neuen Struct */
    memcpy(dest,src,sizeof(DiaParam_t));

    /* Reserviere Speicher für Wertetabelle */
    size_t len;
    switch (src->DataFormat) {
        case  t_float   :   len = sizeof(float);
                            break;
        case  t_int8    :   len = sizeof(int8_t);
                            break;
        case  t_uint8   :   len = sizeof(uint8_t);
                            break;
        case  t_uint16  :   len = sizeof(uint16_t);
                            break;
        default:            break;
    }

    dest->valptr = malloc(src->entrys * len);
    if (dest->valptr == NULL)
        return (NULL);

    return (dest);
}

[Johannes S. (Gast)]

In C? Igitt.... Für meinen Reflow Ofen habe ich gerade ähnliches 
angefangen und brauche da auch ein Chart für T Soll und Ist. Ich dachte 
sowas findet man mäßig auf Github aber nach einiger Suche dachte ich das 
man sowas doch selbst hinbekommt.
Ich baue das in C++, basierend auf der Adafruit Grafik Lib. Die trennt 
sauber den HW Layer von den Grafik Primitiven, dadurch konnte ich die 
Grafik schon als Simu auf dem PC erstellen. Ist noch in den Grundzügen, 
aber kann ich bei Interesse hier vorstellen. Das basiert auf mbed und 
ist damit per Export einfach für Bluepill und EmBitz zu generieren.

[Johannes S. (Gast)]

So sieht das als Anfang aus bisher aus, einmal die Darstellung auf dem 
µC und das mit dem exaktamente gleichen Code erzeugte Bild in der PC 
Simu. Auf dem PC ist die Entwicklung einfach bequemer, auch wenn das 
Debuggen auf den Cortexen schon easy ist.
Der Text in der Simu fehlt noch weil die Grafik in mbed von der mbed 
Stream Klasse abgeleitet ist und putc/puts/printf zur Verfügung stellt, 
das wäre der nächste Schritt diese in der Simu zu implementieren. Bei 
den Arduinos wird ist das von einer vereinfachten printf abgeleitet, 
aber die Arduinos haben für mich eine untergeordnete Priorität.
Der Code für das Chart sieht bisher so aus:

  Chart chart(tft, 0, 0, 320, 200, WHITE);

  tft.begin();
  tft.reset();
  tft.setRotation(1);
  tft.fillScreen(BLACK);

  PlotArea* plotArea = chart.addPlotArea(6 * 6, 0, 0, 10, YELLOW);
  plotArea->addGridVertical(plotArea->_w / 10, RED);
  plotArea->addGridHorizontal(plotArea->_h / 5, GREEN);
  chart.draw();

Das ist wie gesagt noch nicht zu Ende modelliert und es fehlt noch die 
Anbindung von Skalen und Datenserien. Ist eigentlich 'nur' Fleissarbeit, 
aber ich muss mich gerade ziemlich teilen.

ooops, jetzt sind die Bilder doppelt. Beim Ändern des vorherigen Posts 
gabs Mecker, deshalb habe ich die noch nochmal angehängt. Könnte ein Mod 
im vorherigen Post löschen wenn er mag. Ist schon spät...
PS: angehängte Bilder kann man bei Editieren nicht wieder löschen?

[Chris J. (Gast)]

Johannes S. schrieb:
> In C? Igitt....

Du Johannes.... das nennt man auch "einen Thread kapern" ;-)

Mir fällt bisher nichts ein, wie ich den Datentyp allgemeingültig halten 
kann. GNU CC ist doch so mächtig, vielleicht gibts da ja doch noch was.

[Johannes S. (Gast)]

Naja, das Aufgabe hört sich zumindest gleich an, aber wenn ich dich 
nicht mit c++ überzeugen kann...

In C kann man Objektfunktionalität natürlich auch bauen. In C++ kann man 
dem Chart ein 'addDataSeries(DataSeries)' verpassen und die DataSeries 
kann eine virtuelle Funktion 'draw()' haben die dann ihren Datentyp in 
Pixel umrechnet.

In dein C Beispiel übersetzt heisst das in Diagram_t Funktionspointer zu 
definieren für dass Speicherhandling und die Zeichenfunktion. Dann 
kannst du auch ein drawFloat oder drawInt8 bauen das eben die Daten 
entsprechend interpretiert.

[pegel (Gast)]

Kennst du den?

Der ist ein Teil von dem:
https://www.element14.com/community/servlet/JiveServlet/download/60777-1-95905/STM.Application_Library_2.zip

[Johannes S. (Gast)]

Warum ist dieser Thread in PC-Programmierung gelandet? Es geht doch 
eindeutig um uC Programmierung.

[Frank M. (ukw) (Moderator)]

Johannes S. schrieb:
> Warum ist dieser Thread in PC-Programmierung gelandet?

Habe das korrigiert.

[Johannes S. (Gast)]

Danke!

[Chris J. (Gast)]

pegel schrieb:
> Kennst du den?

Es macht wenig Sinn ein komplett neues Setup zu benutzen, was mehr 
braucht als einen Editor, wenn man bereits alles selbst gemacht hat.

Ich habe da mal reingeschaut.... bisher noch keinen Plan wie man das 
einsetzt, wenn man ein SPI Display vom Typ ILI9341 an einen STM32103 
gepappt hat. Da muss dann ja auch der LL Layer geschrieben werden. Das 
schreckt mich von solchen Libs auch immer ab.

Ok, es gibt Hoffnung, wenn ich so ein Demoprojekt irgendwie in Embitz 
reinkriege und die tausende Pfade zu den Libs richtig gesetzt habe...

  /* Configuration for SPI interfaced LCDs */
#if defined(USE_STM3210C_EVAL) || defined(USE_STM3210B_EVAL) ||\
  defined(USE_STM32100B_EVAL) ||   defined(USE_STM32L152_EVAL)
  pLcdParam->LCD_Ctrl_Port_NCS          = LCD_CTRL_PORT_NCS;
  pLcdParam->LCD_Gpio_Data_Port         = LCD_GPIO_DATA_PORT;
  pLcdParam->LCD_Ctrl_Pin_NCS           = LCD_CTRL_PIN_NCS;
  pLcdParam->LCD_Gpio_Pin_SCK           = LCD_GPIO_PIN_SCK;
  pLcdParam->LCD_Gpio_Pin_MISO          = LCD_GPIO_PIN_MISO;
  pLcdParam->LCD_Gpio_Pin_MOSI          = LCD_GPIO_PIN_MOSI;
  pLcdParam->LCD_Gpio_RemapPort         = LCD_GPIO_REMAP_PORT;
  pLcdParam->LCD_Rcc_BusPeriph_GPIO     = LCD_GPIO_RCC_BUS_PERIPH;
  pLcdParam->LCD_Rcc_BusPeriph_GPIO_Ncs = LCD_GPIO_RCC_BUS_PERIPH_NCS;
  pLcdParam->LCD_Bus_Port               = LCD_SPI_PORT;
#endif

}

[Chris J. (Gast)]

Vielleicht kannst Du mir mal Starthilfe geben, wie sowas grundsätzlich 
eingerichtet wird.

Das erzeugt mir das Tool, wie ich sehe... und wie wird das eingebunden? 
Welche Hardware brauche ich zum Testen? Möglichst ein Demoboard mit 
Display.
Ich arbeite mit EmBitz IDE, basiert auf CodeBlocks, kennt aber kein 
cmake.

Im Bild mein Projekt. Mein Code, der auf der SPL und TMLIB (Tilen 
Majerle) basiert, beides Middlewares. zB enthält die grundlegenede 
Grafikfunktionen und eine Kapselung fast aller Pripherie. Ich habe nur 
das Interface für mein Display geschrieben.

Wenn das mit diesem Grafikwunder auch so geht wäre das schon gut....

[pegel (Gast)]

Hast schon Recht.
Wenn dein Board nicht in der Lib ist, wird schon einiges an Anpassung 
benötigt.

Da die Lib komplett im Quellcode vorliegt, im Gegensatz zu anderen wie 
STemWin, kann man aber vielleicht einige Ideen "ausleihen".

[uuu (Gast)]

Ein allgemein gueltiger Datentyp ? Byte. Byte-Anzahl X-Werte & 
Byte-Anzahl Counts = Y Werte. Gebrochene Pixel gibt es ja nicht.