#define BitMaskCLK 0b00100000 //pin 13 = Clock Pin; Pin 13 ist bit 5 von Port B #define BitMaskDAT 0b00001000 //pin 11 = Data Pin; Pin 11 ist bit 3 von Port B #define BitMaskLAT 0b00100000 //pin 5 = Data Pin; Pin 5 ist bit 5 von Port D #define BitMaskOE 0b01000000 //pin 6 = Data Pin; Pin 6 ist bit 6 von Port D #define BitMaskR1 0b00010000 //pin 4 = Data Pin; Pin 4 ist bit 4 von Port D #define BitMaskR2 0b10000000 //pin 7 = Data Pin; Pin 7 ist bit 7 von Port D #define BitMaskR3 0b00000001 //pin 8 = Data Pin; Pin 8 ist bit 0 von Port B #define BitMaskR4 0b00000010 //pin 9 = Data Pin; Pin 9 ist bit 1 von Port B #define BitMaskR5 0b00000100 //pin 10 = Data Pin; Pin 10 ist bit 2 von Port B //================================================================================================ // Bitmasken für Wörter /* * LEDArray[0][0] B00101000 // ES * LEDArray[0][1] B00101010 // IST * LEDArray[0][2] B10101010 // FÜNF * LEDArray[0][0] B01010100 LEDArray[0][1] B00000001 // ZEHN * LEDArray[0][1] B01010100 LEDArray[0][2] B01010101 // ZWANSIG * LEDArray[1][0] B10101000 LEDArray[1][1] B00000010 // DREI * LEDArray[1][1] B10101000 LEDArray[1][2] B10101010 // VIERTEL * LEDArray[1][0] B01000000 LEDArray[1][1] B00010101 // NACH * LEDArray[1][1] B01000000 LEDArray[1][2] B00000101 // VOR * LEDArray[2][0] B10101000 LEDArray[2][1] B00000010 // HALB * LEDArray[2][1] B10100000 LEDArray[2][2] B00101010 // ZWÖLF * LEDArray[2][0] B01010100 LEDArray[2][1] B00000001 // ZWEI * LEDArray[2][0] B01000000 LEDArray[2][1] B00000101 // EIN * LEDArray[2][1] B01010000 LEDArray[1][2] B01010101 // SIEBEN * LEDArray[3][0] B10100000 LEDArray[3][1] B00001010 // DREI * LEDArray[3][2] B10101010 // FÜNF * LEDArray[3][0] B01010100 // ELF * LEDArray[3][1] B01010101 // NEUN * LEDArray[3][2] B01010101 // VIER * LEDArray[4][0] B10100000 LEDArray[4][1] B00001010 // ACHT * LEDArray[4][1] B10100000 LEDArray[4][2] B00001010 // ZEHN * LEDArray[4][0] B01010000 LEDArray[4][1] B00010101 // SECHS * LEDArray[4][2] B01010100 // UHR */ //================================================================================================ /* Bitmasken für Zahlen X : 1 für Zehner und 2 für einer Oben: LEDArray[0][X] |= B00110000; LEDArray[1][X] |= B00110000; LEDArray[2][X] |= B00100000; // 1 LEDArray[0][X] |= B11101000; LEDArray[1][X] |= B10101100; LEDArray[2][X] |= B10101000; // 2 LEDArray[0][X] |= B11101000; LEDArray[1][X] |= B11101000; LEDArray[2][X] |= B10101000; // 3 LEDArray[0][X] |= B11001100; LEDArray[1][X] |= B11101000; LEDArray[2][X] |= B10000000; // 4 LEDArray[0][X] |= B10101100; LEDArray[1][X] |= B11101000; LEDArray[2][X] |= B10101000; // 5 LEDArray[0][X] |= B10101100; LEDArray[1][X] |= B11101100; LEDArray[2][X] |= B10101000; // 6 LEDArray[0][X] |= B11101000; LEDArray[1][X] |= B11000000; LEDArray[2][X] |= B10000000; // 7 LEDArray[0][X] |= B11101100; LEDArray[1][X] |= B11101100; LEDArray[2][X] |= B10101000; // 8 LEDArray[0][X] |= B11101100; LEDArray[1][X] |= B11101000; LEDArray[2][X] |= B10101000; // 9 LEDArray[0][X] |= B11101100; LEDArray[1][X] |= B11001100; LEDArray[2][X] |= B10101000; // 0 Unten: LEDArray[2][X] |= B00010000; LEDArray[3][X] |= B00110000; LEDArray[4][X] |= B00110000; // 1 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B11010100; LEDArray[4][X] |= B01011100; // 2 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B11010100; LEDArray[4][X] |= B11010100; // 3 LEDArray[2][X] |= B01000100; LEDArray[3][X] |= B11011100; LEDArray[4][X] |= B11000000; // 4 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B01011100; LEDArray[4][X] |= B11010100; // 5 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B01011100; LEDArray[4][X] |= B11011100; // 6 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B11000000; LEDArray[4][X] |= B11000000; // 7 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B11011100; LEDArray[4][X] |= B11011100; // 8 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B11011100; LEDArray[4][X] |= B11010100; // 9 LEDArray[2][X] |= B01010100; LEDArray[3][X] |= B11001100; LEDArray[4][X] |= B11011100; // 0 */ //================================================================================================ #include const int TastH = 17; //Taster für Stunden const int TastM = 16; //Taster für Minuten const int TastS = 15; //Taster für Set // const int UHRSCL = 19; //SCL zur Realtime Clock // wird nicht benötigt, da standart Schnittstelle // const int UHRSDA = 18; //SDA zur Realtime Clock const int BRT = 14; //Analog A0 für Helligkeitssensor // noch nicht eingepflegt const int CKCLK = 2; //Clock eingang von der Realtime Clock const int dataPin = 11; //Serial Daten Pin const int LEDOE = 6; //Output Enable der Schieberegister const int clockPin = 13; //Clock für Schieberegister const int latchPin = 5; //Letch enable für die Schieberegister const int CSEL1 = 4; //Reihe 1 const int CSEL2 = 7; //Reihe 2 const int CSEL3 = 8; //Reihe 3 const int CSEL4 = 9; //Reihe 4 const int CSEL5 = 10; //Reihe 5 const int DCF = 3; //Pin für DCF Signal const int DS1307Adr=0x68; // Adresse der Realtimeclock //=============================================================================================== int Stunden = 0; // Speicher für Stunden int Minuten = 0; // Speicher für Minuten int Sekunden = 0; // Speicher für Sekunden int StundenAnz = 0; // Speicher für die Ausgabe, denn ab viertel wird die nächste Stunde angezeigt bool ping = false; // Eine Sekunde vergangen bool TastH_ = 0; // Merker für Flankenerkennung beim einstellen der Uhr bool TastM_ = 0; bool TastS_ = 0; byte LEDArray[5][3] = { // Array für die Ausgabematrix { // also der Puffer für die Ausgabe B00000000, B00000000, B00000000 }, { B00000000, B00000000, B00000000 }, { B00000000, B00000000, B00000000 }, { B00000000, B00000000, B00000000 }, { B00000000, B00000000, B00000000 } }; //================================================================================================== void setup() { pinMode(latchPin, OUTPUT); pinMode(dataPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(LEDOE, OUTPUT); pinMode(CSEL1, OUTPUT); pinMode(CSEL2, OUTPUT); pinMode(CSEL3, OUTPUT); pinMode(CSEL4, OUTPUT); pinMode(CSEL5, OUTPUT); pinMode(CKCLK, INPUT_PULLUP); pinMode(TastS, INPUT_PULLUP); pinMode(TastH, INPUT_PULLUP); pinMode(TastM, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(CKCLK), INTSec, RISING); //CKCLK als Interrupt 0 startet INTSec() bei steigender Flanke Wire.begin(); SetzenDS1307(7,0x10); // Den Ausgang der Realtimeclock einschalten und 1Hz blinken einstellen HoleUhrzeit(); // Urzeit auslesen timetoword(); // Zeit als Wörter in den Puffer schreiben } //=================================================================================================== void loop() { if (digitalRead(TastS)) { // Ist der Set Taster nicht betätigt? if (TastS_) { // War er beim letzten noch betätigt? -> Fallende Flanke des Set Tasters TastS_ = 0; // Da nicht mehr betätigt den Merker für den nächsten Durchlauf zurück setzen SetzenDS1307(2,inttoBCD(Stunden)); // Schreiben der Zeit aus dem Zwischenspeicher in die RTC SetzenDS1307(1,inttoBCD(Minuten)); // RTC nimmt nur BCD, deshalb bei der Übergabe wandeln SetzenDS1307(0,0); // Sekunden werden beim loslassen auf 0 gesetzt HoleUhrzeit(); // Zeit neu einlesen timetoword(); // Ausgabepuffer der Zeit in Wörtern beschreiben } if (ping){ // Interupt? -> 1s vergangen Sekunden++; // Sekunden Puffer hochzählen ping = false; // Interupt Anzeiger zurücksetzen if (Sekunden >= 60){ // 1 Minute vergangen? HoleUhrzeit(); // Zeit von der RCT holen, da dort genauer timetoword(); // und wieder in den Puffer } } ausgabe(); // Puffer an die Schieberegister auschreiben } else { // Set Taster betätigt TastS_ = true; // Merker für die Flankenerkennung Set Taster if (!digitalRead(TastH)){ // Taster für Stunden (nicht nicht) betätigt ? if (!TastH_) { // War er vorher nicht betätigt? Stunden++; // Stunden um eins hochsetzen. if (Stunden >= 24){Stunden = 0;} // Stunden bei 24 zurück setzen TastH_ = true; // Merker Flankenerkennung Stunden Taster stzen } } else {TastH_ = false;} // wenn nicht betätigt, dann Flankenerkennung zurück setzen if (!digitalRead(TastM)){ // Taster für Minuten (nicht nicht) betätigt ? if (!TastM_) { // War er vorher nicht betätigt? Minuten++; // Minuten um eins hochsetzen. if (Minuten >=60){Minuten = 0;} // Minuten bei 60 zurück setzen TastM_ = true; // Merker Flankenerkennung Minuten Taster stzen } } else {TastM_ = false;} // wenn nicht betätigt, dann Flankenerkennung zurück setzen timetonumber(); // Ausgabepuffer diesmal mit den Zahlen beschrieben ausgabe(); // und auf die Register schicken } } //================================================================================================= void ausgabe(){ for (int i=0; i<5; i++){ // Schleife für die 5 Zeilen for (int j=0; j<3; j++){ // Schleife für die 3 Byte / 3 Schieberegister byte bitt = 1; //Variable die speichert, welches Bit wir gerade rausschreiben. Wir fangen beim LSB an. while(bitt) //Wenn wir die "1" 7 mal geschoben haben, ist sie vom LSB zum MSB gewandert. Beim 8. Mal ist das Bit dann links rausgeschoben und die Variable 0. Da 0 = false wird die Schleife abgebrochen { if (LEDArray[i][j] & bitt) //ist das aktuelle Bit des herauszuschiebenden Wertes gesetzt? PORTB |= BitMaskDAT; //ja: Datenpin HIGH else PORTB = (PORTB &~BitMaskDAT); //nein: Datenpin LOW. "PORT &~BitMaskDAT" gibt alle Pins so zurück wie sie waren, außer der der in BitMaskDat gesetzt ist wird 0. bitt <<= 1; //Schiebe die Merkervariable um eins nach links, jetzt ist das nächste Bit dran. PORTB ^= BitMaskCLK; // Toggle den Clockpin PORTB ^= BitMaskCLK; // Toggle den Clockpin, jetzt gab es auf jeden Fall eine pos. Flanke } } PORTD |= BitMaskOE; // OE Pin auf High PORTD |= BitMaskLAT; // Latchpin auf High switch(i){ // welche Zeile ist dran? case 0: PORTB = (PORTB &~BitMaskR5); PORTD |= BitMaskR1; break; // Zeile 5 aus, Zeile 1 an case 1: PORTD = (PORTD &~BitMaskR1); PORTD |= BitMaskR2; break; // Zeile 1 aus, Zeile 2 an case 2: PORTD = (PORTD &~BitMaskR2); PORTB |= BitMaskR3; break; // Zeile 2 aus, Zeile 3 an case 3: PORTB = (PORTB &~BitMaskR3); PORTB |= BitMaskR4; break; // Zeile 3 aus, Zeile 4 an case 4: PORTB = (PORTB &~BitMaskR4); PORTB |= BitMaskR5; break; // Zeile 4 aus, Zeile 5 an } PORTD ^= BitMaskLAT; //Toggle den Latchpin. Da er davor HIGH war, wird er jetzt wieder LOW. PORTD ^= BitMaskOE; //Toggle den OE Pin. Da er davor HIGH war, wird er jetzt wieder LOW. } } //================================================================================================= void SetzenDS1307(int Adr, int Daten) { // Schicken eies Bytes an dei RTC Wire.beginTransmission(DS1307Adr); // Initialisierung der Verbindung Wire.write(Adr); // zu beschriebende Register Adresse Wire.write(Daten); // Was soll geschieben werden Wire.endTransmission(); // Beenden der Übertragung } //================================================================================================= void HoleUhrzeit() { // Holen der aktuellen Uhrzeit von der RTC und schreiben in die internen Speicher Wire.beginTransmission(DS1307Adr); // Initialisierung der Verbindung Wire.write(0); // Mitteilung, dass die Uhrzeit geschickt werden soll Wire.endTransmission(); // Ende der Übertragung Wire.requestFrom(DS1307Adr,3); // Warten auf übertragung von der RTC if(Wire.available()==3) // Wenn 3 Byte übertragen wurden { Sekunden=BCDtoint(Wire.read()); // 1. Byte von BCD in int umwandeln und in Sekunden übernehmen Minuten=BCDtoint(Wire.read()); // 2. Byte von BCD in int umwandeln und in Minuten übernehmen Stunden=BCDtoint(Wire.read()); // 3. Byte von BCD in int umwandeln und in Stunden übernehmen } } //================================================================================================= void timetoword() { // Zuordung der Zeit zu den Wörtern StundenAnz = Stunden; // Merker für den Anzeige wert der Stunden auf die aktuelle Stunde if (Minuten > 12) StundenAnz++; // wenn die Minuten größer als 12 sind, also ab viertel ... -> Anzeigewert um 1 erhöhen clearANZ(); // Puffer leeren LEDArray[0][0] |= B00101000; // ES ausschreiben LEDArray[0][1] |= B00101010; // IST ausschreiben if (Minuten > 2) { if (Minuten > 7){ if (Minuten > 12){ if (Minuten > 17){ if (Minuten > 22){ if (Minuten > 27){ if (Minuten > 32){ if (Minuten > 37){ if (Minuten > 42){ if (Minuten > 47){ if (Minuten > 52){ if (Minuten > 57){ LEDArray[4][2] |= B01010100; // UHR ausschreiben wenn Minuten > 57 } else { // Minuten > 52 und kleiner 57 LEDArray[0][2] |= B10101010; // FÜNF LEDArray[1][1] |= B01000000; LEDArray[1][2] |= B00000101; // VOR } } else { // Minuten > 47 und kleiner 52 LEDArray[0][0] |= B01010100; LEDArray[0][1] |= B00000001; // ZEHN LEDArray[1][1] |= B01000000; LEDArray[1][2] |= B00000101; // VOR } } else { // Minuten > 42 und kleiner 47 LEDArray[1][0] |= B10101000; LEDArray[1][1] |= B00000010; // DREI LEDArray[1][1] |= B10101000; LEDArray[1][2] |= B10101010; // VIERTEL } } else { // Minuten > 37 und kleiner 42 LEDArray[0][0] |= B01010100; LEDArray[0][1] |= B00000001; // ZEHN LEDArray[1][0] |= B01000000; LEDArray[1][1] |= B00010101; // NACH LEDArray[2][0] |= B10101000; LEDArray[2][1] |= B00000010; // HALB } } else { // Minuten > 32 und kleiner 37 LEDArray[0][2] |= B10101010; // FÜNF LEDArray[1][0] |= B01000000; LEDArray[1][1] |= B00010101; // NACH LEDArray[2][0] |= B10101000; LEDArray[2][1] |= B00000010; // HALB } } else { // Minuten > 27 und kleiner 32 LEDArray[2][0] |= B10101000; LEDArray[2][1] |= B00000010; // HALB } } else { // Minuten > 22 und kleiner 27 LEDArray[0][2] |= B10101010; // FÜNF LEDArray[1][1] |= B01000000; LEDArray[1][2] |= B00000101; // VOR LEDArray[2][0] |= B10101000; LEDArray[2][1] |= B00000010; // HALB } } else { // Minuten > 17 und kleiner 12 LEDArray[0][0] |= B01010100; LEDArray[0][1] |= B00000001; // ZEHN LEDArray[1][1] |= B01000000; LEDArray[1][2] |= B00000101; // VOR LEDArray[2][0] |= B10101000; LEDArray[2][1] |= B00000010; // HALB } } else { // Minuten > 12 und kleiner 17 LEDArray[1][1] |= B10101000; LEDArray[1][2] |= B10101010; // VIERTEL } } else { // Minuten > 7 und kleiner 12 LEDArray[0][0] |= B01010100; LEDArray[0][1] |= B00000001; // ZEHN LEDArray[1][0] |= B01000000; LEDArray[1][1] |= B00010101; // NACH } } else { // Minuten > 2 und kleiner 7 LEDArray[0][2] |= B10101010; // FÜNF LEDArray[1][0] |= B01000000; LEDArray[1][1] |= B00010101; // NACH } } else { // Minuten kleiner 2 LEDArray[4][2] |= B01010100; // UHR } switch (StundenAnz){ // Welche Stunde soll angezeigt werden? case 0: LEDArray[2][1] |= B10100000; LEDArray[2][2] |= B00101010; break; // ZWÖLF case 1: LEDArray[2][0] |= B01000000; LEDArray[2][1] |= B00000101; if (Minuten > 2 | Minuten < 57) {LEDArray[2][1] |= B00010000;} break; // EIN(S) bei vollen Stunden eins sonst ein case 2: LEDArray[2][0] |= B01010100; LEDArray[2][1] |= B00000001; break; // ZWEI case 3: LEDArray[3][0] |= B10100000; LEDArray[3][1] |= B00001010; break; // DREI case 4: LEDArray[3][2] |= B01010101; break; // VIER case 5: LEDArray[3][2] |= B10101010; break; // FÜNF case 6: LEDArray[4][0] |= B01010000; LEDArray[4][1] |= B00010101; break; // SECHS case 7: LEDArray[2][1] |= B01010000; LEDArray[2][2] |= B01010101; break; // SIEBEN case 8: LEDArray[4][0] |= B10100000; LEDArray[4][1] |= B00001010; break; // ACHT case 9: LEDArray[3][1] |= B01010101; break; // NEUN case 10: LEDArray[4][1] |= B10100000; LEDArray[4][2] |= B00001010; break; // ZEHN case 11: LEDArray[3][0] |= B01010100; break; // ELF case 12: LEDArray[2][1] |= B10100000; LEDArray[2][2] |= B00101010; break; // ZWÖLF case 13: LEDArray[2][0] |= B01000000; LEDArray[2][1] |= B00000101; if (Minuten > 2 | Minuten < 57) {LEDArray[2][1] |= B00010000;} break; // EIN(S) bei vollen Stunden eins sonst ein case 14: LEDArray[2][0] |= B01010100; LEDArray[2][1] |= B00000001; break; // ZWEI case 15: LEDArray[3][0] |= B10100000; LEDArray[3][1] |= B00001010; break; // DREI case 16: LEDArray[3][2] |= B01010101; break; // VIER case 17: LEDArray[3][2] |= B10101010; break; // FÜNF case 18: LEDArray[4][0] |= B01010000; LEDArray[4][1] |= B00010101; break; // SECHS case 19: LEDArray[2][1] |= B01010000; LEDArray[2][2] |= B01010101; break; // SIEBEN case 20: LEDArray[4][0] |= B10100000; LEDArray[4][1] |= B00001010; break; // ACHT case 21: LEDArray[3][1] |= B01010101; break; // NEUN case 22: LEDArray[4][1] |= B10100000; LEDArray[4][2] |= B00001010; break; // ZEHN case 23: LEDArray[3][0] |= B01010100; break; // ELF case 24: LEDArray[2][1] |= B10100000; LEDArray[2][2] |= B00101010; break; // ZWÖLF } } //================================================================================================= void timetonumber() { // Beim Stellen soll die Zeit als Zahl ausgegeben werden clearANZ(); // Puffer leeren switch (Stunden - (Stunden/10)*10) { // Welche Stunde? Einer oben rechts ausgeben case 0: {LEDArray[0][2] |= B11101100; LEDArray[1][2] |= B11001100; LEDArray[2][2] |= B10101000; break;} // 0 oben case 1: {LEDArray[0][2] |= B00110000; LEDArray[1][2] |= B00110000; LEDArray[2][2] |= B00100000; break;} // 1 case 2: {LEDArray[0][2] |= B11101000; LEDArray[1][2] |= B10101100; LEDArray[2][2] |= B10101000; break;} // 2 case 3: {LEDArray[0][2] |= B11101000; LEDArray[1][2] |= B11101000; LEDArray[2][2] |= B10101000; break;} // 3 case 4: {LEDArray[0][2] |= B11001100; LEDArray[1][2] |= B11101000; LEDArray[2][2] |= B10000000; break;} // 4 case 5: {LEDArray[0][2] |= B10101100; LEDArray[1][2] |= B11101000; LEDArray[2][2] |= B10101000; break;} // 5 case 6: {LEDArray[0][2] |= B10101100; LEDArray[1][2] |= B11101100; LEDArray[2][2] |= B10101000; break;} // 6 case 7: {LEDArray[0][2] |= B11101000; LEDArray[1][2] |= B11000000; LEDArray[2][2] |= B10000000; break;} // 7 case 8: {LEDArray[0][2] |= B11101100; LEDArray[1][2] |= B11101100; LEDArray[2][2] |= B10101000; break;} // 8 case 9: {LEDArray[0][2] |= B11101100; LEDArray[1][2] |= B11101000; LEDArray[2][2] |= B10101000; break;} // 9 } switch (Stunden/10) { // Zehner oben Mitte ausgeben case 1: {LEDArray[0][1] |= B00110000; LEDArray[1][1] |= B00110000; LEDArray[2][1] |= B00100000; break;} // 1 case 2: {LEDArray[0][1] |= B11101000; LEDArray[1][1] |= B10101100; LEDArray[2][1] |= B10101000; break;} // 2 } switch (Minuten - (Minuten/10)*10) { // Welche Minute? Einer unten rechts ausgeben case 0: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B11001100; LEDArray[4][2] |= B11011100; break;} // 0 unten case 1: {LEDArray[2][2] |= B00010000; LEDArray[3][2] |= B00110000; LEDArray[4][2] |= B00110000; break;} // 1 case 2: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B11010100; LEDArray[4][2] |= B01011100; break;} // 2 case 3: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B11010100; LEDArray[4][2] |= B11010100; break;} // 3 case 4: {LEDArray[2][2] |= B01000100; LEDArray[3][2] |= B11011100; LEDArray[4][2] |= B11000000; break;} // 4 case 5: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B01011100; LEDArray[4][2] |= B11010100; break;} // 5 case 6: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B01011100; LEDArray[4][2] |= B11011100; break;} // 6 case 7: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B11000000; LEDArray[4][2] |= B11000000; break;} // 7 case 8: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B11011100; LEDArray[4][2] |= B11011100; break;} // 8 case 9: {LEDArray[2][2] |= B01010100; LEDArray[3][2] |= B11011100; LEDArray[4][2] |= B11010100; break;} // 9 } switch (Minuten/10) { // Zehner unten mitte ausgeben case 1: {LEDArray[2][1] |= B00010000; LEDArray[3][1] |= B00110000; LEDArray[4][1] |= B00110000; break;} // 1 case 2: {LEDArray[2][1] |= B01010100; LEDArray[3][1] |= B11010100; LEDArray[4][1] |= B01011100; break;} // 2 case 3: {LEDArray[2][1] |= B01010100; LEDArray[3][1] |= B11010100; LEDArray[4][1] |= B11010100; break;} // 3 case 4: {LEDArray[2][1] |= B01000100; LEDArray[3][1] |= B11011100; LEDArray[4][1] |= B11000000; break;} // 4 case 5: {LEDArray[2][1] |= B01010100; LEDArray[3][1] |= B01011100; LEDArray[4][1] |= B11010100; break;} // 5 } } //================================================================================================= void clearANZ() { // leeren des Puffers for (int i=0; i<5; i++){ // 5 Zeilen for (int j=0; j<3; j++){ // 3 Byte LEDArray[i][j] = B00000000; // auf 0 setzen } } } //================================================================================================= int inttoBCD(int BinWert) { // Wandlung Int zu BCD int Korrektur=(BinWert/1000)*0x600+(BinWert/100)*0x060+(BinWert/10)*0x006; // Korrekturwert errechnen return BinWert+Korrektur; // Gesamtwert ausgeben } //================================================================================================= int BCDtoint(int BCDWert) { // Wandlung BCD zu Int int WERT = BCDWert & 0x0F; // Separieren der Einer WERT = WERT + ((BCDWert/16)*10); // Zehner Wert in Hex und zu den einer dazu rechnen return WERT; // Zurückgeben } //================================================================================================= void INTSec(){ // Interrupt beim Ausgang der RTC ping = true; // Interrupt merker setzen }