BCD-Code auslesen



  • Hallo liebe Community!
    Ich benötige Hilfe bei meinem Programm. Ich habe bereits (so weit ich weiß) alle Foren durchsucht und bis jetzt noch nichts gefunden...

    Mein Ziel:
    Ich möchte ein BCD-codiertes "Signal" auslesen, wobei ich dieses über die Konsoleneingabe ersteinmal manuell simulieren will. Bei dem Signal stellt jedes Halbbyte eine Dezimalzahl dar, mit der dann die Uhrzeit und das Datum generiert wird. Dabei steht das erste Halbbyte für die Zehnerstelle der Sekunde, das zweite Halbbyte für die Einerstelle der Sekunde usw....
    Bsp.: 0101 0001 0010 0010 0001 0010 = 5 1 2 2 1 2 entspricht 12:22:51 als Uhrzeit, genauso fürs Datum.

    Mein Problem 1:
    Wenn ich in die Konsoleneingabe beispielsweise 1001 eingebe, erkennt das Programm die Eingabe alsDezimalzahl "1001", und nicht als Binärcode für "9". Wie kann ich dem Programm sagen, dass ich einen Binärcode eingebe?
    Mein Problem 2:
    Falls mein Programm dann also den Binärcode als solchen erkennt, wie kann ich dann die Halbbytes einem Wert zuweisen? Vllt immer nur alle 4 Stellen in eine Variable speichern oder den ganzen 01011010-Krempel dann mit << bzw- >> verschieben? Ich habe echt keine Idee...

    Ich hoffe, ich habe mich halbwegs verständlich ausgedrückt... 😅
    Den nachfolgenden Teil des Programms habe ich fertig, zum Testen der Ausgabe habe ich den Halbbytes ein paar Werte gegeben. Ich füge ihn einfach mal dazu...

    #include <stdio.h>
    #include <stdlib.h>
    
    /* run this program using the console pauser or add your own getch, system("pause") or input loop */
    
    int main(int argc, char *argv[]) 
    
    {
    														//0=immer0, x=0/1
    	int		ST, SU;						//Sekundenzehner, Sekundeneiner		0xxx xxxx 
    	int		MNT, MNU;					//Minutenzehner, Minuteneiner		0xxx xxxx
    	int		HT, HU;						//Stundenzehner, Stundeneiner		00xx xxxx
    	int		WU;						//Wochentag 1-7				0000 0xxx
    	int		DT, DU;						//Datum Tagzehner, Tageiner		00xx xxxx
    	int		MT, MU;						//Datum Monatzehner, Monateiner		000x xxxx
    	int		YT, YU;						//Datum Jahrzehner, Jahreiner		xxxx xxxx
    	
    	int		WA, WB;						//Wochentag MO-SO, WA für 1. Buchstaben und WB für zweiten Buchstaben
    	
    	//Nur zum Testen...
    	HT=1;
    	HU=0;
    	MNT=2;
    	MNU=7;
    	ST=4;
    	SU=5;
    	
    	WU=5;
    	DT=2;
    	DU=4;
    	MT=1;
    	MU=2;
    	YT=1;
    	YU=9;
    	
    //macht aus WU als Zahl den Wochentag als Abkürzung mit Ascii...
    	if (WU==1)
    	{ WA=77; 	//M
    	  WB=79;	//O
    	}
    	else if (WU==2)
    	{ WA=68;	//D
    	  WB=73;	//I
    	}	
    	else if (WU==3)
    	{ WA=77;	//M
    	  WB=73;	//I
    	}	
    	else if (WU==4)
    	{ WA=68;	//D
    	  WB=79;	//O
    	}
    	else if (WU==5)
    	{ WA=70;	//F
    	  WB=82;	//R
    	}
    	else if (WU==6)
    	{ WA=83;	//S
    	  WB=65;	//A
    	} 
    	else if (WU==7)
    	{ WA=83;	//S
    	  WB=79;	//O
    	}
    	else
    	{ WA=45;	//-
    	  WB=45;	//-
    	}
    	printf ("Uhrzeit: %d%d:%d%d:%d%d\n", HT, HU, MNT, MNU, ST, SU);
    	printf ("Datum: %c%c, der " , WA, WB);
    	printf("%d%d.%d%d.20%d%d\n", DT, DU, MT, MU, YT, YU);
    	return 0;	
    }
    

    In der Aussgabe steht jetzt:
    Uhrzeit: 12:37:30
    Datum: FR, der 30.11.2018

    Schon einmal vielen Dank fürs Durchlesen und die hoffentlich hilfreichen Antworten, ich weiß eure Zeit und Mühe sehr zu schätzen!!!
    MFG Bauerranger



  • Du kannst z.B. einen String einlesen und diesen dann mit stoi konvertieren:

    size_t err_pos;
    int i = stoi("1001", &err_pos, 2);
    // i ist 9
    

    Edit: sorry, ich hatte in C++ geantwortet. In C nimmst du stattdessen strtoul. Beispiel, sogar auch mit binary, hier: http://www.cplusplus.com/reference/cstdlib/strtol/



  • Zu 1: Was spricht denn dagegen, das umzurechnen und als Dezimalzahl einzugeben?
    Zu 2: Bei 8 Bit/Byte brauchst du eine Bitverschiebung und einen AND-Vergleich mit 0xF (15 maximaler Wert [alle Bits gesetzt], der mit 4 Bit dargestellt werden kann), um an die einzelnen Nibbles zu kommen.

    uint32_t value=.., nibble;
    // Nibble 0:
    nibble=value & 0xF;
    // Nibble 1:
    nibble=(value>>4) & 0xF;
    // Nibble 2:
    nibble=(value>>8) & 0xF;
    ...


  • @yahendrik sagte in BCD-Code auslesen:

    Zu 1: Was spricht denn dagegen, das umzurechnen und als Dezimalzahl einzugeben?

    Ich möchte ein eingehendes Binärsignal simulieren, welches vom Programm umgerechnet werden soll. Wenn ich nur die Dezimalzahlen eingeben müsste wäre das Ganze ja kein Problem....

    @yahendrik sagte in BCD-Code auslesen:

    Zu 2: Bei 8 Bit/Byte brauchst du eine Bitverschiebung und einen AND-Vergleich mit 0xF (15 maximaler Wert [alle Bits gesetzt], der mit 4 Bit dargestellt werden kann), um an die einzelnen Nibbles zu kommen.
    uint32_t value=.., nibble;
    // Nibble 0:
    nibble=value & 0xF;
    // Nibble 1:
    nibble=(value>>4) & 0xF;
    // Nibble 2:
    nibble=(value>>8) & 0xF;
    ...

    Ich bin leider ein viel zu großer C-Anfänger, deshalb weiß ich mit diesen Befehlen gar nichts anzufangen 😂
    Könntest du das vielleicht etwas ausführlicher nochmal beschreiben?
    Danke dir trotzdem für deine Hilfe!!!



  • @Bauerranger Dass es zum Testen ist, ist mir schon klar, aber
    854325121
    ist schneller eingegeben als
    110010111010111111011110000001
    Sollte eigentlich jeder Taschenrechner können.

    Um an die einzelnen Halbbytes zu kommen, solltest du sich mit Bitoperatoren beschäftigen. Es ist eigentlich recht einfach und auch immer das Gleiche:

    1. Wieviele Bits
    2. Was ist der höchste Wert, der mit dieser Bitanzahl dargestellt werden kann

    Der >> -Operator shiftet eine Zahl um N Stellen nach rechts (<< dementsprechend nach links), & ist ein bitweiser Vergleich.

    Nibble
    2    1    0
    ---------
    1000 1110 1011
    
    0xF = 15 = 1111b
    0: nibble=value & 0xF;
       1000 1110 1011 & 1111 -> 1011 (natürlich)
    1: nibble=(value>>4) & 0xF;
       Bitshift rechts um 4 Stellen 1011 fällt raus, von links werden Nullen nachgeschoben (hier aber egal)
       1000 1110 & 1111 -> 1110
    


  • Sooo, falls das noch jemanden interssiert: ich habe jetzt eine Lösung gefunden, die funktioniert! 😁
    Ich kann nun einen Binärcode hintereinanderweg mit einem anschließendem Enter eingeben und das Programm gibt mir das richtige Datum und Uhrzeit aus, yippieh! Jetzt muss ich das ganze nur noch für den PIC-Controller umschreiben und ich bekomme aus meinem DCF-Empfänger über UART meine Uhrzeit, vielleicht 😃 !
    Hier der fertige Programmcode:

    #include <stdio.h>
    #include <stdlib.h>
    
    
    /* run this program using the console pauser or add your own getch, system("pause") or input loop */
    
    int main(int argc, char *argv[]) 
    
    {
    	//Variablendeklaration	
    	int s[9], m[9], h[9], w[9], d[9], e[9], y[9];							//0=immer0, x=0/1
    	int		st, su;						//Sekundenzehner, Sekundeneiner		0xxx xxxx 
    	int		mt, mu;						//Minutenzehner, Minuteneiner		0xxx xxxx
    	int		ht, hu;						//Stundenzehner, Stundeneiner		00xx xxxx
    	int		wu;						//Wochentag 1-7				0000 0xxx
    	int		dt, du;						//Datum Tagzehner, Tageiner		00xx xxxx
    	int		et, eu;						//Datum Monatzehner, Monateiner		000x xxxx
    	int		yt, yu;						//Datum Jahrzehner, Jahreiner		xxxx xxxx
    	
    	int	WA, WB;							//Wochentag MO-SO
    	
    					
    	scanf ("%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d", &s[0], &s[1], &s[2], &s[3], &s[4], &s[5], &s[6], &s[7], &m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6], &m[7], &h[0], &h[1], &h[2], &h[3], &h[4], &h[5], &h[6], &h[7], &w[0], &w[1], &w[2], &w[3], &w[4], &w[5], &w[6], &w[7], &d[0], &d[1], &d[2], &d[3], &d[4], &d[5], &d[6], &d[7], &e[0], &e[1], &e[2], &e[3], &e[4], &e[5], &e[6], &e[7], &y[0], &y[1], &y[2], &y[3], &y[4], &y[5], &y[6], &y[7]);
    	
    
    	//erstes Sekundenhalbbyte von Binär in Dezimal
    	if (s[0]==0 & s[1]==0 & s[2]==0 & s[3]==0)
    	{	su=0;
    	}
    	else if (s[0]==1 & s[1]==0 & s[2]==0 & s[3]==0)
    	{	su=1;
    	}
    	else if (s[0]==0 & s[1]==1 & s[2]==0 & s[3]==0)
    	{	su=2;
    	}
    	else if (s[0]==1 & s[1]==1 & s[2]==0 & s[3]==0)
    	{	su=3;
    	}
    	else if (s[0]==0 & s[1]==0 & s[2]==1 & s[3]==0)
    	{	su=4;
    	}	
    	else if (s[0]==1 & s[1]==0 & s[2]==1 & s[3]==0)
    	{	su=5;
    	}
    	else if (s[0]==0 & s[1]==1 & s[2]==1 & s[3]==0)
    	{	su=6;
    	}
    	else if (s[0]==1 & s[1]==1 & s[2]==1 & s[3]==0)
    	{	su=7;
    	}
    	else if (s[0]==0 & s[1]==0 & s[2]==0 & s[3]==1)
    	{	su=8;
    	}
    	else if (s[0]==1 & s[1]==0 & s[2]==0 & s[3]==1)
    	{	su=9;
    	}
    	
    	//zweites Sekundenhalbbyte von Binär in Dezimal
    	if (s[4]==0 & s[5]==0 & s[6]==0 & s[7]==0)
    	{	st=0;
    	}
    	else if (s[4]==1 & s[5]==0 & s[6]==0 & s[7]==0)
    	{	st=1;
    	}
    	else if (s[4]==0 & s[5]==1 & s[6]==0 & s[7]==0)
    	{	st=2;
    	}
    	else if (s[4]==1 & s[5]==1 & s[6]==0 & s[7]==0)
    	{	st=3;
    	}
    	else if (s[4]==0 & s[5]==0 & s[6]==1 & s[7]==0)
    	{	st=4;
    	}
    	else if (s[4]==1 & s[5]==0 & s[6]==1 & s[7]==0)
    	{	st=5;
    	}
    	
    	//erstes Minutenhalbbyte von Binär in Dezimal
    	if (m[0]==0 & m[1]==0 & m[2]==0 & m[3]==0)
    	{	mu=0;
    	}
    	else if (m[0]==1 & m[1]==0 & m[2]==0 & m[3]==0)
    	{	mu=1;
    	}
    	else if (m[0]==0 & m[1]==1 & m[2]==0 & m[3]==0)
    	{	mu=2;
    	}
    	else if (m[0]==1 & m[1]==1 & m[2]==0 & m[3]==0)
    	{	mu=3;
    	}
    	else if (m[0]==0 & m[1]==0 & m[2]==1 & m[3]==0)
    	{	mu=4;
    	}	
    	else if (m[0]==1 & m[1]==0 & m[2]==1 & m[3]==0)
    	{	mu=5;
    	}
    	else if (m[0]==0 & m[1]==1 & m[2]==1 & m[3]==0)
    	{	mu=6;
    	}
    	else if (m[0]==1 & m[1]==1 & m[2]==1 & m[3]==0)
    	{	mu=7;
    	}
    	else if (m[0]==0 & m[1]==0 & m[2]==0 & m[3]==1)
    	{	mu=8;
    	}
    	else if (m[0]==1 & m[1]==0 & m[2]==0 & m[3]==1)
    	{	mu=9;
    	}
    	
    	//zweites Minutenhalbbyte von Binär in Dezimal
    	if (m[4]==0 & m[5]==0 & m[6]==0 & m[7]==0)
    	{	mt=0;
    	}
    	else if (m[4]==1 & m[5]==0 & m[6]==0 & m[7]==0)
    	{	mt=1;
    	}
    	else if (m[4]==0 & m[5]==1 & m[6]==0 & m[7]==0)
    	{	mt=2;
    	}
    	else if (m[4]==1 & m[5]==1 & m[6]==0 & m[7]==0)
    	{	mt=3;
    	}
    	else if (m[4]==0 & m[5]==0 & m[6]==1 & m[7]==0)
    	{	mt=4;
    	}
    	else if (m[4]==1 & m[5]==0 & m[6]==1 & m[7]==0)
    	{	mt=5;
    	}
    	
    	//erstes Stundenhalbbyte von Binär in Dezimal
    	if (h[0]==0 & h[1]==0 & h[2]==0 & h[3]==0)
    	{	hu=0;
    	}
    	else if (h[0]==1 & h[1]==0 & h[2]==0 & h[3]==0)
    	{	hu=1;
    	}
    	else if (h[0]==0 & h[1]==1 & h[2]==0 & h[3]==0)
    	{	hu=2;
    	}
    	else if (h[0]==1 & h[1]==1 & h[2]==0 & h[3]==0)
    	{	hu=3;
    	}
    	else if (h[0]==0 & h[1]==0 & h[2]==1 & h[3]==0)
    	{	hu=4;
    	}	
    	else if (h[0]==1 & h[1]==0 & h[2]==1 & h[3]==0)
    	{	hu=5;
    	}
    	else if (h[0]==0 & h[1]==1 & h[2]==1 & h[3]==0)
    	{	hu=6;
    	}
    	else if (h[0]==1 & h[1]==1 & h[2]==1 & h[3]==0)
    	{	hu=7;
    	}
    	else if (h[0]==0 & h[1]==0 & h[2]==0 & h[3]==1)
    	{	hu=8;
    	}
    	else if (h[0]==1 & h[1]==0 & h[2]==0 & h[3]==1)
    	{	hu=9;
    	}
    	
    	//zweites Stundenhalbbyte von Binär in Dezimal
    	if (h[4]==0 & h[5]==0 & h[6]==0 & h[7]==0)
    	{	ht=0;
    	}
    	else if (h[4]==1 & h[5]==0 & h[6]==0 & h[7]==0)
    	{	ht=1;
    	}
    	else if (h[4]==0 & h[5]==1 & h[6]==0 & h[7]==0)
    	{	ht=2;
    	}
    		
    	//erstes Wochentagshalbyte von Binär zu Dezimal
    	if (w[0]==1 & w[1]==0 & w[2]==0 & w[3]==0)
    	{	wu=1;
    	}
    	else if (w[0]==0 & w[1]==1 & w[2]==0 & w[3]==0)
    	{	wu=2;
    	}
    	else if (w[0]==1 & w[1]==1 & w[2]==0 & w[3]==0)
    	{	wu=3;
    	}
    	else if (w[0]==0 & w[1]==0 & w[2]==1 & w[3]==0)
    	{	wu=4;
    	}
    	else if (w[0]==1 & w[1]==0 & w[2]==1 & w[3]==0)
    	{	wu=5;
    	}
    	else if (w[0]==0 & w[1]==1 & w[2]==1 & w[3]==0)
    	{	wu=6;
    	}
    	else if (w[0]==1 & w[1]==1 & w[2]==1 & w[3]==0)
    	{	wu=7;
    	}
    	
    	//erstes Tageshalbyte von Binär zu Dezimal
    	if (d[0]==0 & d[1]==0 & d[2]==0 & d[3]==0)
    	{	du=0;
    	}
    	else if (d[0]==1 & d[1]==0 & d[2]==0 & d[3]==0)
    	{	du=1;
    	}
    	else if (d[0]==0 & d[1]==1 & d[2]==0 & d[3]==0)
    	{	du=2;
    	}
    	else if (d[0]==1 & d[1]==1 & d[2]==0 & d[3]==0)
    	{	du=3;
    	}
    	else if (d[0]==0 & d[1]==0 & d[2]==1 & d[3]==0)
    	{	du=4;
    	}	
    	else if (d[0]==1 & d[1]==0 & d[2]==1 & d[3]==0)
    	{	du=5;
    	}
    	else if (d[0]==0 & d[1]==1 & d[2]==1 & d[3]==0)
    	{	du=6;
    	}
    	else if (d[0]==1 & d[1]==1 & d[2]==1 & d[3]==0)
    	{	du=7;
    	}
    	else if (d[0]==0 & d[1]==0 & d[2]==0 & d[3]==1)
    	{	du=8;
    	}
    	else if (d[0]==1 & d[1]==0 & d[2]==0 & d[3]==1)
    	{	du=9;
    	}
    	
    	//zweites Tageshalbyte von Binär zu Dezimal
    	if (d[4]==0 & d[5]==0 & d[6]==0 & d[7]==0)
    	{	dt=0;
    	}
    	else if (d[4]==1 & d[5]==0 & d[6]==0 & d[7]==0)
    	{	dt=1;
    	}
    	else if (d[4]==0 & d[5]==1 & d[6]==0 & d[7]==0)
    	{	dt=2;
    	}
    	else if (d[4]==1 & d[5]==1 & d[6]==0 & d[7]==0)
    	{	dt=3;
    	}
    	
    	//erstes Monatshalbbyte von Binär zu Dezimal
    	if (e[0]==0 & e[1]==0 & e[2]==0 & e[3]==0)
    	{	eu=0;
    	}
    	else if (e[0]==1 & e[1]==0 & e[2]==0 & e[3]==0)
    	{	eu=1;
    	}
    	else if (e[0]==0 & e[1]==1 & e[2]==0 & e[3]==0)
    	{	eu=2;
    	}
    	else if (e[0]==1 & e[1]==1 & e[2]==0 & e[3]==0)
    	{	eu=3;
    	}
    	else if (e[0]==0 & e[1]==0 & e[2]==1 & e[3]==0)
    	{	eu=4;
    	}	
    	else if (e[0]==1 & e[1]==0 & e[2]==1 & e[3]==0)
    	{	eu=5;
    	}
    	else if (e[0]==0 & e[1]==1 & e[2]==1 & e[3]==0)
    	{	eu=6;
    	}
    	else if (e[0]==1 & e[1]==1 & e[2]==1 & e[3]==0)
    	{	eu=7;
    	}
    	else if (e[0]==0 & e[1]==0 & e[2]==0 & e[3]==1)
    	{	eu=8;
    	}
    	else if (e[0]==1 & e[1]==0 & e[2]==0 & e[3]==1)
    	{	eu=9;
    	}
    	
    	//zweites Monatshalbbyte von Binär zu Dezimal
    	if (e[4]==0 & e[5]==0 & e[6]==0 & e[7]==0)
    	{	et=0;
    	}
    	else if (e[4]==1 & e[5]==0 & e[6]==0 & e[7]==0)
    	{	et=1;
    	}
    	
    	//erstes Jahreshalbbyte von Binär zu Dezimal
    	if (y[0]==0 & y[1]==0 & y[2]==0 & y[3]==0)
    	{	yu=0;
    	}
    	else if (y[0]==1 & y[1]==0 & y[2]==0 & y[3]==0)
    	{	yu=1;
    	}
    	else if (y[0]==0 & y[1]==1 & y[2]==0 & y[3]==0)
    	{	yu=2;
    	}
    	else if (y[0]==1 & y[1]==1 & y[2]==0 & y[3]==0)
    	{	yu=3;
    	}
    	else if (y[0]==0 & y[1]==0 & y[2]==1 & y[3]==0)
    	{	yu=4;
    	}	
    	else if (y[0]==1 & y[1]==0 & y[2]==1 & y[3]==0)
    	{	yu=5;
    	}
    	else if (y[0]==0 & y[1]==1 & y[2]==1 & y[3]==0)
    	{	yu=6;
    	}
    	else if (y[0]==1 & y[1]==1 & y[2]==1 & y[3]==0)
    	{	yu=7;
    	}
    	else if (y[0]==0 & y[1]==0 & y[2]==0 & y[3]==1)
    	{	yu=8;
    	}
    	else if (y[0]==1 & y[1]==0 & y[2]==0 & y[3]==1)
    	{	yu=9;
    	}
    	
    	//zweites Jahreshalbbyte von Binär zu Dezimal
    	if (y[4]==0 & y[5]==0 & y[6]==0 & y[7]==0)
    	{	yt=0;
    	}
    	else if (y[4]==1 & y[5]==0 & y[6]==0 & y[7]==0)
    	{	yt=1;
    	}
    	else if (y[4]==0 & y[5]==1 & y[6]==0 & y[7]==0)
    	{	yt=2;
    	}
    	else if (y[4]==1 & y[5]==1 & y[6]==0 & y[7]==0)
    	{	yt=3;
    	}
    	else if (y[4]==0 & y[5]==0 & y[6]==1 & y[7]==0)
    	{	yt=4;
    	}	
    	else if (y[4]==1 & y[5]==0 & y[6]==1 & y[7]==0)
    	{	yt=5;
    	}
    	else if (y[4]==0 & y[5]==1 & y[6]==1 & y[7]==0)
    	{	yt=6;
    	}
    	else if (y[4]==1 & y[5]==1 & y[6]==1 & y[7]==0)
    	{	yt=7;
    	}
    	else if (y[4]==0 & y[5]==0 & y[6]==0 & y[7]==1)
    	{	yt=8;
    	}
    	else if (y[4]==1 & y[5]==0 & y[6]==0 & y[7]==1)
    	{	yt=9;
    	}
    	
    
    	//Wochentagszahl in Wochentagsabkürzung mit Asciizeichen
    	if (wu==1)
    	{ WA=77;
    	  WB=79;
    	}
    	else if (wu==2)
    	{ WA=68;
    	  WB=73;
    	}	
    	else if (wu==3)
    	{ WA=77;
    	  WB=73;
    	}	
    	else if (wu==4)
    	{ WA=68;
    	  WB=79;
    	}
    	else if (wu==5)
    	{ WA=70;
    	  WB=82;
    	}
    	else if (wu==6)
    	{ WA=83;
    	  WB=65;
    	} 
    	else if (wu==7)
    	{ WA=83;
    	  WB=79;
    	}
    	else
    	{ WA=45;
    	  WB=45;
    	}
    	
    	//Ausgabe
    	printf ("Uhrzeit: %d%d:%d%d:%d%d\n", ht, hu, mt, mu, st, su);
    	printf ("Datum: %c%c, der " , WA, WB);
    	printf("%d%d.%d%d.20%d%d\n", dt, du, et, eu, yt, yu);
    	return 0;	
    }
    

    Als Beispiele: (Der Binärcode ist natürlich spiegelverkehrt, 1.Byte=Sekunden,..., 7-Byte=Jahr, Eingabe OHNE Leerzeichen, anschließend Enter, 20XX für das Jahr nur die letzten beiden Ziffern)

    14:49:28 , 05 , 30.11.2018
    0001 0100 1001 0010 0010 1000 1010 0000 0000 1100 1000 1000 0001 1000
    (82:94:41 , 50 , 03.11.81)

    07:19:42 , 01 , 03.12.2018
    0100 0010 1001 1000 1110 0000 1000 0000 1100 0000 0100 1000 0001 1000
    (24:91:70 , 10 , 30.21.81)

    Vielleicht bringts ja jemandem etwas 😃
    Mfg Bauerranger



  • Ich weiß gar nicht, wo ich da anfangen soll... Das mag funktionieren, aber sieht mäßig elegant aus.

    Warum liest du überhaupt in int-Variablen ein, wenn du diese danach eh nur auf 0 und 1 vergleichst - nimm doch stattdessen einen char-Array. Warum haben deine int-Arrays Größe 9?

    Dann hast du sehr viele Wiederholungen im Code, insbesondere für jedes Halbbyte eine riesige if-Kette. Gibt es da nicht vielleicht eine Formel, wie man auf so einen Wert kommt (*1,*2,*4,*8 und +)? Kennst du Funktionen?

    Wochentage: Wer soll denn WA=77; WB=79; verstehen? Im Original hattest du wenigstens noch einen Kommentar. Aber warum nicht WA = 'M'; WB = 'O'; - das ist schon eine Nummer weniger schlecht lesbar. Noch besser wäre sowas:
    const char daynames[][3] = {"Mo", "Di", ...}; - also einfach ein Array mit den Abkürzungen.



  • @Bauerranger Lerne Bitoperationen in C ( &, |, ~, <<, >>)
    Dieser eine Tag ist sinnvoller verbracht, als deinen Code weiter zu nutzen.



  • 350 Zeilen "if/elseif/else"-Konstruktion...

    Der erste, der das recycled wird von mir höchstpersönlich mit einem Eimer Bytes erschlagen. 😉