Hex in String umwandeln

[Ingmar R. (irosenhagen)]

Ahoi, nachdem das Problem mit dem Auslesen der MMC gelöst ist (siehe 
letzter Beitrag hier:Beitrag "SourceCode MMC die Zweite"), 
gibts ein neues Problemchen.
Und zwar hab will ich die Dateinamen usw. im Root Directory ausgeben. 
Die Karte liefert mir das ja alles artig in den Hex-Codes der 
ASCII-Tabelle.
Mein Display braucht für die Darstellung eines Zeichens 8 Byte. Die 
mitgegebene Ausgabefunktion macht also folgendes:
Man ruft die Funktion zB mit Print(a) auf, dann wandelt die Funktion "a" 
in den Hex-Wert des Asciis um. Also 0x61, danach guckt sie welche 8 
Spalten in Zeile 0x61 eines Arrays liegen und schickt diese ans Display.

D.h. ich kann Text direkt ausgeben und mit einer passenden utoa auch 
Variablen die Zahlen enthalten.
Aber wie kriege ich es jetzt hin, daß ich Variablen ausgebe, die dann 
als Text interpretiert werden?
Hatte schon an eine Funktion in der Richtung gedacht:

ASCII[0x61]='a';

unsigned char ascii_lookup (unsigned char ascii_code)
{
string=ASCII[ascii_code];
return (string);
}


ascii_lookup(0x61);
Print(string);

Aber das scheint auch nicht so zu klappen.

[Johannes M. (johnny-m)]

Ich verstehe nicht ganz, was Du da vorhast. 'a' hat bereits den Wert 
0x61, deshalb sehe ich keinen Sinn in einer Lookup-Tabelle für 
ASCII-Zeichen... Der Controller eines Displays (wenn es sich um ein 
alphanumerisches handelt oder es Zeichensätze unterstützt) gibt 
automatisch ein 'a' aus, wenn ein 0x61 reinkommt.

[Karl H. (kbuchegg)]

Ingmar Rosenhagen wrote:

Ich versteh zwar weniger als 10% deiner Fragestellung
(weil sie so konfus formuliert ist)
aber,

> Man ruft die Funktion zB mit Print(a) auf, dann wandelt die Funktion "a"
> in den Hex-Wert des Asciis um. Also 0x61,

Wozu brauchst du da eine Funktion?
'a' ist die Schreibweise im Quelltext deines Programmes. Das
Programm kriegt soweiso immer nur 0x61 zu sehen, egal ob du
0x61 oder 'a' schreibst. Beides sind nur unterschiedliche
Schreibweisen für dasselbe.

> D.h. ich kann Text direkt ausgeben und mit einer passenden utoa auch
> Variablen die Zahlen enthalten.

OK. In diesem Teil verstehe ich, wovon du redest.

> Aber wie kriege ich es jetzt hin, daß ich Variablen ausgebe, die dann
> als Text interpretiert werden?

Den Teil verstehe ich wiederrum überhaupt nicht. Was ist die
Fragestellung.  Von welcher Variablen sprichst du? Und warum
muss diese als Text interpretiert werden? Vor allen Dingen:
Warum muss sie 'interpretiert' werden. Ein µC interpretiert
nicht.


> Hatte schon an eine Funktion in der Richtung gedacht:
>
> ASCII[0x61]='a';
>
> unsigned char ascii_lookup (unsigned char ascii_code)
> {
> string=ASCII[ascii_code];
> return (string);
> }

Diese Lookup-Tabelle kannst du dir sparen. Deine Funktion
lässt sich kürzer schreiben als

unsigned char ascii_lookup (unsigned char ascii_code)
{
  return ascii_code;
}

weil der ASCII Code eines Zeichens und das Zeichen für ein
C-Programm ein und dasselbe sind. Wenn du schreibst:

unsigned char b = 'a';

dann wird in b der ASCII Code des Zeichens 'a' abgelegt.
In einem C-Programm gibt es genau genommen keine Zeichen,
so wie du das vermutest. Alles sind nur Zahlen. Und im
Falle von character Variablen, sind diese Zahlen halt die
ASCII Codes der Zeichen. Aber es sind nach wie vor einfach
nur Zahlen:

unsigned char b = '!';
b = 2 * b;

Bei der Initialisierung wurde b der Wert 0x21, oder dezimal 33
zugewiesen. Dies deshalb weil 0x21 der ASCII Code für '!' ist.
Die Multiplikation mal 2 macht daraus 66. Wird die Variable b
mit entsprechenden Ausgaberoutinen ausgegeben welche b als
Character Variable auffassen, dann kommt am Ausgabegerät ein
'B' an. Dies deshalb weil der ASCII-Code von 'B' 66 (oder
eben 0x42) ist. Aber diese Umsetzung in einen lesbaren Buchstaben
macht das Ausgebegerät (indem es die entsprechenden Pixel
ein und ausschaltet). Für das Programm im µC ist das immer
einfach nur die Zahl 66.

>
>
> ascii_lookup(0x61);
> Print(string);

Gewöhn dir eine andere Nomenklatur an:
Unterscheide zwischen einzelnen Zeichen und Strings.
einzelne Zeichen werden einfach nur 'Zeichen' genannt.
Ein String ist in C eine Abfolge von Zeichen (die in
einem Array gespeichert ist) und mit einem '\0' Zeichen
abgeschlossen wird.


Mir ist immer noch nicht klar, was denn eigentlich deine
Fragestellung ist.

[2922 (Gast)]

Der Poster will ein Hex in 8 byte wandeln. Macht wenig Sinn. Besser were 
es ein Byte, das Darzustellende, in 8 bytes zu wandeln. Dies macht man 
mit einer Tabelle. Das braucht beliebig Platz. Der sparsamere Ansatz 
waere nur die benoetigten Zeichen in einer Tabelle zu haben.

[Karl H. (kbuchegg)]

Ja schon. Soweit hab ich das auch aus dem Originalbeitrag herausgelesen.

Wenn ich den Originalbeitrag richtig interpretiere, dann hat er
bereits eine Funktion, mit der er ein einzelnes Zeichen korrekt
ausgeben kann.

Daraus eine Funktion zu basteln, die einen kompletten String ausgeben
kann, ist ja trivial und wenn ich richtig interpretiere ebenfalls
vorhanden.

Weiters hat er eine Funktion mit der er einen Zahlenwert in eine
Textrepräsentierung umwandeln und dann (mittels der Textfunktion)
die Ausgabe bewerkstelligt.

Also frage ich mich: Herz, was willst du mehr. Textausgabe geht,
Zahlenausgabe geht. Wo liegt dann das Problem?

Wie man eine Zahl in der Textrepräsentierung nicht zur Basis 10
sondern zur Basis 16 bekommt, wird ja doch wohl nicht das Problem
sein. Falls doch: Schau dir mal das letzte Argument von utoa()
an.