Konstante variabel aufrufen?

Halle ihr Experten,
ich weiß, dass sich in meinem Titel etwas wiederspricht. Es geht um folgendes, ich soll bei einem Messgerät den C-Code für den Mikrocontroller derart umschreiben, so dass ich mit Hilfe einer Variablen auf Konstanten zugreifen kann. Bei diesen Werten muss es sich um Konstante handeln, damit sie aus Platzgründen im Rom liegen. Da man nun aber eine Konstante normalerweise durch ihren Namen aufruft, gibt das mit der Variable ein Problem, das man zwar durch eine Unmenge von ‚switch-case‘ abfragen realisieren könnte. Auch die möglichkeit, die Werte an einer bestimmten Stelle im Rom zu plazieren und über die Adresse direkt darauf zuzugreifen, ist zu unflexibel. Nun weiß ich einfach nicht mehr, was ich machen soll, und ob das überhaupt irgendwie möglich ist.

Mit freundlichen Grüßen
Stefan Hager

Hi Stefan,

wenn Du Konstanten in einem Array anlegen kannst, brauchst Du
nicht einmal die Variable, sondern verwendest den Bezeichner des Arrays + Index um die einzelnen Daten im ROM zu lesen.

Gruß Patrick

oder aber…
Hi Stefan,

vergiß das Array aus dem vorherigen Posting. Du mußt einfach
nur dafür sorgen, daß die Konstanten die Du im Quelltext anlegst ins ROM gelegt werden. Greifst Du dann mit dem Bezeichner darauf zu, wird der µC aus dem ROM lesen.

Gruß Patrick

Hallo Stefan,

int a = 123;
Im RAM werden 16-Bit (wenn der Compiler 16-Bit int verwendet) für a reserviert und beim Start wird „123“ aus dem ROM ins RAM copiert. „a“ ist les- und schreibbar (LValue)

const int a = „123“
„a“ ist im ROM abgelegt und kann deshalb nur gelesen werden. Im RAM wird kein PLatz benötigt.

Ist das die gesuchte Antwort ??

MfG Peter(TOO)

nicht ganz…
Hallo Peter,
aber ich muss mich erst mal bei Dir bedanken, dass ich jetzt mal endlich weiss, warum der Compiler inmmer etwas von ‚left side not lvalue‘ geschrieben hat.

Es sieht bei mir so aus, dass ich Text-Strings als Konstante abgelegt habe, um damit den Platz im RAM freizuhalten. Nun habe ich in einem Modul des Programms eine Funktion, die mir eine Variable übergibt. Und nun muss ich eine Möglichkeit finden, am besten ohne viele ‚if-‘ und ‚switch-case-Abfragen‘, anhand dieser Variable auf die in einem anderen Modul abgelegten Konstanten zuzugreifen.

z.B.

const char konstante1 = „Hallo“;
const char konstante2 = „Welt“;

in einem anderen Modul rufe ich dann die Funktion
ausgabe(variable1) auf.

und nun muss in der Funktion ausgabe anhand der Variable eine Verbindung zwischen dem Inhalt in variable1 und dem Konstantennamen konstante1 finden, da ich in ausgabe gerene den Inhalt von konstante1 auf einem LCD-Display ausgeben möchte.

Mfg und vielen Dank für die Mühen beim Durchlesen und Nachdenken
Stefan Hager

const char konstante1 = „Hallo“;
const char konstante2 = „Welt“;

#define konst1 Hallo
#define konst2 Welt

dann übersetzt der Compiler alle ‚konst1‘ in ‚Hallo‘ usw.

Du kannst im Quellcode bequeme Bezeichner benutzen die der Compiler dann umwandelt.

im Quelltext steht dann z.B. …konst1

der Compiler macht daraus …Hallo

vielleicht hilft Dir das.

Gruss und schönes Wochende,
Christof

Hallo Stefan
Das Problem bei der Lösung von Christof ist, dass jede Benutzung einen eigenen Eintrag im ROM benötigt.

Es sieht bei mir so aus, dass ich Text-Strings als Konstante
abgelegt habe, um damit den Platz im RAM freizuhalten. Nun
habe ich in einem Modul des Programms eine Funktion, die mir
eine Variable übergibt. Und nun muss ich eine Möglichkeit
finden, am besten ohne viele ‚if-‘ und ‚switch-case-Abfragen‘,
anhand dieser Variable auf die in einem anderen Modul
abgelegten Konstanten zuzugreifen.

z.B.

const char konstante1 = „Hallo“;
const char konstante2 = „Welt“;

in einem anderen Modul rufe ich dann die Funktion
ausgabe(variable1) auf.

Wenn ich es richtig verstanden Habe, verteilt sich das ganze auf 3 Module:
Modul 1: enthält die Texte
Modul 2: will einen dieser Texte Ausgeben
Modul 3: macht die Ausgabe
Problem: möglichst wenig ROM und RAM verwenden. ?

Eine Möglichkeit wäre das ganze mit einer Array zu lösen:

File „texte.h“:

typedef enum
{
 HELLO,
 WELT,
 TEXT3,
 .....
 TEXTn,
 \_\_SIZE\_\_ /\* damit hast du die die Anzahl der enums \*/
} TEXTE;


**file "modul1.c"**

    
    #include "texte.h"
    
    const char konstanten[\_\_SIZE\_\_][] = 
     {
     "Hello",
     "World",
     "text1",
     .......,
     "textn"
     };
    
    
    **file "modul2.c"**
    
        
        #include "texte.h"
        
        void ausgabe(TEXTE text);
        
        void f(void)
        {
         ausgabe(WELT);
        }
        
        
        **file "modul3.c"**
        
            
            #include "texte.h"
            extern const char konstanten[\_\_SIZE\_\_][];
            /\* Falls der Compiler Probleme mit der undefinierten 
            Dimension macht, alternativ:
            extern const char \* const konstanten[\_\_SIZE\_\_];
            \*/
            
            void ausgabe(TEXTE text)
            {
             puts( konstanten[text] ); 
            }
        
        
        
        
        
        
        > Mfg und vielen Dank für die Mühen beim Durchlesen und Nachdenken
        
        War nur Erfahrung.
        
        
        
        > Stefan Hager

Herzlichsten Dank für Eure Hilfe…
… habs jetzt aber nach langem hin und her anders gemacht, da die Variante auf jeden Fall funktioniert. Ich habe jetzt einen Array, den ich an eine ganz bestimmte Positien im ROM Speicher lege, und in dem die Strings hinterlegt sind. Auf die einzelnen Strings greife ich dann durch einen Pointer, der die Anfangsadresse des Arrays weiß, zu, den ich nur noch verschieben muss, um an die einzelnen Elemente zu kommen. Ich finde es nicht ganz so praktisch, da nich so flexibel, falls sich mal was ändern sollte, aber für die Anwendung reicht das…

Allen ein schönes Wochenende
MfG Stefan Hager

Tach Patrick,
das hatte ich auch versucht, habe es aber nicht zustande gebracht, Strings in einem Array so zu speicher, dass ich sie auch wieder als Strings ausgeben konnte. Ich habe keine Ahnung, woran ich da gescheitert bin.

Gruß Stefan