UART Probleme
Im Unterforum Microcontroller - Beschreibung: Hardware - Software - Ideen - Projekte
| Autor |
|
|
|
BID = 530525
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
|
Moin,
Habe mir den Code nur einmal angeschaut, aber nicht auf Logik geprüft, vieeeeeeeeel zu umständlich.
Zitat :
|
Ich werde erst später den Code ausprobieren können.
|
Dann, entschuldigung, teste ihn doch erstmal, bevor du hier postest. Ich gebe mir auch mühe, funktionierenden Kode zu posten. Außerdem solltest du meine Hilfestellung ernst nehmen, oder es selber machen. Nicht umsonst schrieb ich
Zitat :
|
Bitte nicht vom String der einzelnen Bits ausgehen. Das wäre zwar möglich, aber blödsinnig .
|
und lieferte schon einen Prototypen
Zitat :
|
uint8_t *hex8(uint8_t number, uint8_t *dest);
|
Wozu mache ich mir die Mühe, wenn die Ratschläge in den Wind geblasen werden? 
Also, nochmal etwas netter:
die Zahlen 0-9 entsprechen auch den Zahlen 0x0-0x9, die Zahlen 10-15 entsprechen 0xA-0xF. Das tolle ist, dass also ein Zeichen (0-F) genau vier Bits repräsentiert. Also, die unteren vier Bits entsprechen einem Zeichen, die oberen vier dem anderen.
Und wir müssen darauf achten, dass darstellbare Zeichen (ASCII) dabei rauskommen. Ich mache das jetzt hier mal für das untere Nibble, du machst das höhere.
uint8_t Wert, Temp;
uint8_t Puffer[3]; /* danach fragte ich, wurde auch überlesen...*/
Puffer[0]=Puffer[1]='0'; /* mit ASCII 0 füllen */
Puffer[2]=0;
Temp=Wert & 0xF;
if(Temp < 0xA)
Puffer[1]=Temp + '0';
else
Puffer[1]=Temp + 'A' - 10;
/* und schon haben wir als Zeichen in Puffer[1] irgendwas zwischen 0-9 ^ A-F stehen.*/
Jetzt zum Lernen: versuche mal, mein Programm zu kommentieren. Benutze dazu am besten eine Tabelle mit ASCII-Zeichen. Bitte alles kommentieren, v.a., warum grade das gemacht wurde, wie es dort steht!
Das kann man auch, um später auch mehr als nur zwei Nibbles zu verarbeiten sehr stark auf diese Funktion verkürzen:
char hexval(unsigned char arg)
{
return ((arg&=0xF)<0x0A) ? (arg+'0') : (arg+'A'-10);
};
Sie gibt als Wert immer das ASCII-Zeichen der unteren vier Bits zurück. Das kann man iterativ sehr gut auf beliebig lange (rein theoretisch) Bytes anwenden.
Edit:
Zitat :
|
*hex='F';
*hex++;
|
*hex='F'; ist ja ok, aber was passiert in der nächsten Zeile? Du inkrementierst den Wert, nicht den Zeiger. Der Zeiger würde also weiterhin auf den gleichen Bereich zeigen, aber dort würde kein 'F' mehr stehen sondern ein 'G'  .
_________________
[ Diese Nachricht wurde geändert von: DonComi am 25 Jun 2008 17:43 ] |
|
BID = 530588
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
|
Für mich ist es einfach als purer Einsteiger ganz schwer gleich solche Funktionen zu programmieren.
So ich probiere einmal deinen CODE zu kommentieren:
uint8_t Wert, Temp; //deklaration WERT und TEMP in int
uint8_t Puffer[3]; // int feld mit 3 werten
Puffer[0]=Puffer[1]='0'; //Alle werte auf 0 setzen
Puffer[2]=0;
Temp=Wert & 0xF; //Temp wird mit 1111 verundet
if(Temp < 0xA) // Wenn der wert kleiner wie A ist dann
Puffer[1]=Temp + '0'; // der wert Temp wird auf Puffer[1] geschrieben
else //ansonsten
Puffer[1]=Temp + 'A' - 10; //wird A zu Temp in Puffer geschrieben und der
//wert um 10 reduziert
Mfg
Rambodischien
[ Diese Nachricht wurde geändert von: Rambodischien am 25 Jun 2008 21:10 ] |
|
BID = 530590
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Ja, recht gut, aber nicht immer so präzise.
Und jetzt schreibst du das ganze auf zwei Nibbles, also ein Byte um - Fertig.
_________________
|
BID = 530593
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
OK ich probier es:
| Code : |
uint8_t Wert, Temp;
uint8_t Puffer[3];
Puffer[0]=Puffer[1]='0';
Puffer[2]=0;
Temp=Wert & 0xF;
if(Temp < 0xA)
Puffer[1]=Temp + '0';
else //ansonsten
Puffer[1]=Temp + 'A' - 10;
Temp=Wert & 0xF0;
if(Temp <0xA0)
Puffer[2]=Temp +'0';
else
Puffer[2]=Temp+'A'-10;
|
|
Mfg
Rambodischien
|
BID = 531718
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Hallo Rambodieschen
Das sieht doch schonmal ganz gut aus, nur ist da noch ein logischer Fehler:
Zitat :
|
Temp=Wert & 0xF0;
if(Temp <0xA0)
Puffer[2]=Temp +'0';
else
Puffer[2]=Temp+'A'-10;
|
Du verundest Temp mit 0xF0, dabei kommt entweder 0 raus oder aber eine Zahl, die größer als 15 ist. Da darfst du jetzt aber keinen Offset mehr dazuaddieren, denn dann stimmen die ASCII-Zeichen nicht mehr.
Um das zu vermeiden, solltest du die Nibbles einfach tauschen oder den Wert durch 16 teilen oder alle Bits um vier Stellen zum LSB schieben. Daher wiederholt sich obiger Vorgang:
/* Code */
Temp=(Wert>>4) & 0x0F;
if(Temp <0xA)
Puffer[2]=Temp +'0';
else
Puffer[2]=Temp+'A'-10;
//Code
Du siehts, der Algorithmus ist sehr einfach. Man kann ihn eben noch so erweitern, dass man, wie ich das oben schon angedeutet habe, die Ermittlung des ASCII-Zeichens für das jeweils untere Nibble in eine Unterfunktion (static) packt. Man kann so nun weitere, darauf aufbauende Funktionen schreiben. Es wird dadurch möglich, quasi jeden Datentypinhalt hexadezimal darzustellen, ohne dass man den eigentlichen Algorithmus für jeden Typ neuschreibt.
Also, hiermal eine einfache, fertige Funktion, die die übergebene 8-Bit-Ganzzahl hexadezimal in den Puffer schreibt.
/* Code */
static uint8_t hexval(uint8_t arg)
{
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
};
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
*Strdest=hexval(value>>4);
*(Strdest+1)=hexval(value);
*(Strdest+2)=0;
return Strdest;
};
//Code
Mein C-Compiler für meine CPU in diesem Rechner benötigt für hexval(...) exakt 11 Maschieneninstruktionen resp. 23 Byte und für *hex8(...) 17 Maschieneninstruktionen bzw. 44 Byte.
Der C-Compiler für den AVR benötigt 8 Instruktionen bzw. 16 Byte und für die zweite Funktion 20 Instruktionen bzw. 40 Byte.
Würde man es selbst in ASM schreiben könnte man hier und da noch etwas Platz sparen. Alles in allem aber recht schonend .
/* Disassemblierung avr-gcc */
| Code : |
00000542 <hexval>:
542: 8f 70 andi r24, 0x0F ; 15
544: 8a 30 cpi r24, 0x0A ; 10
546: 10 f4 brcc .+4 ; 0x54c
548: 80 5d subi r24, 0xD0 ; 208
54a: 01 c0 rjmp .+2 ; 0x54e
54c: 89 5c subi r24, 0xC9 ; 201
54e: 99 27 eor r25, r25
550: 08 95 ret
00000552 <hex8>:
552: ff 92 push r15
554: 0f 93 push r16
556: 1f 93 push r17
558: f8 2e mov r15, r24
55a: 8b 01 movw r16, r22
55c: 82 95 swap r24
55e: 8f 70 andi r24, 0x0F ; 15
560: f0 df rcall .-32 ; 0x542
562: f8 01 movw r30, r16
564: 80 83 st Z, r24
566: 8f 2d mov r24, r15
568: ec df rcall .-40 ; 0x542
56a: f8 01 movw r30, r16
56c: 81 83 std Z+1, r24 ; 0x01
56e: 12 82 std Z+2, r1 ; 0x02
570: c8 01 movw r24, r16
572: 1f 91 pop r17
574: 0f 91 pop r16
576: ff 90 pop r15
578: 08 95 ret
|
|
/* Disassemblierung gcc für x86 */
| Code : |
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]xf,%eax
8048366: 3c 09 cmp [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]xf,%eax
8048366: 3c 09 cmp [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
08048377 <hex8>:
uint8_t *hex8(uint8_t value, uint8_t *Strdest)
{
8048377: 55 push %ebp
8048378: 89 e5 mov %esp,%ebp
804837a: 53 push %ebx
804837b: 8b 5d 0c mov 0xc(%ebp),%ebx
*Strdest=hexval(value>>4);
804837e: 8a 45 08 mov 0x8(%ebp),%al
8048381: c0 e8 04 shr [1code]
static uint8_t hexval(uint8_t arg)
{
8048360: 55 push %ebp
8048361: 89 e5 mov %esp,%ebp
return ((arg&=0xF) < 0xA) ? (arg+'0') : (arg+'A'-0xA);
8048363: 83 e0 0f and $0xf,%eax
8048366: 3c 09 cmp $0x9,%al
8048368: 77 05 ja 804836f <hexval+0xf>
804836a: 83 c0 30 add $0x30,%eax
804836d: eb 03 jmp 8048372 <hexval+0x12>
804836f: 83 c0 37 add $0x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
[/code1]x37,%eax
8048372: 0f b6 c0 movzbl %al,%eax
};
8048375: 5d pop %ebp
8048376: c3 ret
|
|
_________________
[ Diese Nachricht wurde geändert von: DonComi am 1 Jul 2008 10:09 ]
|
BID = 531816
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Vielen Dank für die ausführliche und gute Erklärung.
Ich glaube das habe ich kapiert und ich werde in der nächsten Zeit den Code ausprobieren.
Leider habe ich wieder ein paar Probleme.
1) Ich wollte die Größe des Feldes mit einem Modulo verknüpfen:
etwa so: while(sizeof(puffer)%8 != 0)
(Puffer ist ein Pointer auf ein Feld)
Nur leider funktioniert das nicht.
2)Wie kann ich ein char[] einfach umdrehen? Das heißt einfach dass das letzte Zeichen als erstes steht, das zweitletzte als zweites Zeichen usw. gibt es dafür irgendwelche Funktionen.
Danke
Mfg
Rambodischien 
|
BID = 531839
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Zitat :
|
1) Ich wollte die Größe des Feldes mit einem Modulo verknüpfen:
etwa so: while(sizeof(puffer)%8 != 0)
(Puffer ist ein Pointer auf ein Feld)
|
sizeof ist statisch, d.h. es wird nicht zur Laufzeit bestimmt, wie groß das Objekt ist.
Es ginge aber so:
uint8_t Feld[100];
sizeof Feld /* Ergebnis: 100 */
Das Ganze klappt nichtmehr, wenn ein Zeiger, der auf den Anfang eines Arrays zeigt,als Argument an sizeof übergeben wird!
Das erläutert dieses Beispiel:
uint8_t Feld[100];
uint8_t *feld = &Feld[0];
sizeof Feld: 100
sizeof feld: 2!
Außerdem macht es keinen Sinn, da sich wie gesagt sizeof statisch verhält und sich im Programm nie ändern würde. Der Compiler würde den Audruck sizeof(puffer)%8 zuende ausrechnen und ggf. die while-Bedingung als erfüllt bzw. unerfüllt erkennen und ggf. wegoptimieren.
2.
In der C-Library bin ich grade nicht fündig geworden, aber das dürfte mit deinem Kenntnisstand bereits selbst implementierbar sein .
Oder du googelst mal nach strreverse oder ähnliches.
_________________
|
BID = 531965
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Danke für die schnelle Antwort.
Noch eine Frage:
wenn ich in einem char[] 11000010100100010101 stehen habe möchte ich die ersten 4 Zeichen in ein Integerwert umwandeln damit ich nachher es in eine hex-Zahl umwandeln kann.
Wie mache ich so etwas?
Ich habe mir überlegt das ich wenn ich z.B.: 1010 habe von hinten nach vorne durchgehe und wenn ich an der zweiten stelle einen 1er habe den Integerwert +2 mache und wenn ich an der vierten Stelle einen 1er habe ich den Wert +8 rechne.
Gibt es hier eine bessere Lösung?
Mfg
Rambodischien
|
BID = 532068
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Der Ansatz ist doch gut.
OK, ich hoffe, du willst nicht erst eine Zahl in einen Binärstring umrechnen lassen und diesen wieder in einen Hexstring.
Zum Thema:
Jetzt verfolge doch mal deinen Plan und implementiere ihn! Nur so lernt man auch, es muss nicht immer gleich von Anfang alles so perfekt sein.
Die Wertigkeiten sind ja klar: 1, 2, 4, 8.
Das kann man sehr vielfältig und gewitzt machen. Mach mal nen Vorschlag, ich bewerte ihn dann.
_________________
|
BID = 532074
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Zitat :
DonComi hat am 2 Jul 2008 19:00 geschrieben :
|
Der Ansatz ist doch gut.
OK, ich hoffe, du willst nicht erst eine Zahl in einen Binärstring umrechnen lassen und diesen wieder in einen Hexstring.
|
Genau das ist meine Absicht 
Nun etwas genauer: Ich will eine SMS versenden über ein Handy dazu benötige ich den PDU-Mode.
Der Text der versendet werden soll muss folgendermaßen konstruiert werden.
Ein Ascii Zeichen hat 7 Bit und damit das 8te Bit nicht verschwendet wird wird vom nächsten Zeichen das Bit in die 8 Bit mit hinein genommen.
Und ich will das in C Programmieren.
Mfg
Rambodischien
|
BID = 532076
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Zitat :
|
Ein Ascii Zeichen hat 7 Bit und damit das 8te Bit nicht verschwendet wird wird vom nächsten Zeichen das Bit in die 8 Bit mit hinein genommen.
Und ich will das in C Programmieren.
|
Aber doch nicht über einen solchen Klimmzug.
Da eignen sich diverse Operationen auf Bitebene besser - vorallem wesentlich schneller.
Ansonsten, meine Antwort steht ja im vorigen Posting. 
_________________
|
BID = 532085
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Zitat :
DonComi hat am 2 Jul 2008 19:34 geschrieben :
|
Aber doch nicht über einen solchen Klimmzug.
Da eignen sich diverse Operationen auf Bitebene besser - vorallem wesentlich schneller.
|
Wie?
Trotzdem habe ich probiert was zu schreiben leider bekomme ich immer eine 0 zurück.
| Code : |
while(*strret)
{
for(i=0;i<4;i++)
{
if((strret+(y+i))==1)
{
if(i==3)
{
hex=hex+1;
}
else
{
hex=hex+0;
}
if(i==2)
{
hex=hex+2;
}
else
{
hex=hex+0;
}
if(i==1)
{
hex=hex+4;
}
else
{
hex=hex+0;
}
if(i==0)
{
hex=hex+8;
}
else
{
hex=hex+0;
}
}
else
{
hex=hex+0;
}
}
y=y+4;
strret=strret+4;
};
|
|
strret ist ein Pointer auf das Feld mit den 0er und 1er.
Mfg
Rambodischien
|
BID = 532135
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Hallo,
Das ist sinnfrei und braucht demnach auch nicht implementiert zu werden.
Zitat :
| | if((strret+(y+i))==1) |
Abgesehen davon, dass ich keine Ahnung habe, was y ist (keine Definition -> existiert für mich nicht ), wird der Inhalt des Strings nie 1, sondern höchstens '1'.
Du musst unterscheiden zwischen dem ASCII-Zahlenwert von dem Zeichen 1 und der Zahl 1!
Außerdem arbeitest du hier ja nicht mit dem Wert von strret, sondern mit dem Zeiger!
Die Klammerung ist auch überflüssig, da dort eine Summe gebildet wird.
Und wenn du schon iterierst, dann auch so, dass du nicht i tausendmal neu testen muss, das braucht alles Rechen- und Speicherresourcen. Entweder lässt sich der Iterator in den Algorithmus miteinbeziehen oder er dient nur dazu, einen Vorgang definiert oft abzuspielen.
Hier mal meine Version:
(achja, poste doch bitte den ganzen Quelltext bzw. zumindest die ganze Funktion, ist einfacher für mich, als nur einen Kodebrocken zu haben ):
uint8_t nibble_hex(uint8_t *quellstring);
uint8_t nibble_hex( uint8_t *quellstring)
{
uint8_t i, ret=0;
for (i=0;i<4;i++, quellstring++)
ret += (*quellstring-'0')<<i;
return ret;
};
Anstelle von
ret += (*quellstring-'0')<<i
kann man auch schreiben:
if(*quellstring=='1')
Da i von 0 bis 3 hochgezählt wird, wird jedesmal die Stellenwertigkeit des Summanden geändert. Sie beginnt bei 1, dann 2, 4 und 8 (1<<0 -> 1; 1<<1 -> 10b; 1<<2 -> 100b; 1<<3 -> 1000b)
Das hat den Vorteil, dass, wenn nicht sichergestellt ist, dass im String nur '0' und '1' vorkommt, das Programm nicht irgendeinen S***** macht. Im ersten Fall gehts nur gut, solange auch wirklich nur '1'en und '0'en sind. Ist dort ein anderes Zeichen, z.B. eine Terminierung, dann wird dort eine ganz andere Zahl stehen. Nimm also, wenn es sicherer sein soll, den letzen Vorschlag.
Außerdem sollte man testen, ob nicht eventuell der String schon zuende ist und man nicht im Nirvana ließt...
Daher wäre es sinnvoll, ja sogar für guten Stil zwingend, die for-Schleife so zu erweitern:
for (i=0; (i<4) && *quellstring ;i++, quellstring++)
Alles klar?
Dann kommentier mal meinen (kompletten) Kode aus! Dabei sollte man ürbigens nur Sachen kommentieren, die sich nicht selbst erklären. Also pointer++; ist klar, dass wird nicht kommentiert.
Was mir so aufgefallen ist bei dir:
* du vergisst manchmal, dass Pointer und Wert, auf den der Pointer zeigt, zwei unterschiedliche Dinge sind. Auf den Wert wird zugegriffen, wenn man den Pointer dereferenziert, und zwar eben mit dem *-Operator. Das hast du aber schon zum größten Teil alles richtig gemacht
* du bringt die Werte 1 und 0 und '1' und '0' manchmal durcheinander. '1' ist eine Zahl, im ASCII-Kode 49, '0' ist dort 48. Das muss unterschieden werden.
Hier als kleine Hilfe eine ASCII-Tabelle:
http://de.wikipedia.org/wiki/ASCII-Tabelle
Gut, soweit erstmal
Edit: achja, ich vergas. Es wird nur eine Zahl zwischen 0 und 15 errechnet. Wenn du ein Zeichen des Hexadezimalkodes zurückgeben willst, greife einfach auf die bereits bekannte kurze Funktion zurück.
static uint8_t hexval(uint8_t arg);
also, return hexval(ret);
_________________
[ Diese Nachricht wurde geändert von: DonComi am 3 Jul 2008 2:04 ]
|
BID = 532803
Rambodischien
Schreibmaschine
Beiträge: 1341
Wohnort: Österreich
|
Bin gerade dabei das Programm zu schreiben, aber leider habe ich wieder ein Problem:
Ich versuchen von dem char[] ( in dem 0010010 steht) in ein Integerwert umzuwandeln, das funktionier aber leider nicht. Ich habe es mit atoi probiert aber leider kommt immer 0 herraus.
Wenn ich das komplette Feld mit atoi(string) probiere kommt eine art hexcode heraus. Wenn ich nur atoi(string[1]) mache kommt immer 0 heraus egal was ich auch eingeben.
Mfg
Rambodischien
|
BID = 532943
DonComi
Inventar
Beiträge: 8605
Wohnort: Amerika
|
Och, komm schon.
atoi würde daraus eine entsprechend große Zahl machen, aber 8 Bit reichen nicht aus. ato geht ja auch von einer Basis 10 und nicht aus.
Das sind doch alles Fingerübungen. Dir sind die Stellenwertigkeiten der Bits bekannt. Teste acht mal auf '1', wenn es zutrifft addierst du die Stellenwertigkeit auf. Die Summe entspricht dann der Zahl.
_________________
|
|
Zum Ersatzteileshop
Bezeichnungen von Produkten, Abbildungen und Logos , die in diesem Forum oder im Shop verwendet werden, sind Eigentum des entsprechenden Herstellers oder Besitzers. Diese dienen lediglich zur Identifikation!
Impressum
Datenschutz
Copyright © Baldur Brock Fernsehtechnik und Versand Ersatzteile in Heilbronn Deutschland
gerechnet auf die letzten 30 Tage haben wir 19 Beiträge im Durchschnitt pro Tag heute wurden bisher 0 Beiträge verfasst
© x sparkkelsputz Besucher : 182415982 Heute : 479 Gestern : 7490 Online : 308 28.11.2024 6:13
0 Besucher in den letzten 60 Sekunden ---- logout ----viewtopic ---- logout ----
|
xcvb
ycvb
0.0772562026978
|
