"Zeiger" auf struct-Element

[Marcel P. (Gast)]

Hallo, ich hab da ein kleines Problem.
Für das auslesen mehrerer Motor-Sensoren habe ich mir folgende Struktur 
an Variablen angelegt:

typedef struct{
  uint16_t ui16_sensor_val;
  char description_string[20];
} SENSOR;

struct sensors {
  SENSOR oil_pressure;
  SENSOR oil_temp;
  SENSOR coolant_pressure;
  SENSOR coolant_temp;
  SENSOR ambient_temp;
} datafields;

uint8_t ui8_active_screen = 0;

Jetzt möchte ich diese Sensorwerte auf einem Display ausgeben, abhängig 
vom Wert der in ui8_active_screen  der gewählten Bildschirmseite soll 
der entsprechende Sensor angezeigt werden.
also statt so für einen einzelnen Wert:

char Buffer[5];
itoa(datafields.oil_pressure.ui16_sensor_val, Buffer, 10);
lcd_string(Buffer);

eher sowas in der art:

char Buffer[5];
itoa(datafields[ui8_active_screen].ui16_sensor_val, Buffer, 10);
lcd_string(Buffer);

das frisst der compiler natürlich nicht. Wie kann ich das 
bewerkstelligen ?
Vielen dank schonmal...

[mr. mo (Gast)]

Mal folgenden Operator nachschlagen "->".

[Daniel A. (daniel-a)]

Mit einem Array.

#define SENSOR_COUNT 3

struct sensors {
  SENSOR oil_pressure;
  SENSOR oil_temp;
  SENSOR coolant_pressure;
  SENSOR coolant_temp;
  SENSOR ambient_temp;
} datafields[SENSOR_COUNT];

Oder noch besser:

// Headerfile
#define SENSOR_COUNT 3

struct sensor { // nur declaration
  SENSOR oil_pressure;
  SENSOR oil_temp;
  SENSOR coolant_pressure;
  SENSOR coolant_temp;
  SENSOR ambient_temp;
};

...

// c file
struct sensor sensors[SENSOR_COUNT]; // definition

...

char Buffer[6]; // 6 statt fünf, weil das Nullbyte auchnoch Platz braucht
itoa(sensors[ui8_active_screen].ui16_sensor_val, Buffer, 10);
lcd_string(Buffer);

[Marcel P. (Gast)]

@mr.mo

danke, werde ich mal ansehen...

@Daniel

hätte ich dann aber nicht 3 mal das komplette struct ? Also 3 mal den 
Ölsensor, 3 mal den Kühlmittelsensor, usw ?

char Buffer[6]

stimmt, an die maximale 65535 muss ja als String noch ne '\0' ran... 
ganz vergessen, danke ^^

[aSma>> (Gast)]

Marcel P. schrieb:
> typedef struct{
>   uint16_t ui16_sensor_val;
>   char description_string[20];
> } SENSOR;
>
> struct sensors {
>   SENSOR oil_pressure;
>   SENSOR oil_temp;
>   SENSOR coolant_pressure;
>   SENSOR coolant_temp;
>   SENSOR ambient_temp;
> } datafields;

Servus,
du willst ja mit Pointer arbeiten. Ein großes Thema ist es immer wieder, 
wenn es um dynamische Speicherverwaltung geht...

Hier ein hardcoded bsp.:

typedef struct{
   uint16_t ui16_sensor_val;
   char description_string[20];
} SENSOR_t;

typedef struct sensors {
   SENSOR_t oil_pressure;
   SENSOR_t oil_temp;
   SENSOR_t coolant_pressure;
   SENSOR_t coolant_temp;
   SENSOR_t ambient_temp;
 } DATAFIELD_t;

//gloabal var
DATAFIELD_t[] DATA

[Marcel P. (Gast)]

@aSma

