Hallo und guten Abend,
ich möchte mir eine ASCII-Tabelle über den seriellen Monitor ausgeben lassen.
Die Ausgabe soll einmal als Dezimalzahl, Hexadezimalzahl und als Zeichen erfolgen.
Pro Zahlenwert sollen 15 Zeichen je Zeile ausgegeben werden.
Bisher habe ich das Programm so erstellt, das er mir alle Zahlenwerte nebeneinander ausgebe, das passiert nacheinander.
Gibt es die Möglichkeit, alle 3 Werte gleichzeitig auszugeben?
Und wie erstelle ich am besten einen Befehl, der automatisch nach 15 ausgegebenen Werten einen Zeilenumbruch einfügt?
int i;
int Zahl;
bool first_loop = false;
void setup()
{
Serial.begin(9600);
Serial.println("\n ASCII-Tabelle:");
}
void loop() {
if (first_loop == false)
{
for (i = 0; i <= 47; i++)
{
Serial.print("Dezimal: ");
Serial.print(i);
Serial.print("\t");
delay(200);
}
Serial.print("\n");
for (i = 0; i <= 47; i++)
{
Serial.print("Hexa: ");
Serial.print(i, HEX);
Serial.print("\t\t");
delay(200);
}
Serial.print("\n");
for (i = 0; i <= 47; i++)
{
Serial.print("Zeichen: ");
Serial.print(i, byte());
Serial.print("\t");
delay(200);
}
}
first_loop = true;
}
Schau Dir mal snprintf an. Ansonsten einfach mitzählen und ein println machen.
Gruß Tommy
timschillert:
Vorsicht, die ersten Zeichen bis 1F sind Steuerzeichen.
Ansonsten geht Zeilenumbruch an eine Bedingung geknüpft:
int i;
int Zahl;
int umbruch = 15;
bool first_loop = false;
void setup()
{
Serial.begin(115200);
Serial.println("\n ASCII-Tabelle:");
}
void loop() {
if (first_loop == false)
{
for (i = 32; i <= 127; i++)
{
//Serial.print("Dezimal: ");
Serial.print(i);
Serial.print("\t");
//Serial.print("Hexa: ");
Serial.print(i, HEX);
Serial.print("\t");
//Serial.print("Zeichen: ");
Serial.print(i, byte());
delay(200);
if (i % umbruch == 0) {Serial.println();}else {Serial.print("\t");}
}
first_loop = true;
}
}
wno158
March 9, 2021, 7:56pm
4
Wie soll es denn aussehen?
32 20 33 21 ! 34 22 " 35 23 # 36 24 $ 37 25 % 38 26 & 39 27 ' 40 28 ( 41 29 ) 42 2A * 43 2B + 44 2C , 45 2D - 46 2E . 47 2F /
48 30 0 49 31 1 50 32 2 51 33 3 52 34 4 53 35 5 54 36 6 55 37 7 56 38 8 57 39 9 58 3A : 59 3B ; 60 3C < 61 3D = 62 3E > 63 3F ?
64 40 @ 65 41 A 66 42 B 67 43 C 68 44 D 69 45 E 70 46 F 71 47 G 72 48 H 73 49 I 74 4A J 75 4B K 76 4C L 77 4D M 78 4E N 79 4F O
80 50 P 81 51 Q 82 52 R 83 53 S 84 54 T 85 55 U 86 56 V 87 57 W 88 58 X 89 59 Y 90 5A Z 91 5B [ 92 5C \ 93 5D ] 94 5E ^ 95 5F _
96 60 ` 97 61 a 98 62 b 99 63 c 100 64 d 101 65 e 102 66 f 103 67 g 104 68 h 105 69 i 106 6A j 107 6B k 108 6C l 109 6D m 110 6E n 111 6F o
112 70 p 113 71 q 114 72 r 115 73 s 116 74 t 117 75 u 118 76 v 119 77 w 120 78 x 121 79 y 122 7A z 123 7B { 124 7C | 125 7D } 126 7E ~ 127 7F Oder blockweise?
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F ! " # $ % & ' ( ) * + , - . /
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F @ A B C D E F G H I J K L M N O
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F P Q R S T U V W X Y Z [ \ ] ^ _
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F ` a b c d e f g h i j k l m n o
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F p q r s t u v w x y z { | } ~
if (i % umbruch == 0) {Serial.println();}else {Serial.print("\t");}
was bedeutet das mit dem %?
aussehen soll es so:
DEZ: 0,1,2,3...15
Neuer Block
DEZ: 11,12,13...31
usw.
timschillert:
if (i % umbruch == 0) {Serial.println();}else {Serial.print("\t");}
was bedeutet das mit dem %?
Das ist modulo % - Arduino-Referenz
ABER:
aussehen soll es so:
DEZ: 0,1,2,3...15
Neuer Block
usw.
Das ist kompliziert...
wno158
March 9, 2021, 9:59pm
7
Aber man kann es hinbekommen:
DEZ : 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
HEX : 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F
CHAR: ! " # $ % & ' ( ) * + , - . /
DEZ : 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
HEX : 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
CHAR: 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
DEZ : 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
HEX : 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
CHAR: @ A B C D E F G H I J K L M N O
DEZ : 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
HEX : 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F
CHAR: P Q R S T U V W X Y Z [ \ ] ^ _
DEZ : 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
HEX : 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F
CHAR: ` a b c d e f g h i j k l m n o
DEZ : 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
HEX : 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F
CHAR: p q r s t u v w x y z { | } ~ Hier auf altertümliche Art z.B. mit diesem Sketch (da ist auch noch mit #if 0 wegdefinierter Code der ersten beiden Varianten drin):
// Forum
// https://forum.arduino.cc/index.php?topic=731490.0
//
// ASCII Tabelle händisch formatiert auf C-Art (also auf die maximal umständliche Weise)
const byte zeichenAbstand = 1;
const byte feldAbstand = 3;
const byte umbruchNach = 16;
const char* hexPrefix = " ";
const int startWert = 32;
const int endWert = 128;
void printAbstand(const int breite)
{
for (byte count = 0; count < breite; count++)
{
Serial.print(' ');
}
}
void printDezimal(const int wert)
{
if (wert >= 1000)
{
// drei Stellen maximal
Serial.print(F("..."));
return;
}
if (wert < 100)
{
Serial.print(' ');
}
if (wert < 10)
{
Serial.print(' ');
}
Serial.print(wert);
}
void printHex(const char* prefix, const int wert)
{
if (prefix != NULL)
{
Serial.print(prefix);
}
if (wert > 255)
{
// zwei Stellen maximal
Serial.print(F(".."));
return;
}
if (wert < 0x10)
{
Serial.print('0');
}
Serial.print(wert, HEX);
}
void printZeichen(const int wert)
{
if (wert < 32 || wert > 255)
{
// nicht druckbares Zeichen
Serial.print('.');
return;
}
Serial.print((char)wert);
}
// -------------------------------------------------------------------------------------
void setup()
{
delay(100);
Serial.begin(115200);
delay(100);
#if 0
// ASCII-Tabelle der Form DEZ HEX CHAR DEZ+1 HEX+1 nextChar ...
for (int i = startWert; i < endWert; i++)
{
printDezimal(i);
printAbstand(zeichenAbstand);
printHex(hexPrefix, i);
printAbstand(zeichenAbstand);
printZeichen(i);
printAbstand(feldAbstand);
if ( ((i + 1) % umbruchNach) == 0)
{
Serial.println();
}
}
Serial.println();
Serial.println();
// ASCII-Tabelle der Form DEZ DEZ+1... HEX HEX+1... CHAR CHAR+1...
for (int i = startWert; i < endWert; i += umbruchNach)
{
for (byte k = 0; k < umbruchNach; k++)
{
printDezimal(i + k);
printAbstand(zeichenAbstand);
}
printAbstand(feldAbstand);
for (byte k = 0; k < umbruchNach; k++)
{
printHex(hexPrefix, i + k);
printAbstand(zeichenAbstand);
}
printAbstand(feldAbstand);
for (byte k = 0; k < umbruchNach; k++)
{
printZeichen(i + k);
printAbstand(zeichenAbstand);
}
Serial.println();
}
Serial.println();
Serial.println();
#endif
// ASCII-Tabelle Dreizeilig
for (int i = startWert; i < endWert; i += umbruchNach)
{
Serial.print(F("DEZ : "));
for (byte k = 0; k < umbruchNach; k++)
{
printDezimal(i + k);
printAbstand(zeichenAbstand);
}
Serial.println();
Serial.print(F("HEX : "));
for (byte k = 0; k < umbruchNach; k++)
{
printHex(hexPrefix, i + k);
printAbstand(zeichenAbstand);
}
Serial.println();
Serial.print(F("CHAR: "));
for (byte k = 0; k < umbruchNach; k++)
{
Serial.print(F(" "));
printZeichen(i + k);
printAbstand(zeichenAbstand);
}
Serial.println();
Serial.println();
}
}
void loop()
{
}
Du willst eine Ausgabe die so aussieht?
ASCII-Tabelle:
dec: 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
hex: 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F
byte: ! " # $ % & ' ( ) * + , - . /
dec: 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
hex: 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
byte: 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
dec: 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
hex: 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
byte: @ A B C D E F G H I J K L M N O
dec: 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
hex: 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F
byte: P Q R S T U V W X Y Z [ \ ] ^ _
dec: 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
hex: 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F
byte: ` a b c d e f g h i j k l m n o
dec: 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
hex: 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E
byte: p q r s t u v w x y z { | } ~Viele Wege führen nach Rom. Das ist einer davon
// Forensketch basiert auf https://forum.arduino.cc/index.php?topic=731490.msg4921496#msg4921496
int Start = 32;
int Ende = 127;
int i = Start;
int umbruch = 15;
bool first_loop = false;
void setup()
{
Serial.begin(115200);
Serial.println("\n ASCII-Tabelle:");
}
void loop() {
if (first_loop == false)
{
while (i < Ende)
{
for (int x = 0; x <= 2; x++)
{
if (x == 0) Serial.print("dec: \t");
if (x == 1) Serial.print("hex: \t");
if (x == 2) Serial.print("byte: \t");
for (int y = i; (y <= (i + umbruch)) && (y < Ende); y++)
{
if (x == 0) Serial.print(y, DEC);
if (x == 1) Serial.print(y, HEX);
if (x == 2) Serial.print(y, byte());
if (y <= (i + umbruch) && (y < Ende)) Serial.print("\t");
}
Serial.println();
}
i += umbruch+1;
}
first_loop = true;
}
}
wno158:
Haste nicht
Kann ich im Übrigen auch:
ASCII-Tabelle:
dec: 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
hex: 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F
byte: ! " # $ % & ' ( ) * + , - . /
dec: 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
hex: 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
byte: 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
dec: 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
hex: 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F
byte: @ A B C D E F G H I J K L M N O
dec: 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
hex: 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F
byte: P Q R S T U V W X Y Z [ \ ] ^ _
dec: 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
hex: 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F
byte: ` a b c d e f g h i j k l m n o
dec: 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
hex: 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E
byte: p q r s t u v w x y z { | } ~
wno158
March 9, 2021, 10:14pm
10
my_xy_projekt:
Wo genau?
(Ich muss schlafen gehen - ich sehe es nicht)
wno158:
Ich hatte es rauskopiert. Im DEC gehts in der ersten Zeile bis 15 - in der zweiten fängts bei 11 an..
(Ich muss schlafen gehen - ich sehe es nicht)
Sei froh. Du kannst.
wno158
March 9, 2021, 10:31pm
12
Danke für die Aufklärung; brauche ich also nicht schon wieder eine neue Sehhilfe.
my_xy_projekt:
Viele Wege führen nach Rom. Das ist einer davon
danke, das sieht gut aus
habe gerade festgestellt, das mir die Zeichen nur als Zahlen ausgegeben werden. Woran kann das liegen?
timschillert:
An allem.
der Code ist der, den du hier vorgeschlagen hast.
int START = 0;
int ENDE = 255;
int UMBRUCH = 15;
bool first_loop = false;
void setup()
{
Serial.begin(9600);
Serial.println("\n\n ASCII-Tabelle:");
Serial.println("\n\n Ausgabe-Beginn: \n");
}
void loop() {
if (first_loop == false)
{
while (START < ENDE)
{
for (int ZEILE = 0; ZEILE <= 2; ZEILE++)
{
if (ZEILE == 0) Serial.print("dec: \t");
if (ZEILE == 1) Serial.print("hex: \t");
if (ZEILE == 2) Serial.print("byte: \t");
for (int i = START; (i <= (START + UMBRUCH)) && (START < ENDE); i++)
{
if (ZEILE == 0) Serial.print(i, DEC);
if (ZEILE == 1) Serial.print(i, HEX);
if (ZEILE == 2) Serial.print(i, byte());
if (i <= (START + UMBRUCH) && (i < ENDE))
Serial.print("\t");
}
Serial.print("\n");
}
START += UMBRUCH + 1;
}
first_loop = true;
Serial.print("\nAusgabe-Ende");
}
}
Habe ihn nur andere Variablennamen gegeben.
Im seriellen Monitor wird die Dezimal- und Hexadezimalzahl korrekt ausgegeben, nur die Zeichen werden als Zahl ausgegeben
timschillert:
Nein. Der ist doch erheblich abweichend.
int START = 0;
int ENDE = 255;
Informiere Dich über printable Zeichen und über Steuerzeichen.
ich habe jetzt nochmal den anderen Code probiert. Ändert nichts. Er gibt mir die Zeichen nur als Zahl aus.
Alles in Großbuchstaben verwendet man normalerweise für Konstanten und nicht für Variablen. Den Compiler interessiert das nicht. Das geht so oder so. Aber die meisten Programmierer denken dabei nicht an Variablen
nur die Zeichen werden als Zahl ausgegeben
Druckbare Zeichen werden korrekt anzeigt. Da sind aber auch viele drin die nicht dargestellt werden können. 0-31 sind Steuerzeichen. Und alles größer als 127 gehört nicht zur einfachen ASCII Tabelle
Serenifly:
bei mir werden nur Zahlen angezeigt. Hatte ein Update vom Mikrocontroller installiert (ESP32), vielleicht liegt es daran. Vorher hat es funktioniert
An eine while-Schleife hatte ich vorher auch gedacht., war mir aber unsicher mit der Umsetzung