-
Thread
BCD Darstellung einer Dezimalzahl in C
Tipp: Nimm Papier und Bleistift. Mach dir klar wie eine Zahl abgespeichert wird, und was eine BCD codierte Zahl überhaupt ist. Wenn du das auf dem Papier umwandeln kannst dann machs als Software. Noch ein Tipp Mache für jede Konvertierung eine eigene Funktion. Lagere die Ausgabe dann in eine
ansonsten legt er mir ja immer alles übereinander und die Werte von den vorigen gehen verloren. bcd = bcd << (i * 4); output = output | bcd; i++;
-
Thread
ASCII - BCD Wandler
in *vier* Bit, nicht in einem Byte (acht Bit). Du mußt also, um in C zu sprechen, um von ASCII zu BCD zu kommen u_char value[] = "15"; u_char bcd; bcd = value[0] - '0' << 4; bcd |= value[1] - '0'; rechnen. @all: Das mit der 7-Segment-Anzeige habe ich erst kürzlich für einen Tiny12 programmiert
Rufus, du meinst PACKED BCD.. http://www.danbbs.dk/~erikoest/bcd.htm ^^hier steht auch was drüber dave
-
Thread
Variable zu ASCII umwandeln in C
>>unsigned char und was steckt drin. eine bcd oder binärzahl? DS
deine Zahl mehrere Stellen hat, musst du zuerst die einzelnen Ziffern isolieren (Biärzahl zu einer BCD-Zahl umwandeln), bevor du jede Ziffer einzeln in ein ASCII-Zeichen konvertieren kannst. Ein allfälliges Minuszeichen muss natürlich auch beachtet werden. EDIT: Wenn du noch nie in C programmiert
-
Thread
DCF77, warum so komisch codiert?
Gabs beim 6502 nicht sogar ein BCD-Bit, um die Arithmetik umzustellen? --Thomas
DCF-77 war halt dafür gedacht, dezimal dargestellt zu werden. Da erscheint es unsinnig, Binärcode in BCD umwandeln zu müssen. Viel einfacher ist es, alles in BCD zu lassen, besonders da auch die Mikrocontroller der damaligen Zeit besondere BCD Befehle hatten. Sprich Du hast dann zum Beispiel 2 Zahlen addiert
-
Thread
7Bit binär an 2x 7Segment Anzeigen
Eingang hat und 2x A - G Signale ausgibt für zwei 7-seg. > Anzeigen? Gibts direkt nicht. Als Binär/BCD-Wandler gibts den 74185, aber der ist inzwischen obsolet. Man kann einen Binär/BCD-Wandler auch durch Kopplung eines Binär und eines BCD-Zählers aufbauen. Gruss Harald
http://de.wikipedia.org/wiki/BCD-Code Stichwort: "binär zu bcd umwandeln" http://www.mikrocontroller.net/topic/217877#2174011 http://www.mikrocontroller.net/topic/78266#652657 T.
-
Thread
C - double Wert aufteilen in Vor- und Nachkommastelle
LilaLauneBart schrieb im Beitrag #4326410: > Problem: > Moechte ich die Nachkommastelle umwandeln in integer, schneidet er mir > die fuehrenden Nullen ab. Nein. Ein int ist immer gleich lang, da kann nicht einfach was abgeschnitten werden. Ich vermute, daß du den Wert irgendwie ausgibst,
komischen Mischmasch überhaupt anfangen soll? Für Ziffernausgabe wäre - wie schon geschrieben - BCD günstiger, für Fixkommarechnung ein 64 Bit Integer. Und echtes 64bit IEEE-Float im FPGA möchte man eher selten haben.
-
Thread
IC für LED bwz LCD Anzeige gesucht
ps.: ist aber ein ganz normaler BCD Dekoder !!
...es gibt in der ttl reihe 74xx bausteine zum umwandeln von binär in bcd, allerdings musst du sie kaskadieren und bei acht bit ist das wirklich ein ttl grab, anschließend könntest du 7447 als umwandler von bcd zu 7 segment nehmen, aber 3 stück, da du
-
Thread
Zahlensysteme - Script
niederwertigen Nibbles größer als 9 wurde dem höherwertigen Nibble 6 hinzuaddiert (prinzipiell eine BCD Kodierung)
es weiter mit "Ziffern 6938", die "keine Zahl" sind. 6938 ist eine Zahl, egal ob hex oder dez oder BCD. Wenn Du Ziffern meinst, dann trenne sie per Komma. Oder meinetwegen auch per "." wie die Binärzahl davor. BCD ist ein Missbrauch der binären Zahlenrepräsentation eines Computers. Er hat entweder BCD-Befehle
-
Thread
BCD zu ASCII
Ich möchte eine BCD Zahl in ASCII umwandeln durch diesen Code ldi temp2, 0x30 ;Hex 30 in r16 laden mov temp1, tausender ;tausender Stelle nach r17 add temp1, temp2 ;Hex 30 zur taudender stelle
jemand einen Rat? Die Inhalte in den Registern tausender,hunderter,zehner und einer sind definitiv bcd Zahlen zwischen 0 und 9.
-
Thread
C# Dezimal Zahlen und BCD Zahlen
auf die 101 rechnen kann. Eine Formel gibt es da nicht. Aber einen Algorithmus. Stelle =1, BCD=0 solange Dezimalzahl > 0 Ziffer = Dezimalzahl % 10 Dezimalzahl = Dezimalzahl / 0 BCD = BCD + Ziffer * Stelle Stelle = Stelle * 16 Für zwei Stellen kannst du das auch direkt hin schreiben
im Beitrag #6109793: > Eine Formel gibt es da nicht. > Aber einen Algorithmus. > > Stelle =1, BCD=0 > solange Dezimalzahl > 0 > Ziffer = Dezimalzahl % 10 > Dezimalzahl = Dezimalzahl / 0 > BCD = BCD + Ziffer * Stelle > Stelle = Stelle * 16 > > Für zwei Stellen kannst du das auch
-
Thread
Voltmeter mit Atmega8 und auf LCD anzeigen
Dualen Wert des ADC auf den gewünschten Zielwert bringen. Bei dir z.B: Max-AD-Wert umwandeln in (int)1800. Entspricht dem Spannungswert in hundertstel Volt. 2. Umwandlung der Dualzahl in eine BCD-Zahl Programmbeispiele findest du hier in den Tuts. 3. Umwandeln der BCD-Zahl
wieder durch 256 geteilt. 4: beiden mittleren Bytes ergeben nun 0-1800. Diesen Wert als 4-stellige BCD Zahl anzeigen lassen. Falls gewünscht, die 1.Stelle auf 0 testen und statt 0 eine Leerstelle drucken und nach der 2. Stelle ein Komma(Punkt) drucken. PS: Ich kenne es zwar nicht persönlich
-
Thread
8 Bit binär zu ASCII
auch: [avrasm] ;input: R16 = 8 bit value 0 ... 255 ;output: R18, R17, R16 = ASCII-digits bcd: ldi r18, -1 + '0' _bcd1: inc r18 subi r16, 100 brcc _bcd1 ldi r17, 10 + '0' _bcd2: dec r17 subi r16, -10
E=0 Solange X>100 X=X-100 H=H+1 Solange X>10 X=X-10 Z=Z+1 E=X Will man binär in BCD umwandeln, so kann man das für 2 Stellen etwas abkürzen: X: Originalzahl Y: BCD-Version Y=0 Solange X>10 X=X-10 Y=Y+$10 Y=Y+X
-
Thread
AVR Dezimalzahlen in Binärzahlen umrechnen
multipliziert Ergebnis von der Originalzahl abziehen. Oder wenn es um die Umwandlung von einem Byte in 2 BCD-Nibble geht, kannst du auch in einer kleinen Schleife durch Subtraktion und Mitzählen umwandeln, bist der Wert kleiner als 10 ist. Beispiel: Enthalte dein Bye die Dezimalzahl 35 (0x23). Dann kannst
void incZeit (void) { sekunden = incBCD(sekunden); if(sekunden > 0x59) { sekunden = 0; minuten = incBCD(minuten); if(minuten > 0x59) { minuten = 0; stunden = incBCD(stunden); if(stunden > 0x23
-
Thread
VHDL Rechner
und die Zahl nur für die Anzeige umwandeln... Warum willst du es unbedingt im BCD-Code machen? BTW: der Code ist nicht als gutes Beispiel brauchbar... Sowas macht man nicht: zahl1 <= "00000000000000000"; Und die dreiseitige PS
ja aber is so ein BCD-Dual und Dual-BCD Code Wandler nich sehr aufwendig? Und da die Daten von der Tastatur so kommen und auch wieder als bcd ausgegeben werden isses da nich praktischer so zu rechnen?
-
Thread
32 bit arithmetik mit 8051
. das bekomm ich selbst noch hin. nun wäre es aber geil wenn ich z.b. die dezimalzahl direkt in bcd wandeln könnte, weil da wären ja genau 4 bit eine dezimalziffer und ich bräuchte immer nur 4 bits nehmen, das in dezimal umwandeln und dann entweder nochmal pro bcd-tetrade in einer speicherstelle zwischenspeichern
wenn alles fertig ist halt über die schnittstelle rausschicken. nur wie kann ich ne dualzahl in bcd umwandeln? jedenfalls so ne 32 bit dualzahl? mit 8 bit wäre das ganze ja leicht und 16 bit, könnte ich bestimmt auch noch irgendwie im acc und b register unterbringen aber 32 bit geht halt nicht.
-
Thread
Echtzeituhr mit DS1307 und Multiplexing 7 Seg Anzeige
Für den Anfang würde es auch ein BCD to 7 Segment machen. Dann kommt er mit einem 8Bit Port aus.
Maxim B. schrieb im Beitrag #5395175: > Einfach zwischen > BCD und binar umrechnen oder dazu noch eine Stunde addieren. 0,1 us? verstehe ich was nicht oder du? es geht nicht um BCD oder binär es geht darum wenn du die Uhrzeit liest aus der RTC, liest du
-
Thread
Analoge Werte an LED ausgeben
aber wie programmiert man so einen ADC - wie sage ich ihm, dass er die Spannung in einen Binärwert umwandeln soll. Das ist mein Problem - ich kenne die Befehle nicht und bin nicht fündig geworden.
Einerstelle vom Zwischenergebnis > gegeben und in die oberen 4 Bits die Zehnerstelle. Sozusagen ein BCD. > Fände ich leichter abzulesen. Ja, natürlich, das wäre für mich dann die Phase 2 gewesen. Erstmal einfach, dann komfortabel. Phase 1: ADC-Wert binär darstellen Phase 2: ADC-Wert in BCD
-
Thread
Binäre Codierung, Dezimal anzeigen
@rudi, nein sowas sucht er nicht, das ist nur die decodierung von bcd zu 7segment. zuvor benötigt er noch soetwas, ist aber kaum noch zu haben 74485 Binär-zu-BCD-Codeumsetzer, wenn er es in hardware machen will.... m.
und habe das eben genau mit den 74185 gelöst. Auch den umgekehrten Fall hatte ich schon. 3stellige BCD Code in Binärzahl umwandeln für einen DA Wandler zu steuern. ( Pegel und Frequenzeinstellung in einen Rohde&Schwarz SMLU ). Das ging mit den 74184 ganz gut. Rohde hatte dafür einen speziellen DA Wandler
-
Thread
binär in bcd(teile)
Rundschreiben? :-/ > es kommt die Zahl 213 nun sollte eine Zahl 2 sein eine 1 und eine 3 Binär nach BCD wandeln: http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung
/ können sollte. gibt es nicht eine einfachere möglichkeit, wie z.b. den binär code in dezimal umwandeln und die zahl zu teilen.
-
Thread
3 BCDs subtrahieren - asm
hi, ich hab 3 BCD ziffern die von 3 andren BCD ziffern abgezogen werden. beispielsweise 243-197. somit wäre 2 die 1.bcd 4. die 2. usw.. die liegen alle ungepackt in registern rum. wie ist das prinzip dafür, dass
Ja, eben BCD, das ist so einfach wie schriftliches Subtrahieren, immer schön Stelle für Stelle, Übertrag beachten, fertig. Man kanns natürlich auch in Binär umwandeln, aber es muss nicht sein.
-
Thread
Uhrzeit aus RTC auf LCD ausgeben
Variablen in einem String zu verketten und habe mich erstmal mit strcat() veruscht: [c] unsigned char BCD10; unsigned char BCD1; char string; char stringsek1[20]; char stringsek10[20]; BCD10 = ((TWDR & 0x70) >> 4); BCD1 = (TWDR & 0x0F); string = "Sekunden:"; itoa(BCD1,stringsek1,10
Bitoperationen noch ein wenig > 'schöner' gestalten, indem man sie in einem Makro versteckt.#define > BCD_HIGH(x) ( ((x) & 0x70) >> 4 ) > #define BCD_LOW(x) ( (x) & 0x0F ) > > .... > > lcd_string_xy( 0, 0, "Sekunden: "); > > lcd_char( BCD_HIGH( TWDR ) ); > lcd_char( BCD_LOW( TWDR
-
Thread
26 bit umwandlung in ASCII
Es ist ja R28 das LSB und nicht R30, also gehts so weiter: [C] ... ldi r19, -1 + '0' _bcd7: inc r19 subi r28, low(1000) ;-1000 sbci r29, high(1000) brcc _bcd7 ldi r18, 10 + '0' _bcd8: dec r18 subi r28, low(-100) ;+100 sbci r29, high(-100) brcs _bcd8
höchstwertigen Ziffer nur drei der vier Register behandelt werden: [pre] bin32_ascii: ldi r25, -1 + '0' _bcd1: inc r25 subi r29, byte2(1000000000) ;-1000,000,000 until overflow sbci r30, byte3(1000000000) sbci r31, byte4(1000000000) brcc _bcd1 ldi r24, 10 + '0' _bcd2: dec r24
-
Thread
Integerzahl stellen abschneiden
als BCD zählen?
der Zahl aber dann jedoch was abziehen .. dann muss ich die andere zahl, die abgezogen wird auch in BCD umrechnen oder? bzw BCD wieder in einen Bitvector, Integer oder sonstwas umwandeln... und das ist recht kompliziert oder?
-
Thread
Gray Code auswertung --> Schrittmotor Steuerung
nehme jetzt einen Absolutwertgeber. Dieser liefert mir einen Gray Code. Diesen Gray code werde ich umwandeln in einen BCD-code. BCD to Gray Code umwandler besteht meiner Meinung nach aus Exklusiv-Oder Verknüpfungen (XOR). (siehe Anhang) Wie würde dann diese realisierung mittls Logikschaltkreisen aussehen
Hallo, ich wollte keinen extra Beitrag aufmachen. Ich suche einen Gray to BCD decoder. Gibt es so einen Baustein und wie heißt er? Danke sulospace
-
Thread
Rechnung in VHDL
/s9y/categories/44-BCD-Umwandlung ich habs mir auch so gedacht aber wenn ich BCD verwerde dann kommen andere werte -___-
schrieb im Beitrag #3656481: > siehe Anhang. Du kannst einen 20 Bit Binärwert nicht in einem 20 Bit BCD Vektor unterbringen. Ausserdem musst du dir den BCD-Vektor hinterher natürlich als Hex-Wert /anzeigen/ lassen. Das ist Anfängermathematik mit Zahlensystemen...
-
Thread
Programmierung eines 80C552 mit Assembler
den Wert in Einer und Zehner zerlegen. Und mit MOVC A, @A+DPTR die Ziffer in den 7-Segment Code umwandeln. Peter
dec r0 ; djnz r3,mul_x2 ; djnz r4,bin2bcd ; ; sort packed bcd result to seperate memory locations mov r0,#30h ;load r0 with adress of BCD mov r1,#40h ;load r1 with result adress
-
Thread
Messwertkonvertierung, Rechnen in VHDL
dem was du machen willst. So. Genug der Theorie: du willst eine Binärzahl in Dezimalstellen umwandeln. Dein Stichwort ist BCD-Umwandlung. Sieh dir mal an, wie ich das mache und überlege dir, warum ich das so mache: http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung
schrieb im Beitrag #3954686: > So. Genug der Theorie: du willst eine Binärzahl in Dezimalstellen > umwandeln. Dein Stichwort ist BCD-Umwandlung. Sieh dir mal an, wie ich > das mache und überlege dir, warum ich das so mache: > http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung Vielen Dank
-
Thread
MSP430 Port abfragen
1.1. eine Folge von z.B. 8 Bits einlesen und prüfen ob diese Hi oder Low sind und diese später mit bcd Adressschaltern die an Port 2 angeschlossen werden vergleichen.Jedesmal wenn also eine abfallende Flanke kommt, soll Port 1.2 eingelesen werden.Ich habe mir gedacht, dass müsste doch am besten mit einer
Variable vom Typ Char dafür geeignet? 2. Muss ich die eingelesene binäre Folge z.B. 11001110 in Hex umwandeln damit ich diese mit den Schaltern vergleichen kann? Wenn ja, gibt es für das Wandeln einen Befehl. Wenn nein, welche Möglichkeit gibt es sonst? Danke Euch vorab.
-
Thread
konvertieren von integer zu dezimal
Nur zur Begriffsbestimmung: Du willst von /Integer/ nach /BCD/ umwandeln. (BCD = Binär codiertes Dezimalsystem) Vielleicht hilft dir das bei der Suche etwas weiter. EDIT: Allerdings gibt es da das Problem, dass du in 2 Bytes (uint16_t) nur 4 BCD-Stellen
Wozu brauchst Du denn packed BCD? Ich habs noch nie gebraucht. Wenn Du Zahlen anzeigen willst: http://www.mikrocontroller.net/topic/121526#new Peter
-
Thread
AD Wandler
gerade meine Bachelor Arbeit und habe folgende Probleme, ich muss 5 analoge Sensorsignale in einen BCD code umwandeln, zusätzlich kommt dazu das es kostengünstig sein soll aber zugleich schockresistent(lufttüchtig) Frage 1: geht es das ich die fünf Signale auf einen Multiplexer lege und dann in einen
Eingansbereich, Auflösung, Genauigkeit, Wandlerrate ? Und erzähl mal, was mit dem BCD hinten passieren soll. Peter
-
Thread
Long(Int) -> ASCII Umwandlung
Suche nach bin2bcd.
//***********************Zahl in BCD umrechnen u.via Uart ausgeben void Convert_Int_Bcd (int Zahl) { int Help; Help = Zahl / 1000;
-
Thread
DCF77 -> Verständnis BCD -> Uli-Radig's Code
BCD umgehen kann, muss man die BCD in Integer umwandeln. "%d" in der Formatanweisung bedeutet: Interpretiere den übergebenen Integerwert als Dezimalzahl. Damit wird noch einmal eine Umwandlungsroutine gestartet: INT to ASCII. Ich hätte es für geschickter gehalten, die BCD-Zahl gleich in ASCII umzuwandeln: (BCD & 0x0Fh) | 0x30 (BCD >> 4) | 0x30 und dann dem printf-String zwei char zu übergeben. viele grüße ralph
-
Thread
DS18B20
Routine, die den 16Bit-Temperaturwert (TH und TL), der vom DS18B20 ausgegeben wird, in einen 16Bit-BCD-Wert (4 Zeichen) umwandelt, damit ich damit über BCD zu 7-Segmentdecoder (4511 o.ä.) die Temperatur über eine Anzeige ansteuern kann. Ich verwende einen AT90S8515 und will über zwei 8-Bit-Ports 4 Decoder-ICs
Hallo Martin, bei Atmel gibt's eine AppNote zu BCD http://www.atmel.com/dyn/resources/prod_documents/doc0938.pdf mit Software in Assembler. Edgar
-
Thread
Integer zu 20Bit Char
jemand einen Ansatzpunkt geben wo ich da anfangen kann?! Spontan: Mit itoa() in einen String umwandeln und dann die Zeichen einzeln aufsplitten. PS: Bist du sicher dass du [c]char[] = {1,2,3,4,5}[/c] machen möchtest und nicht [c]char[] = {'1','2','3','4','5'}[/c] ?
zusammengeschrieben und funktioniert nun > super: ... Was du da gemacht hast, ist eine "Integer-nach-Packed-BCD" Uwandlung. Beim "Packed-BCD" sind jeweils in 1 Byte zwei BCD-Zahlen hineingepackt...
-
Thread
ITOA ohne Division/Modulo
decimal‑literal 0xhex‑decimal‑literal https://www.mikrocontroller.net/articles/AVR_Arithmetik#Bin%C3%A4r_zu_BCD_-_Umwandlung das ist für hex der erste Schritt, umwandeln in BCD Je nach Algorithmus erhält man einzelne Ziffern oder "gepacktes" BCD mit zwei Stellen in einem Byte. Dann muss man vor die Einzelstelle
mir BCD? Wenn die Zahlen in BCD vorliegen ist es natürlich einfach, '0'(48) zu addieren. Liegen die Zahlen aber als INT vor müssen sie trotzdem durch Division/Modulo in BCD umgerechnet werden. Die meisten Zahlen
-
Thread
ADC Wert am 2x16 Display ausgeben
Hallo, Eine "Binär nach BCD"-Routine findest du hier: http://www.avr-asm-tutorial.net/avr_de/rechnen/index.html Routinen zur Ausgabe auf LCDs findest du hier im Forum, oder auch auf der angegebenen Seite. Gruß Oliver
auf 2,5mV genau messen. Muß ich den ADC Wert dann nicht irgendwie durch 4 teilen, bevor ich ihn in BCD umforme, und auf dem Display ausgebe? Noch eine Frage: Brauche ich für eine BCD Ziffer ein komplettes Register, oder ist es auch möglich zwei BCD Ziffern in ein Register zu schreiben. Für Antworten
-
Thread
Umwandel in BCD und zurück
Wie kann ich in AVR-GCC ein Byte in BCD und zurück umwandeln? Gibts da ne fertige Funktion?
-
Thread
Port in 2 Byte aufteilen-Rechenoperation ausführen-Auf anderem Port ausgeben(Binär)
in 4 Bit wieder ausgeben? Wenn es nicht anders geht, müsste ich die Zahlen zuerst in Dezimal umwandeln, rechnen und wieder in Binär umwandeln! Mit freundlichen Grüßen Robin Wenert
OK! MEIN BCD-Code stimmt ganz sicher! Ich hab noch eine Frage: [code] config.PortA = Input config.PortB = Output BCDI1 = (PORTA & 0b00001111) BCDI2 = (PORTA
-
Thread
Algmeine Funktion
0b00001111; // maskieren der 1er Stelle ergebnis = (ergebnis >> 4) * 10 + (ergebnis & 0x0F); // umwandeln von BDC [/c] die 2. Zeile ist vollkommen überflüssig. (ergebnis >> 4) * 10 ist in deinem Fall immer null im Grunde läuft es auf das hier hinaus: [c] uint8_t getsm (uint8_t value_bcd) { uint8_t value_dec; value_dec = 10 * (value_bcd >> 4) + (value_bcd & 0x0f); return (value_dec); }; [/c]
-
Thread
STD_LOGIC_VECTOR --> 7 SEGMENT DISPLAY
realisiert werden? Du musst erst mal dein 12-Bit Vektor (0...1023) in die einzenlen Dezimalstellen umwandeln. Dafür bietet sich ein Binär-nach-BCD Wandler an. http://www.lothar-miller.de/s9y/archives/34-Vektor-nach-BCD.html http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung > Benötige ich
Design. Im folgenden erläutere ich kurz, wie ich es mir gedacht habe. Ich lese erst mit LM Vector2BCD Algorithmus den 12 Bit Vektor ein und extrahiere mir die 4 * 4 Bit BCD Werte. Portmaping der Komponente Vector2BCD [vhdl] Comp_BCD : Vector2BCD port map ( clk => clk, vector
-
Thread
LM75 mit Atmaga 8 auslesen und auf LCD ausgeben [c]
weiß halt nicht, wie die Temperatur in dem Register des LM 75 kodiert ist, weil es passt ja weder mit bcd-Code, noch wenn ich es als 8-Bit Dualzahl lese und in einenDezimalwert umrechne. Ich dachte eigentlich, dass die Umkodierung schon im lm75.c erfolgt? jedenfalls ist dort die Abfrage nach dem 15.Bit
Sprünge(0..16...32...48..64...80..96..112..0...16...usw..) Man muss diesen Ascii Code in Dezimal umwandeln. Du kannst mal deinen Code schicken. Hier ist meiner Gruss Marcus
-
Thread
Windows UEFI boot reparieren
ohne Dateisystem. Ich vermute das von dieser gestartet wird und hier der Bootmanager drauf ist. easyBCD weiß wie man da rankommt, das habe ich ja vom gebooteten Windows benutzt. Vom RE aus kann ich das easyBCD nicht starten weil das .NET haben will. Für die Möglichkeit das von USB/DVD zu starten will
Mode im BIOS eingeschaltet lassen weil Windows keinen EFI Start hat. Da müsste ich die MBR in GPT umwandeln.
-
Thread
CAN Abfrage von ASCII und Dezimalwerten
kapiert, aber soweit ich es verstehe, bekommst Du vom CAN 8 binäre Bytes, die Du in einen String umwandeln mußt, um diese weiterzuverarbeiten. Du mußt also alle 6 Datenbytes von Binärdarstellung in Ascii-Darstellung umwandeln. Das ging z.B. mit [c] sprintf(zielstring, "#i%i%i%i%i%i%i\n", candaten
kapiert, aber soweit ich es verstehe, > bekommst Du vom CAN 8 binäre Bytes, die Du in einen String umwandeln > mußt, um diese weiterzuverarbeiten. > > Du mußt also alle 6 Datenbytes von Binärdarstellung in Ascii-Darstellung > umwandeln. > Das ging z.B. mit > [c] > sprintf(zielstring, "#i%i%i%i%i
-
Thread
problem mit hex und int
Werden die Werte in BCD gezählt? Dann ist das eine recht einfache Sache, denn die Zehner-Stelle steht im high-Nibble und die Einer-Stelle im Low-nibble. Dann wäre die Zehnerstelle (wert >> 4) + 0x30 und die Einerstelle (
hallo, das ganze ist in c. ich nutze die rtc von ti. timerA als sekundentakt. dürfte bcd sein. gruß markus
-
Thread
Dual Zahlen für 7 Segment ausgabe umrechnen
0999752 0010 1000 1111 0000 0000 ?2,8,15,0,0 0167680 Die Umwandlung ist ein HEXtoBCD-Konverter (Suchfunktion, Zalenausgabe für Anzeigen). gruß hans
keine Ausssage getroffen, das es Dual ist habe ich >herraus finden müssen. Es häte ja auch einfach BCD, Aiken etz.. sein >können. Dual(Basis 2) ist ein Code wie BCD(Basis 10),Binär(Basis 16), oktal(Basis 8) usw., aber lassen wir das. CPU`s können nur Dual verarbeiten,oder? >Ich kann natürlich
-
Thread
24 Bit Umwandeln
, die drei Byte soll ich auf dem Display anzeigen lassen. Wie kann ich die 3 Byte in decimal umwandeln? vielen Dank Sabine
000010110101010101010111 > am Display soll 742743 gezeigt werden Also mit entsprechender Routine umwandeln. Ich habe hier auf dem 8051 skalierbare BIN-BCD-Routinen, für beliebig erweiterbare Zahlengrößen, das fluppt gut. printf brauche ich so gut wie gar nicht. Oben nannte schon einer was Routinen
-
Thread
Hex Seriennummer in Dec
den Wert als "normalen" Integer. Den musst du dann mit itoa() oder sprintf() in eine Zeichenkette umwandeln.
Falls ich das richtig verstanden habe, dann soll eine 16-stellige Hexadezimalzahl nach BCD umgewandelt werden. Das könnte man mit dem +3-Algorithmus machen: [c] #include <stdio.h> // add-3-algo void hex2bcd(char hex[], char dec[]) { int p, i, v, c; for(i=0; i<16; i++) {
-
Thread
Gleiche Zahlen in Dezimal und Hexadezimalsystem
google mal BCD-Code
http://de.unitjuggler.com/numbersystems-umwandeln-von-decimal-nach-bcd.html
-
Thread
C++ , Berechnung Fakultät mit BCD-Charakter-Arrays
BCD. Dazu kommt noch, dass BCD-Arithmetik vom AVR nicht direkt unterstützt wird, du also zusätzlich Rechenzeit und Flashspeicher brauchst, um damit zu arbeiten.
Ich würde außerdem nicht BCD verwenden, weil das fürs Rechnen echt Scheibenkleister ist. Besser ist es, in einem Byte ganz normal mit den Werten 0 bis 99 zu rechnen. Verschenkt zwar ein Bit, aber ist noch relativ bequem zum Umwandeln