www.mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Parameter verschiedenen typs in eine tabelle einfügen


Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo habe hier ein Problem, vielleicht könnt Ihr mir helfen....

ich will Parameter verschiedenen Typs in einer Tabelle abspeichern. Die
Tabelle soll den Namen, den Typ und den jeweiligen Wert enthalten.
um auf den jeweiligen parameter mit einem pointer zugreifen zu können,
muss jedesmal der pointer mit dem Typ des Parameters, auf den er zeigen
soll initialisiert werden...ich hab mir das so gedacht:...aber es
funktioniert nicht richtig...habt ihr eine Ahnung wie man es abändern
könnte, damit es funktioniert
danke
Gruss
Samuel

/*********************************************************************** 
*****/
/*tabelle */
/*********************************************************************** 
*****/
//Tabelle
const comm_struct comm_tab[] = {
{"parameter1", "s16", &parameter1},
{"parameter2", "s32", &parameter2},
{"parameter3", "u32", &parameter3},
{"parameter4", "u16", &parameter4},
};

/*********************************************************************** 
*****/
/*zugehöriges struct */
/*********************************************************************** 
*****/
typedef char* type_table;

typedef struct{
char *name;
char* type_table;
type_table *ptr;

}comm_struct;

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
"... aber es funktioniert nicht richtig."

Was heisst das?

Erhältst Du eine Compiler-Fehlermeldung, geht das Licht aus, wird der
Kaffee kalt oder stehen irgendwo in Deinem Programm uns nicht bekannte
Daten?

Schon mal Deinen Code (wenn er denn übersetzbar ist) in einem Debugger
angesehen?

