-
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
-
Thread
DCF-Signal richtig auswerten
BCD volatile uint8_t MON_E:4; // Monat BCD volatile uint8_t MON_Z:1; // Monat BCD volatile uint8_t JAHR_E:4; // Jahr BCD volatile uint8_t JAHR_Z:4; // Jahr BCD
Echtzeit auszuwerten, also direkt beim Eintreffen. Dabei kann man auch gleich dieses beknackte packed-BCD in Binär umwandeln. Das erleichtert die Zahlenausgabe. Bit-Structs sind nur in Ausnahmefällen wirklich sinnvoll, erzeugen aber viel umständlichen Code. Ich hab auch ne LED mit an den MC gehängt, die
-
Thread
uC für 0,20€ CH552 / CH554 von WCH Billig Micro mit USB Funktion, Chip vorstellung
com.atcnetz.de.ch55xprogrammer sie ist derzeit nur mit bin Files kompatibel aber man kann die hex Dateien ja zu bin umwandeln, denke ist gant hilfreich wenn man mal schnell eine andere Firmware flachen will. Wird sich schon ein nutzen finden :D Dazu hier auch noch ein kurzes Video: https://youtu.be/rFKiSagsnLs
USB_STRING_UNDEFINED, 5, CDC_CS_INTERFACE, CDC_SUB_HEADER, // identifier header BCD_CDC & 0xFF,BCD_CDC >> 8,// 5, CDC_CS_INTERFACE, CDC_SUB_CALL_FUNCTION, // identifier Call Management 0x00,0x00, 4,CDC_CS_INTERFACE, CDC_SUB_ABSTRACT_CTRL, // identifier
-
Thread
Binär zu BCD / Binär zu 7 Segment Converter.
Mit drei 64k x 8 EPROMs kann man 16 Bit zu 5 BCD-Stellen (0..65535) dekodieren.
Wie Klaus sagte: gleich in BCD rechnen. Hier etwas Theorie: http://www.6502.org/users/dieter/bcd/bcd_0.htm http://www.6502.org/users/dieter/bcd2/bcd2_0.htm
-
Thread
Sharp GP2D02 Sensor auslesen mit CodeVisionAVR und einem AT90S8515
ich habe hier einen STK200(+) mit einem AT90S8515. Daran habe ich einen Sharp GP2D02 Sensor und eine BCD-Anzeige. Ich möchte nun mit dem GP2D02 eine Entfernung messen, die dann direkt an das Display ausgegeben wird. Wenn die Entfernung kleiner als 40cm ist, dann soll eine LED leuchten. Das ganze in C
habe hier einen STK200(+) mit einem AT90S8515. Daran habe ich einen Sharp GP2D02 Sensor und eine BCD-Anzeige. Ich möchte nun mit dem GP2D02 eine Entfernung messen, die dann direkt an das Display ausgegeben wird. Wenn die Entfernung kleiner als 40cm ist, dann soll eine LED leuchten. Das ganze in
-
Thread
Preprocessor Addition von zwei zahlen und Umwandlung in String
dem Prerocessor sagen, dass es zuerst addieren soll und das Ergebniss der Addition dann in String umwandeln?
schrieb im Beitrag #5430593: > Kein Mensch braucht einen String im Speicher, der die Firmware in > BCD-Darstellung mit führendem 0x beinhaltet. Reiht sich irgendwann hinter > 640k ought to be enough for everybody ein. ;-)
-
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
Belichten mit LCD 3D-Drucker
10622_10186_10621_10620_5723011_5722511,searchweb201603_1,ppcSwitch_5&algo_expid=a88bbb20-6e2d-4310-8bcd-2ef917ea25aa-0&algo_pvid=a88bbb20-6e2d-4310-8bcd-2ef917ea25aa&transAbTest=ae803_2&priceBeautifyAB=0 Backlight muss man selbst entfernen.
aus diesem Ding zu generieren. Um das zu probieren steht allerdings tatsächlich das Problem des umwandelns der Daten im Raum. Wie hast du das gelöst und macht das alles tatsächlich Sinn? Sind die Platinen für den Hobbybereich nutzbar, oder funktioniert es eher nicht so gut, wie erwartet? Wäre schön
-
Thread
7-Segmentanzeige mit TTL und Transistoren ansteuern
) so umformen, daß man sie mit NAND oder NOR Gattern implementieren kann. > Die Umwandlung von BCD auf Binär ist bereits erledigt. Hierfür habe ich > 5 mal den DM74LS00 und 4 mal den DM74LS10 verwendet. Was muß man von BCD auf Binär umwandeln? > Mein Problem ist nun die Ansteuerung der vier
Axel S. schrieb im Beitrag #5359804: > Was muß man von BCD auf Binär umwandeln? Das würde mich auch interessieren.
-
Thread
Taschenrechner in Hex/binär
angucken, dann siehst du, daß du mit der Darstellung nichts anfangen kannst. Zumal Taschenrechner mit BCD rechnen.
Mein Schulrechner Casio fx-9? kann dec/hex/oct/bin rechnen und umwandeln. Bisher hat das immer gereicht.. PS: der win7 Bordrechner kann das inzwischen auch. Der iOS interne auch. Kann mir nicht vorstellen dass $Unix da passen muss, zumal iOS ja ein BSD ist.
-
Thread
HEX Zahlen über UART STM32
Peter II schrieb im Beitrag #5213005: > ok wenn es bcd ist, dann kann man es auch ganz einfach machen Schreibt man vor BCD auch "0x"?
auch durch häufigeres Probieren nicht besser. Die Uhr erwarte die Eingabe wohl doch nicht als BCD sondern als hex, i.e. du musst deine ASCII-Eingabe erst einmal in hex umwandeln, als "14" -> 0x0e
-
Thread
Wärmezähler über optische M-Bus-Schnittstelle auslesen
@10,Return temp,°C,t_return,1 1,0A62bcd4@10,Temp diff,°C,t_diff,2 # [/c]
@10,Temp diff,°C,t_diff,2 1,0B26bcd6@1,Operating Hours,h,op_hours,0 1,0072bcd8@1,Serial Number,,sn,0 # [/code]
-
Thread
XOR-Verknüpfung 2er Zahlen
Zahlen müssen Ganzzahlen sein, sie müssen intern binär im Zweierkomplent dargestellt werden, nicht BCD und auch nicht als Zeichenstring, ... MfG Klaus
angegebenen Zahlen ausgegangen. Wer 9356, 2608 und 11964 flux auf dem Papier von dez zu bin umwandeln kann, ja der kann diese Aufgabe auf dem Papier lösen. ;-)
-
Thread
8 Bit nach 3x BCD umwandeln
Hallo, ich suche eine Möglichkeit ohne µC die Ausgabe eines 8 Bit Zählers (1,2,4,8,16... hier der 74HC590) nach 3x BCD ausgeben zu können, damit auf drei 7 Segment Anzeigen 0-255 angezeigt werden kann. Ein reiner BCD Counter zu kaskadieren reicht mir nicht aus, weil ich ja die reale Zählfolge der Ausgänge des 74HC590 zusätzlich brauche. Wie könnte man das am einfachsten realsieren? Im Internet habe ich leider nichts passendes dazu gefunden.
-
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
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
ASCI Low Byte + High Byte zu char umrechnen
Wenn ich das Modbus Telegram nun wieder einlese, möchte diese beiden Bytes wieder zu einem 0x48 umwandeln... aber wie? Kann mir vielleicht jemand auf die Sprünge helfen? LG, sunny
Nur mal so in die Runde geworfen: Vlt wurde das als BCD übertragen ...
-
Thread
STM32F103 Blue Pill Board: Verwendung der RTC mit 32khz
= 0x1; sTime.Minutes = 0x0; sTime.Seconds = 0x0; HAL_RTC_SetTime(&hrtc, &sTime, FORMAT_BCD); DateToUpdate.WeekDay = RTC_WEEKDAY_MONDAY; DateToUpdate.Month = RTC_MONTH_JANUARY; DateToUpdate.Date = 0x1; DateToUpdate.Year = 0x0; HAL_RTC_SetDate(&hrtc, &DateToUpdate, FORMAT_BCD
+ 3600; /* In Normalzeit UTC hh:mm:ss umwandeln */ ptr = localtime(&value); ptr->tm_isdst = true; } /* In eigene Struktur kopieren */ memcpy((void*)&mytime,ptr,sizeof(struct tm)); // mytime
-
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
ASCII nach Binär umwandlung => was muss ich da tun
durchstöbert aber leider nix passendes gefunden. Ich muss meine Daten 3 ASCII zeichen in ein Binärbyte umwandeln. Meine Werte sind immer kleiner gleich 255. Ich habe eine Routine gefunden die das kann, weiss aber nicht so recht wie ich dieser Routine die Daten übergeben muss damit ich hinterher mein binär
Bin1Mul10 ; ========= ; multiplies a 16-bit-binary by 10 ; Sub used by: AscToBin2, Asc5ToBin2, Bcd5ToBin2 ; In: 16-bit-binary in rBin1H:L ; Out: T-flag shows general result: ; T=0: Valid result, 16-bit-binary in rBin1H:L ok ; T=1: Overflow occurred, number too big ; Bin1Mul10: push rBin2H
-
Thread
8051 größer als Test: Carry vorher löschen ?
mich das Auxiliary Carry (?) (AC) zu interessieren ? Nö. Das wird nur bei dezimaler Rechnung im BCD-Format interessant.
werde einfach das Carry löschen bevor ich subtrahiere! Ich muss eh den Code neu schreiben und umwandeln da ich 2 NOPs drinhabe die ich noch rausbringen muss. Edit: Visualisierungen würden wirklich helfen, dieses im-Kopf-vorstellen schmerzt bisweilen ...
-
Thread
Division mit "krummen" 10
Allenfalls zu beginn weg in BCD rechnen ?
> Allenfalls zu beginn weg in BCD rechnen ? AVR's haben doch gar keine BCD Operationen.
-
Thread
NTC Temp. Sensor Parallel Schalten?
fertig gekauften Module, sondern kleine eigene Schaltungen, die das analoge Signal in ein digitales umwandeln und es danach in einen sinnvollen Temperaturwert umrechnen und diesen dann in "Anzeigbarer Form" (BCD o.ä.) ausgeben.
-
Thread
Float nach double konvertieren um es über I2C zu senden
Variablentyp ist, um die per NMEA-Sentence empfangenen Daten zu transportieren. Du könntest die Zahlen BCD-Kodiert über I2C transportieren. Das ist ziemlich kompakt und wäre ohne Verlust der Auflösung möglich.
Stellen. Wenn die Gegenstelle kein AVR ist, kann sie den Text dann *wahrscheinlich* korrekt in Double umwandeln.
-
Thread
Arduino: Problem beim casten
ausgegeben. Logisch. Casten bringt hier rein gar nichts. Du muss die Zahlen in einen String umwandeln. itoa() ist dein Freund. itoa(minute, text, 10); >const char text[] = {"hier gebe ich den anzuzeigenden text ein"}; >Keine Ausgabe auf Matrix-"Display": >const char text[] = {(char
Kommt aus einer RTC nicht "normalerweise" BCD raus? Dann wäre itoa() oder sprintf() jetzt nicht so ganz passend. Eher die nibble trennen und 0x30 dazu.
-
Thread
10bit Wert => 4x 7 Segment
umrechnen lassen und damit habe ich meinen Eingang > der CASE Abfrage. Auf gut deutsch also in eine BCD-Darstellung umwandeln. Und das für eine schnarchlangsame Anzeige fürs Auge? Da wäre mir ein ROM zu teuer. Mit dem Shift-Add-3 Verfahren geht das ressourcenschonender... Siehe dort: http://www.lothar-miller.de/s9y/archives/34-Vektor-nach-BCD.html http://www.lothar-miller.de/s9y/categories/44-BCD-Umwandlung
-
Thread
8 zu 3(1) zu 8 Multiplexen
Warum verschaltest du die Schalter nicht so, dass sie die Schalternummer in BCD übertragen? Schalter 1 - Low, Low, Low Schalter 2 - Low, Low, High Schalter 3 - Low, High, Low Schalter 4 - Low, High, High (...)
auch noch sparen... Ja, die Taster könnte der uC erfassen und "hinten raus" in Schaltzustände umwandeln. > > Wenn das so geht wie ich mir das vorstelle, habt ihr eine Empfehlung > wie ich da am besten rangeh. Hab noch nie einen MC programmiert > geschweige denn mich damit auseinander gesetzt
-
Thread
Dezimal in binär umwandeln
Dann kriege ich 5,5 raus und muss das anschliessend ins binäre umwandeln? 101,101?
unterschiedliche Möglichkeiten Die am häufigsten genutzte ist IEEE 754. Bevor es sich durchsetzte, war BCD-Code verbreitet. Dann gibt es noch Festkommazahlen. Du nimmst das Zweierkomplement von -2375 und dein Programm weiß, dass es das Komma um 3 Stellen verschieben muss. Und natürlich kannst du auch deine
-
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
32Bit Division mit inline Assembler
Bei der Assemblerprogrammierung kann ich Dir nicht weiterhelfen. Hier gibt es die BCD-Bibliothek "decNumber" mit der man die Grundrechenarten mit bis zu 34 Dezimalstellen bekommt: http://speleotrove.com/decimal/ Das ist reines C und die Beispielprogramme sollten Dein Problem abdecken
Assembler eine 64bit-Zahl (100Mio)² durch eine 32bit-Zahl (200Mio) und gibt sie an ein Display als BCD-Ziffern aus. Dazu habe ich Biruas 32/32-Bit-Routine auf 64/32 erweitert. Die Umformung Bin-BCD braucht mehr Platz als die Division.
-
Thread
Assembler wieder auf dem Weg nach vorn Gesperrt
Konfigurationsbits besteht, kann selbst ein simpel gestrickter C-Compiler fast 1:1 in Assembler umwandeln. Schwer vorstellbar, wo überhaupt Optimierungspotential herausschauen soll.
Bit-MS(R). Könntest du das jetzt bitte mal in kurzen, kompakten, übersichtlichen Assembler-Code umwandeln?
-
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
Basic für 80C31
Acorn Atom' und hatte schon ein schönes 'float'-Format mit vier Byte Mantisse, die allerdings nicht BCD (wie beim 8052-Basic) sondern binär kodiert war, was ca. zehn gültige Stellen liefern konnte; alles lief sehr schnell. Braucht jemand einen 'Acorn Atom' oder den Quellcode davon? ;-)
vielmals...so kann er das in meiner Entwicklungsumgebung auch ausführen und direkt in ein BIN File umwandeln
-
Thread
C Programmieren, 10er und 1er getrennt speichern
Da kommt aber ganz schön oft "BCD" vor, in den Kommentaren ;-)
wirklich. y = bin2bcd(31); // 0x13 bzw 19 z = bcd2bin(0x26); // 0x16 bzw 22
-
Thread
Ein Vorschlag zur Intervall-Arithmetik
Um dieses Problem zu umgehen, benutzt man für Intervall-Arithmetiken mit garantierter Genauigkeit BCD-codierte Fließkommazahlen. Welche Vorteile soll es denn gegenüber einem BCD-codierten Fließkommaformat haben? Beseitigt es das Wandlungsproblem?
800..+7ff Man muss nur noch tM (unsigned integer) und k-800 (signed integer) in Hex-Strings umwandeln.
-
Thread
PIC Assembler Division 8Bit
-------------------- BIN2BCD ; BIN zu BCD (00..99) clrf BCD_high BIN2BCD_1 movlw 0x0A ; BCD_high subwf BIN,W ; BIN - 10 btfss STATUS,C ;
funktionieren. Wenn du aber immer nur durch 10 dividieren willst, kannst du den Dividend auch in BCD umwandeln und dann einen Rechtsshift machen und das Ergebnis wieder in eine Binärzahl zurückwandeln. Der Vorteil wäre, das du den Rest dann auch gleich mit einsammeln kannst und keinen Rechenfehler
-
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
Pin-Code Abfrage
mehr.. Das LCD wird mit der Lib aus dem Mikrocontroller Tutorial betrieben, als Code lese ich BCD ein, die Funktion "Einlesen();" wandelt mit das dann in ein char Element um. Allerdings schaffe ich es nicht, den Code in ein int-Array zu packen ... Die Zahlen zeigt es richtig an, nur das Umwandeln
Terminierungszeichen '\0' wie bei C??? also eine Arraylänge von 5? Mit dem einlesen des Ascii, bzw BCD-Codes hatte ich keine Probleme, for schleifen hatte ich jede Menge ausprobiert, find ich auch am Besten, erst als es nicht funktioniert hatte hatte ich einen so umständlichen Text schreiben müssen..
-
Thread
std_logic_vector to integer
was das für Speicherwerte sind und was du mit dem counter vorhast. Evtl. kann man die Speicherwerte BCD-kodiert ablegen, dann hast du die Einer-/Zehnerdezimalstelle (oder man macht die BCD-Konvertierung beim lesen). Oder falls die Eingangswerte irgendeine Logik haben, das irgendwie geschickt auf den Speicher
output <= to_integer(unsigned(cnt)); Warum musst du eigentlich einen /Zähler/ in einen Integer umwandeln? Üblich ist es, mit dem Integer zu /zählen/ und dann als Port einen std_logic_vector zu nehmen...
-
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
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
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