irgendwie stehe ich gerade auf dem Schlauch was du mir genau sagen 
möchtest.
Liegt vielleicht aber auch daran, das ich gerade versuche den -> 
Operator zu verstehen o.O

Im Grunde möchte ich folgende Funktion erreichen, nur eben sehr viel 
einfacher, da die Sensoren mehr werden sollen und ich nicht für jeden 
Sensor ein extra case-Block schreiben möchte.

      char Buffer[5];
      
      switch(ui8_active_screen) {
        
        case 0:
        itoa(datafields.oil_temp.sensor_val, Buffer, 10);
        break;
        case 1:
        itoa(datafields.oil_pressure.sensor_val, Buffer, 10);
        break;
        case 2:
        itoa(datafields.coolant_temp.sensor_val, Buffer, 10);
        break;
        case 3:
        itoa(datafields.coolant_pressure.sensor_val, Buffer, 10);
        break;
        case 4:
        itoa(datafields.ambient_temp.sensor_val, Buffer, 10);
        break;
        default:
        
      }
      lcd_setcursor(0,0);
      lcd_string(Buffer);

[aSma>> (Gast)]

Marcel P. schrieb:
> typedef struct{
>   uint16_t ui16_sensor_val;
>   char description_string[20];
> } SENSOR;
>
> struct sensors {
>   SENSOR oil_pressure;
>   SENSOR oil_temp;
>   SENSOR coolant_pressure;
>   SENSOR coolant_temp;
>   SENSOR ambient_temp;
> } datafields;

Servus,
du willst ja mit Pointer arbeiten. Ein großes Thema ist es immer wieder, 
wenn es um dynamische Speicherverwaltung geht...

Hier ein hardcoded bsp.:

//in header
#define      MAX_SENSOR   3    

typedef struct{
   uint16_t ui16_sensor_val;
   char description_string[20];
} SENSOR_t;

typedef struct{
   SENSOR_t oil_pressure;
   SENSOR_t oil_temp;
   SENSOR_t coolant_pressure;
   SENSOR_t coolant_temp;
   SENSOR_t ambient_temp;
 } DATAFIELD_t;

DATAFIELD_t* read_data(); //fkt in header


//gloabal var
DATAFIELD_t DATA[MAX_SENSOR];  

//fkt mit einen pointer als rückgabetyp
DATAFIELD_t* read_data(){

static uint8_t sensor_counter=0;  // No malloc use. Hard coded.

if (sensor_counter == MAX_SENSOR)  // Max sensor arrived. 
    return NULL;

//hier ist dein pointer
DATAFIELD_t* p = (DATAFIELD_t*)&DATA[sensor_counter++]; //pointer zeigt auf sensor i!

p->oil_pressure.ui16_sensor_val = xxx;

...
return p;
}

//main
extern DATAFIELD_t* read_data();
DATAFIELD_t *sensor1_p, *sensor2_p ,*sensor3_p;

int main(){

sensor1_p = read_data();
sensor2_p = read_data();
sensor3_p = read_data();
}

Wenn du
>   uint16_t ui16_sensor_val;
>   char description_string[20];
nicht gleichzeitig brauchst, dann kannst du daraus auch eine union 
machen.

mfg

[aSma>> (Gast)]

Marcel P. schrieb:
> @aSma
>
> irgendwie stehe ich gerade auf dem Schlauch was du mir genau sagen
> möchtest.

sry, habe noch nicht fertig gehabt. Bin auf den enter botton drauf 
gekommen.

[aSma>> (Gast)]