Autor: Michael (ein anderer) (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@samuel:

Wäre einfacher gewesen Du hättest die Fehlermeldung des Compilers
gepostet...

Dein Problem ist:

Zuerst führst Du einen neuen Bezeichner für einen Typ ein: typedef
char* type_table;

Dann verwendest Du den selben Bezeichner als Member in Deiner Struktur:
char* type_table;

Das geht nicht. Änder' den Namen von einem und es sollte gehen.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,
hab hier folgendes Problem:
beim comilieren  der folgenden Zeile tritt fogende Fehlermeldung auf:

*(u08)comm_tab[mid].ptr=parametervalue_intern;
"
operand of "*" must be a pointer"

was sagt mir das?...und wie kann ich das Problem lösen?
danke

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
*(u08)comm_tab[mid].ptr=parametervalue_intern;

"operand of "*" must be a pointer"

Du castest den Ausdruck comm_tab[mid].ptr
in den Datentyp u08
und versuchst das zu dereferenzieren.
Wenn der Datentyp u08 kein Pointerdatentyp ist (ich vermute mal, daß
das unsigned char sein könnte), dann geht das nicht.

Was für einen Typ hat parametervalue_intern?
Was für einen Typ hat das Struktur-Member ptr?

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ja u08 ist bei mir char....das war ein fehler von mir....
ich will eigentlich s16, s32, u16, u32 benutzen
parametervalue_intern ist s32

also mein programm sieht etwa folgendermassen aus:

//struct
typedef struct{
  char *name;
  u08 type;
  void *ptr;

}comm_struct;


//zugehörige tabelle
const comm_struct comm_tab[] = {      // command table
{"parameter1",TYPS16,&parameter1},
{"parameter2",TYPS16,&parameter2},

}

switch (comm_tab[mid].type)
    {

case TYPS16:
((*s16)comm_tab[mid]).ptr=(s16)parametervalue_intern;
break;

case TYPU16:
((*u16)comm_tab[mid]).ptr=(s16)parametervalue_intern;
break;

case TYPS32:
((*s32)comm_tab[mid]).ptr=(s16)parametervalue_intern;
 break;

case TYPU32:
((*u32)comm_tab[mid]).ptr=(s16)parametervalue_intern;
break;



und dann kommen folgende Fehlermeldungen, bei jeder Zeile in der switch
anweisung, bei der ich casten will:
type name is not allowed
error: expected a ")"

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So:

case TYPS16:
  comm_tab[mid].ptr = (void *) parametervalue_intern;
  break;

etc.

Da ptr vom Typ void* ist, dürfen dem beliebige Pointer zugeweisen
werden.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
wenn ich das so mache dann kommt für diese Zeile folgende
Fehlermeldung:
"error: expression must be a modifiable lvalue"
was sagt mir das?
danke Dir für deine Hilfe

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Deine Definition der Tabelle ist das Problem:

const comm_struct comm_tab[] = ...
^^^^^

Das stört.

Du definierst die Tabelle const, willst sie aber modifizieren - das
erzeugt zu recht eine Fehlermeldung des Compilers.

Mir ist nicht ganz klar, was Du eigentlich bezwecken möchtest -
einerseits ist die Tabelle bereits initialisiert, andererseits möchtest
Du Elemente der Tabelle in Abhängigkeit anderer Elemente der Tabelle
modifzieren.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
ich will über die serielle Schnittstelle des PCs die parameter ändern
können. wie muss ich dann die tabelle ändern?

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Na, lass' einfach das Wort const weg, dann sollte es funktionieren.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
cool...jetzt zeigt der compiler 0 Fehler an....
ich kapier noch nicht ganz, wieso man einfach einen wert der s32 war
wie parametervalue_intern in void* casten darf

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> ich kapier noch nicht ganz, wieso man einfach einen wert der s32 war
> wie parametervalue_intern in void* casten darf

Man darf prinzipiell alles in void* casten. Ob's das überlebt, ist
'ne ganz andere Frage.
Ist sizeof (void *) kleiner als sizeof (s32), dann
gehen durch das Casting Informationen verloren.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gute Morgen,
jetzt gibt es keine Fehlermeldung mehr....allerdings wird
paramatervalue_intern nicht richtig an die Variablen in der Tabelle
zugewiesen. Die Zeile

comm_tab[mid].ptr=(void*)parametervalue_intern;

bewirkt, dass ich nachher in comm_tab[mid].ptr den Wert stehen habe,
der in parametervalue_internb stand, allerdings steht dann z.B.
0x00000005 in comm_tab[mid].ptr, obwohl zuvor paremetervalue_intern den
Wert in dezimal hatte.
allerdings steht in dem entsprechenenden Parameter der Tablle am Ende
immer noch nicht der Wert
könnt ihr mir bitte helfen..danke

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> allerdings steht dann z.B. 0x00000005 in comm_tab[mid].ptr,
> obwohl zuvor paremetervalue_intern den Wert in dezimal hatte.

Was magst Du damit meinen?
Daß der Debugger den einen Wert als 32-Bit-Hexadezimalzahl anzeigt,
während der andere Wert als 32-Bit-Dezimalzahl angezeigt wird?

Ich gewinne zunehmend den Verdacht, daß Du Dir mal ein Grundlagenwerk
über das Programmieren in C durchlesen solltest.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das grösste Problem ist immer noch dass ich den Wert eben nicht in dem
Parameter stehen hab

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hä? Was ist denn bitte der Wert?
Wie sieht denn der Parameter aus?

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also mit folgendem Code will ich den Wert von parametervalue_intern an
den zugehörigen Parameter z.B. "parameter1" in der Tabelle zuweisen,
dabei klappt eben die Zuweisung in der switch Anweisung nicht,
jedenfalls hab ich den Wert nach den Operationen nicht in der variablen
z.B. parameter1 stehen.woran liegt das?

s16 parameter1;
s32 parameter2;
//etc...


//struct
typedef struct{
  char *name;
  u08 type;
  void *ptr;

}comm_struct;


//zugehörige tabelle
const comm_struct comm_tab[] = {      // command table
{"parameter1",TYPS16,&parameter1},
{"parameter2",TYPS16,&parameter2},
//etc.....
}



switch (comm_tab[mid].type)
    {

case TYPS16:
comm_tab[mid].ptr=&parametervalue_intern;
break;

case TYPU16:
comm_tab[mid].ptr=&parametervalue_intern;
break;

case TYPS32:
comm_tab[mid].ptr=&parametervalue_intern;
break;

case TYPU32:
comm_tab[mid].ptr=&parametervalue_intern;
break;

Autor: OldBug (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Doppelt Posten ist übrigens unheimich gemein >:\

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Aus dem anderen Thread wird so allmählich klar, daß Deine
Aufgabenstellung eine andere ist.
Du möchtest in den Speicher schreiben, auf den comm_tab[mid].ptr
verweist, nicht den Wert dieses Pointers ändern.

Dann sieht natürlich Deine gesamte Zuweisung anders aus:

  case TYPS16:
    (* s16) (comm_tab[mid].ptr) = (s16) parametervalue_intern;

Damit überschreibst Du den bei der Initialisierung Deiner Tabelle
gefüllten Speicher;

  const comm_struct comm_tab[] =
    {
      {"parameter1", TYPS16, &parameter1},
      {"parameter2", TYPS16, &parameter2},


in parameter1 steht daraufin etwas anderes.

Dann darf auch das const wieder auftauchen - es muss nur sichergestellt
sein, daß parameter1 etc. nicht const definiert sind.


Im übrigen hat Oldbug recht - daß Du hier annähernd die gleiche
Diskussion in zwei Threads losgetreten hast, ist insgesamt nicht
förderlich.

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke....ja jetzt läuft die ganze sache....

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
was noch nicht funktioniert ist folgendes:

*(u08 *)(comm_tab[mid].ptr)=value_of_parametervalue_u08;


u08 ist unsigned char. darf ich das so nicht machen oder wie so
funktioniert das so nicht? alls anderen castings auf s16, u16, s32, u32
und f32 funktionieren

Autor: samuel (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
sorry falsch...
der Fehler liegt in der Zeile davor:
value_of_parametervalue_u08 ist vom Typ u08
parametervalue_intern ist vom typ char*.

value_of_parametervalue_u08=(u08)parametervalue_intern;


diese casting geht schief...wieso?

Autor: Rufus T. Firefly (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hier castest Du einen Pointer nach u08 - sonst castest Du
unterschiedlich große int-Varianten. Wie wär's mit Dereferenzieren?

Ich hab's Dir schon mehrfach geraten: Lies' Dir mal ein Buch über die
Grundlagen der Programmierung in C durch - Du scheinst nach wie vor das
eine oder andere Verständnisproblem zu haben.
Mehr als genug Hinweise wurden Dir jetzt auch schon gegeben - und einen
C-Grundkurs kann dieses Forum nicht ersetzen.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.