Marcel P. schrieb:
> char Buffer[5];
>
>       switch(ui8_active_screen) {
>
>         case 0:
>         itoa(datafields.oil_temp.sensor_val, Buffer, 10);
>         break;
> ...

Dein case ist nicht ausgagekräftig. Du brauchst hier keinen Pointer, 
wenn du alles global hälst. Aber du kannst natürlich einen nutzen. Wie 
zuvor von mir gezeigt.

typedef enum{
   oil_temp = 0,
   cool_pres,
   cool_temp,
   amb_temp,
} SENSOR_SWITCH_t;

SENSOR_SWITCH_t sensor_e;

switch(sensor_e) {

      case oil_temp:
                        itoa(datafields.oil_temp.sensor_val, Buffer, 10);
                        break;
      case cool_pres:

usw

[Daniel A. (daniel-a)]

Marcel P. schrieb:
> @Daniel
>
> hätte ich dann aber nicht 3 mal das komplette struct ? Also 3 mal den
> Ölsensor, 3 mal den Kühlmittelsensor, usw ?

Ups, ich hatte nicht nachgesehen, was im Struct drin steht. Neuer 
vorschlag: (c11)

typedef struct{
  uint16_t ui16_sensor_val;
  char description_string[20];
} SENSOR;

struct sensors {
  union {
    SENSOR sensor_list[1];
    struct {
      SENSOR oil_pressure; // Müssen alle vom typ SENSOR sein
      SENSOR oil_temp;
      SENSOR coolant_pressure;
      SENSOR coolant_temp;
      SENSOR ambient_temp;
    };
  };
} datafields;

uint8_t ui8_active_screen = 0;

...

char Buffer[6];
itoa(datafields.sensor_list[ui8_active_screen].ui16_sensor_val, Buffer, 10);
lcd_string(Buffer);

[Marcel P. (Gast)]

@aSma

ok, ich versuche mal zu verstehen, wie ich das dann anwende. Momentan 
stehe ich gerade immernoch auf den Schlauch, was aber eher an mir liegt 
^^ .

Ich hab mal kommentiert, wie ich das verstanden habe... und ab wo ich 
auf dem schlauch stehe...

//in header
#define      MAX_SENSOR   3                      // meine Anzahl an sensoren (eigentlich 5)...

typedef struct{
   uint16_t ui16_sensor_val;
   char description_string[20];
} SENSOR_t;

typedef struct{
   SENSOR_t oil_pressure;
   SENSOR_t oil_temp;
   SENSOR_t coolant_pressure;
   SENSOR_t coolant_temp;
   SENSOR_t ambient_temp;
 } DATAFIELD_t;

DATAFIELD_t* read_data(); //fkt in header        


//gloabal var
DATAFIELD_t DATA[MAX_SENSOR];                        // indiesem Array stehen meine jeweiligen Sensorwerte aus ui16_sensor_val

//fkt mit einen pointer als rückgabetyp
DATAFIELD_t* read_data(){

static uint8_t sensor_counter=0;  // No malloc use. Hard coded.                             //fängt bei 0 an, klar

if (sensor_counter == MAX_SENSOR)  // Max sensor arrived.                                  //wenn alle Sensoren durch, fertig
    return NULL;

//hier ist dein pointer
DATAFIELD_t* p = (DATAFIELD_t*)&DATA[sensor_counter++]; //pointer zeigt auf sensor i!        // Hier fängt es an für mich unverständlich zu werden

p->oil_pressure.ui16_sensor_val = xxx;                                                         // Hier steig ich ganz aus ? das ist ja nur der Öldruck-Sensor.. was ist mit den anderen ? Entsprechend so ?:

p->oil_temp.ui16_sensor_val = xxx;                       // =xxx wäre dann etwa mein = ADC_Read_avg(channel, samples); für jeden sensor ?

...
return p;
}

//main
extern DATAFIELD_t* read_data();
DATAFIELD_t *sensor1_p, *sensor2_p ,*sensor3_p;                  // verstehe ich nicht ganz genau, aber das sind dann 3 pointer für das struct DATAFIELD_t ?

int main(){

sensor1_p = read_data();
sensor2_p = read_data();
sensor3_p = read_data();
}

Sorry, das ich mich doof anstelle, aber pointer sind für mich irgendwie 
ein rotes Tuch....

@Daniel

mache ich mir durch deinen Vorschlag nicht den Vorteil des struct 
zunichte wenn alle vom Typ SENSOR sein müssen ? Weil dann könnte ich 
doch auch ein Array draus machen ? Also statt dem hier:

typedef struct{
  uint16_t sensor_val;
  char description_string[20];
} SENSOR;

struct sensors {
  union {
    SENSOR sensor_list[1];
    struct {
      SENSOR oil_pressure; // Müssen alle vom typ SENSOR sein
      SENSOR oil_temp;
      SENSOR coolant_pressure;
      SENSOR coolant_temp;
      SENSOR ambient_temp;
    };
  };
} datafields;

dann so:

enum sensors {
OIL_PRES_e = 0,
OIL_TEMP_e,
COL_TEMP_e,
EOL_PRES_e,
AMB_PRES_e
};

SENSOR sensors[5];

itoa(sensors[OIL_PRES].sensor_val, Buffer, 10);

oder ?

Ich habe das "Datafields" als struct angelegt, weil da in Zukunft noch 
andere sachen ausser SENSOR-typen dazu kommen sollen. Diese anderen 
enthalten zwar auch immer die Felder "sensor_val" und 
"sensor_descriptor" aber eben auch noch zusätzliche Felder.

[Daniel A. (daniel-a)]

Marcel P. schrieb:
> mache ich mir durch deinen Vorschlag nicht den Vorteil des struct
> zunichte wenn alle vom Typ SENSOR sein müssen ? Weil dann könnte ich
> doch auch ein Array draus machen ? Also statt dem hier:

Ja. In solchen fällen nutze ich Basisklassen.

enum sensor_type {
  ST_PRESSURE,
  ST_TEMP
};

struct sensor {
  enum sensor_type type;
  uint16_t ui16_sensor_val;
  char description_string[20];
};

struct pressure_sensor {
  struct sensor super;
  bool other_value;
};

struct temp_sensor {
  struct sensor super;
  int bla;
};

struct pressure_sensor oil_pressure = {
  .type = ST_PRESSURE
};

struct temp_sensor oil_temp = {
  .type = ST_TEMP
};

struct pressure_sensor coolant_pressure = {
  .type = ST_PRESSURE
};

struct temp_sensor coolant_temp = {
  .type = ST_TEMP
};

struct temp_sensor ambient_temp = {
  .type = ST_TEMP
};

struct sensor* sensors[] = {
  &oil_pressure.super,
  &oil_temp.super,
  &coolant_pressure.super,
  &coolant_temp.super,
  &ambient_temp.super
};

...

char Buffer[6];
itoa(sensors[ui8_active_screen]->ui16_sensor_val, Buffer, 10);
lcd_string(Buffer);

[aSma>> (Gast)]

Marcel P. schrieb:
> Sorry, das ich mich doof anstelle, aber pointer sind für mich irgendwie
> ein rotes Tuch....

Siehe Überschrift: "Zeiger" auf struct-Element

Dann lasse einfach die Zeiger und Unions weg.

Wichtig ist, dass man aussagekräftig programmiert, denn dann brauchst du 
auch kaum zu kommentieren (Stichwort: real programmer).

Schreibe jetzt ein header und .c Datei und poste hier.

mfg

[Marcel P. (Gast)]

Ich werde versuchen das sinnig in mein Code zu setzen und dann poste ich 
das ganze Ding mal hier sobald es passt.

Vielen vielen Dank aber schon mal. Die Codebeispiele haben mir aber auch 
noch viele andere Kleinigkeiten gezeigt, die den Programmierstil viel 
besser machen.

Grüße, Marcel

[aSma>> (Gast)]

Daniel A. schrieb:
> Daniel Abrecht

Gar nicht so schlecht. Damit ist das Programm nicht redudant und lässt 
sich prima erweitern. Daumen hoch.