Zwischenprüfung

// 20160825

#include"Wire.h"

void ZeigeUhrZufaellig(byte Zufall=0xFF);
void ZeigeTemperaturZufaellig(byte Zufall=0xFF);
void ZeigeIntermezzoZufaellig(byte Zufall=0xFF);

const char MaxGleich=60;
const char MaxUhrzeit=MaxGleich+17;
const char MaxTemperatur=MaxGleich+17;
const char MaxIntermezzo=18;


// Konstanten
const char LM75_I2C_SlaveAdr=0x4F;
const char DS1307_I2C_SlaveAdr=0x68;

const char ZeitRaffer=1; // zum testen
const char ZeitLupe=1;   // zum testen

// Nummern der Zeilen und Spalten
// 0 1 2 3 4 5 6
// 1
// 2
// 3
// 4
// 5 (automatischer Abstand bei hoch/runter schieben)

// Nummern der Leds
//  0  1  2  3  4  5  6
//  7  8  9 10 11 12 13
// 14 15 16 17 18 19 20
// 21 22 23 24 25 26 27
// 28 29 30 31 32 33 34

// Pinbelegung Arduino

const char AnzahlSpalten=7;
const char AnzahlZeilen=5;

const byte ZeilenPins[AnzahlZeilen]={7, 6, 5, 4, 3};
const byte DecoderPins[3]={8, 9, 10};
const byte TastenPin=11;
const byte WeckerPin=13;

const char AnzahlLeds=AnzahlSpalten*AnzahlZeilen;

const char Schreibzahl[] PROGMEM={ // wie von Hand geschrieben
  2,  1,  0,  7, 14, 21, 28, 29, 30, 23, 16,  9, 99, 99,  // 0 (99 = Dummy-Led)
  7,  1,  8, 15, 22, 28, 29, 30, 99, 99, 99, 99, 99, 99,  // 1
  0,  1,  2,  9, 16, 15, 14, 21, 28, 29, 30, 99, 99, 99,  // 2
  0,  1,  2,  9, 16, 15, 23, 30, 29, 28, 99, 99, 99, 99,  // 3
  0,  7, 14, 15,  2,  9, 16, 23, 30, 99, 99, 99, 99, 99,  // 4
  2,  1,  0,  7, 14, 15, 16, 23, 30, 29, 28, 99, 99, 99,  // 5
  2,  1,  0,  7, 14, 21, 28, 29, 30, 23, 16, 15, 99, 99,  // 6
  0,  1,  2,  9, 15, 22, 29, 99, 99, 99, 99, 99, 99, 99,  // 7
  9,  2,  1,  0,  7, 14, 15, 16, 23, 30, 29, 28, 21, 99,  // 8
 15, 14,  7,  0,  1,  2,  9, 16, 23, 30, 29, 28, 99, 99,  // 9
  2,  1,  0,  7, 14, 15, 16,  9, 99, 99, 99, 99, 99, 99,  // Grad
  2,  1,  7, 14, 21, 29, 30, 99, 99, 99, 99, 98, 99, 99}; // C

const char AnzahlEnfachSpiralen=9;
const char AnzahlDoppletSpiralen=4;
const char Spiralen[(AnzahlEnfachSpiralen+AnzahlDoppletSpiralen)*AnzahlLeds] PROGMEM={
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34, // waagerecht
  0, 7,14,21,28, 1, 8,15,22,29, 2, 9,16,23,30, 3,10,17,24,31, 4,11,18,25,32, 5,12,19,26,33, 6,13,20,27,34, // senkrecht
  0, 1, 2, 3, 4, 5, 6,13,12,11,10, 9, 8, 7,14,15,16,17,18,19,20,27,26,25,24,23,22,21,28,29,30,31,32,33,34, // waagerecht, hin und her
  0, 7,14,21,28,29,22,15, 8, 1, 2, 9,16,23,30,31,24,17,10, 3, 4,11,18,25,32,33,26,19,12, 5, 6,13,20,27,34, // senkrecht, hin und her
  0, 1, 2, 3, 4, 5, 6,13,20,27,34,33,32,31,30,29,28,21,14, 7, 8, 9,10,11,12,19,26,25,24,23,22,15,16,17,18, // spiralfoermig, erst waageecht
  0, 7,14,21,28,29,30,31,32,33,34,27,20,13, 6, 5, 4, 3, 2, 1, 8,15,22,23,24,25,26,19,12,11,10, 9,16,17,18, // spiralfoermig, erst senkrecht
  0, 7, 1,14, 8, 2,21,15, 9, 3,28,22,16,10, 4,29,23,17,11, 5,30,24,18,12, 6,31,25,19,13,32,26,20,33,27,34, // diaginal
  0, 1, 7,14, 8, 2, 3, 9,15,21,28,22,16,10, 4, 5,11,17,23,29,30,24,18,12, 6,13,19,25,31,32,26,20,27,33,34, // diagonal, hin un her
 22,15, 8, 9,16,23,30,29,28,21,14, 7, 0, 1, 2, 3,10,17,24,31,32,33,34,27,20,13, 6, 5, 4,11,18,25,26,19,12, // Schnecke Zehner, Einer
 35, 4,36, 5,37, 6,44,13,51,20,58,27,65,34,64,33,63,32,56,25,49,18,42,11,43,12,50,19,57,26,99,99,99,99,99, // Doppelspirale
 35, 6,36, 5,37, 4,44,11,51,18,58,25,65,32,64,33,63,34,56,27,49,20,42,13,43,12,50,19,57,26,99,99,99,99,99, // dito
 37, 4,36, 5,35, 6,42,13,49,20,56,27,63,34,64,33,65,32,58,25,51,18,44,11,43,12,50,19,57,26,99,99,99,99,99, // dito
 35,34,36,33,37,32,38,31,39,30,40,29,41,28,48,21,55,14,62, 7,61, 8,60, 9,59,10,58,11,57,12,50,19,51,18,17  // dito
};

const char CodeTab[] PROGMEM={
  0x1F, 0x11, 0x1F,   // 0
  0x12, 0x1F, 0x10,   // 1
  0x1D, 0x15, 0x17,   // 2
  0x11, 0x15, 0x1F,   // 3
  0x07, 0x04, 0x1F,   // 4
  0x17, 0x15, 0x1D,   // 5
  0x1F, 0x15, 0x1D,   // 6
  0x01, 0x1D, 0x03,   // 7
  0x1F, 0x15, 0x1F,   // 8
  0x17, 0x15, 0x1F,   // 9

  0x1E, 0x05, 0x1E,   // A
  0x1F, 0x15, 0x0A,   // B
  0x0E, 0x11, 0x11,   // C
  0x1F, 0x11, 0x0E,   // D
  0x1F, 0x15, 0x11,   // E
  0x1F, 0x05, 0x01,   // F

  0x00, 0x00, 0x00,   // Leerzeichen
  0x07, 0x05, 0x07,   // Grad
  0x0E, 0x11, 0x11,   // C
  0x00, 0x10, 0x00,   // Punkt
  0x00, 0x0A, 0x00,   // Doppelpunkt
  0x04, 0x04, 0x04,   // Minus
  0x0C, 0x12, 0x1C,   // a
  0x14, 0x1D, 0x10,   // i
  0x1F, 0x02, 0x1F,   // M
  0x0C, 0x12, 0x0C,   // o
  0x1E, 0x04, 0x02,   // r
  0x12, 0x15, 0x09,   // S
  0x14, 0x08, 0x14,   // x
  0x11, 0x1F, 0x11,   // I
  0x0F, 0x10, 0x0F,   // V
  0x1B, 0x04, 0x1B,   // X
  0x1F, 0x10, 0x10,   // L
  0x1F, 0x04, 0x1F,   // H
  0x0E, 0x11, 0x0E,   // 0, rund
  0x0F, 0x10, 0x10,   // l
  0x1F, 0x05, 0x1F,   // A, eckig
  0x1F, 0x10, 0x1F,   // U
  0x1F, 0x04, 0x1C,   // h
  0x1C, 0x04, 0x04,   // r, eckig
  0x01, 0x1F, 0x01,   // T
  0x0A, 0x0A, 0x0A,   // =
  0x1F, 0x0A, 0x11,   // K
  0x08, 0x04, 0x02,   // /
  0x1F, 0x08, 0x1F    // W
};

const char _A=10; // Hexzeichen
const char _B=11;
const char _C=12;
const char _D=13;
const char _E=14;
const char _F=15;

// Kodierung der Sonderzeichen

const char Leerzeichen=16;
const char Grad=17;
const char Celsius=18;
const char Punkt=19;
const char Doppelpunkt=20;
const char Minus=21;

// Kodierung der Zeichen für dem Wochentag
const char _a=22;
const char _i=23;
const char _M=24;
const char _o=25;
const char _r=26;
const char _S=27;

// für hexadezimale Anzeige
const char _x=28;

// roemische Ziffern
const char _I=29;
const char _V=30;
const char _X=31;

// Low und High
const char _L=32;
const char _H=33;

// Sonstige
const char _O=34;  // rund
const char _l=35;
const char _A2=36; // eckig
const char _U=37;
const char _h=38;
const char _r2=39; // eckig
const char _T=40;
const char Gleich=41; // z.B. für 20°C=68°F bzw. 20°C=193K
const char _K=42;
const char Geteilt=43; // z.B. für amrikanische Datumdarstellung
const char _W=44;
const char _O2=0;  // eckig
const char Ende=0x7F;

const char WochenTagTexte[7][2]={{_M, _o}, {_D, _i}, {_M, _i}, {_D, _o}, {_F, _r}, {_S, _a} , {_S, _o}};

const char MaxTage[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

const char WocheText[] PROGMEM={Punkt, _W, _O, _C, _H, _E, Ende};

const unsigned long MusterSpalten124[6]={0x442211, 0x112244, 0x142241, 0x412214, 0x0770, 0x7007};
const byte MusterSpalten25[6]={0x25, 0x52, 0x55, 0x22, 0x07, 0x70};
const byte MusterZeilen[2]={0x0A,0x15};

const char AnzahlVorhang=4;
const byte MusterVorhang[AnzahlVorhang][3]={
  {0x55,0x7F,0x7F},
  {0x77,0x00,0x7F},
  {0x77,0x00,0x00},
  {0x7F,0x00,0x00}};

const byte RomZiffern[13] = {0x00, 0x01, 0x05, 0x15, 0x09, 0x02, 0x06, 0x16, 0x56, 0x0D, 0x03, 0x07, 0x17};
//                                   I    II    III   IV     V    VI    VII   VIII   IX    X    XI    XII
// binär: 00=leer, 01=I, 10=V, 11=X
// z.B. 0x06 = 0b0110 = 01 10 = VI (von rechts nach links); 0x0D = 0b1101 = 11 01 = IX, 0x17 = 0b10111 = 01 01 11 = XII

const char UhrSpeicherAdr=0; // ab hier stehen die Zeidaten im DS1307
const char WeckerSpeicherAdr=8; // ab hier Weckerdaten im DS1307 speichern

const char LeerMuster=0;

const char KeinTrenner   =0b00000;  // beim Stellen
const char JahrTrenner   =0b00001;  // obere Punkt
const char MonatTrenner  =0b00010;
const char TagTrenner    =0b00100;
const char StundenTrenner=0b01000;
const char MinutenTrenner=0b10000; // unterer Punkt

const char WeckerWTagTrenner   =0b00011;  // 2 Punkte
const char WeckerEinAusTrenner =0b00101;
const char WeckerStundenTrenner=0b01001;
const char WeckerMinutenTrenner=0b10001;
const char WeckerAus=0; // = A
const char WeckerEin=1; // = E

const char Montag=0;
const char Dienstag=1;
const char Mittwoch=2;
const char Donnerstag=3;
const char Freitag=4;
const char Samstag=5;
const char Sonntag=6;
const char Wochentage=7;

const char KeinBalken=-1;
const char LeerZahl=-11;
const char GradCelsius=-23;

const int MaxAnzeigeDauer=2047;
const byte MaxBlinkCount=10;
const unsigned long MaxModusZeit=20000;
const byte Prellzeit=2;  // 2 Durchgaenge zum entrpellen
const char StellZeigeZeit=2;

const byte MaxWeckerSchellt=5; // max. 5 Minuten Weckerschellen

const byte ZeitStellModus=1; // Datum und Uhrzeit stellen
const byte WeckerStellModus=ZeitStellModus+6; // Wecker stellen

const char AuswahlTastenBit=0;
const char RueckTastenBit=1;
const char VorTastenBit=2;
const char XJ1_Bit=3; // zeige Datum zufällig: mit bzw. ohne Wochentag, mit bzw. ohne Jahr, Jahr 2 oder 4 stellig, mit Tag im Jahr, mit Kalenderwoche, amerikanisch
const char XJ2_Bit=4; // zeige Uhrzeit: zufällig: von links nach rechts, von rechts nach links, auf Kopf, in Spiegelschrift, binär, hexadezimal, oktal, römisch, usw.
const char XJ3_Bit=5; // zeige Temperatur zufällig: von links nach rechts, von rechts nach links, auf Kopf, in Spiegelschrift, binär, hexadezimal, oktal, usw.
const char XJ4_Bit=6; // zeige Intermezzo zufällig: Laufschriften, Drehungen, Verschiebungen, Hampelmann, Wellen, usw.
// XJ1 - XJ4 können kombiniert werden

const char TastenMaske=bit(AuswahlTastenBit)|bit(RueckTastenBit)|bit(VorTastenBit);
const char JumperMaske=bit(XJ1_Bit)|bit(XJ2_Bit)|bit(XJ3_Bit)|bit(XJ4_Bit);

const char TemperaturKorrektur=-2;

const byte AlleZeilen=0x1F;
const byte AlleSpalten=0x7F;
const byte ZehnerSpalten=0x07;
const byte EinerSpalten=0x70;

const char ZehnerPos=0;
const char TrennerPos=3;
const char EinerPos=4;
const char LinkeSpalte=0;
const char MitteSpalte=3;
const char RechteSpalte=6;
const char LinkeZehnerSpalte=0;
const char RechteZehnerSpalte=2;
const char LinkeEinerSpalte=4;
const char RechteEinerSpalte=6;

const char ObereZeile=0;
const char MitteZeile=2;
const char UntereZeile=4;
const char DummyZeile=5;

const char ZeichenBreite=3;
const char GrosserAbstand=ZeichenBreite+1;

const byte Links=0;
const byte Rechts=1;
const byte Hoch=2;
const byte Runter=3;
const byte Innen=4;
const byte Aussen=5;
const byte LinksOben=6;
const byte RechtsUnten=7;
const byte LinksUnten=8;
const byte RechtsOben=9;

const byte ZehnerZuerst=0;
const byte EinerZuerst=1;

const byte PunktAus=0;
const byte PunktEin=1;
const byte PunktKopier=2;

const char LSB=0;
const char MSB=7;

// const char x1=1;
const int MinVariLaufgeschwindigkeit=4;
const int MaxVariLaufgeschwindigkeit=10;

// Variablen
char HauptMatrix[8];    // sichtbare Matrix
char SchattenMatrix[8]; // versteckte Matrix zur Vorbereitung

char Stunden, Minuten, Sekunden;
char WTag, Tag, Monat, Jahr;
char Konfig;
boolean UhrWurdeGestellt;

// Speicher für 7 Wecker (für jeden Wochentag einen)
char WeckerMinuten[Wochentage], WeckerStunden[Wochentage], WeckerEinAus[Wochentage];
char WeckerWTag;
byte WeckerSchellt;

char Temperatur;
char Fahrenheit;
int Kelvin;

byte Modus;
unsigned long Moduszeit;
char StellDelta;
char Abbruch;

const byte Keinedauer=0;
byte Pausendauer;
byte Zeigedauer;
byte Laufgeschwindigkeit;

byte BlinkCount;
char AktTasten;
boolean PauseOk;
boolean Nullunterdrueckung;
char Balken;
byte Richtung;
byte ZufallWaagerecht1, ZufallWaagerecht2;
byte ZufallSenkrecht1, ZufallSenkrecht2;
byte Zufall4Richtungen, Zufall6Richtungen, Zufall10Richtungen;
byte ZufallZuerst, ZufallBoolean1, ZufallBoolean2, ZufallBoolean3;
byte ZufallArt16;
char ZufallsZahlen[AnzahlLeds];
char Zahl1, Zahl2;
char AlteZahl;
boolean ZeigeImmer;
char BildVersatz;

//---------------------------------------------------------------------------

void TastenAuswertung() {
  static byte PrellCount;
  static byte TastenCount;
  static boolean TastenSperre;
  static char PrellTasten;
  static char NeuTasten, AltTasten;

  AltTasten=NeuTasten;
  if (AktTasten!=PrellTasten) {
    PrellCount=0;
  } else {
    if (PrellCount<Prellzeit) {
      PrellCount++;
    } else {
      NeuTasten=AktTasten;
    }
  }
  PrellTasten=AktTasten;
  if ((NeuTasten&TastenMaske)>0) {
    if (WeckerSchellt>0) {
      WeckerSchellt=0;
      //???      digitalWrite(WeckerPin, LOW);
    } else {
      Moduszeit=millis();
      if (bitRead(NeuTasten, AuswahlTastenBit)==1 && bitRead(AltTasten, AuswahlTastenBit)==0) {
        TastenSperre=true;
        if (bitRead(NeuTasten, VorTastenBit)==0 && bitRead(NeuTasten, RueckTastenBit)==0) {
          if (Modus==0) {
            Modus=WeckerStellModus;
            WeckerWTag=WTag; // naechsten Wecker suchen
            if (Stunden>WeckerStunden[WTag] || (Stunden==WeckerStunden[WTag] && Minuten>WeckerMinuten[WTag])) {
              WeckerWTag++;
              if (WeckerWTag>Sonntag) WeckerWTag=Montag;
            }
          }
          else {
//            if (Modus==WeckerStellModus+1 && WeckerEinAus[WeckerWTag]==WeckerAus)
//              Modus=WeckerStellModus+4; // keine Zeit stellen, wenn Wecker aus
//            else Modus++;
            Modus++;
          }
        } else {
          Modus=ZeitStellModus;
        }
        Abbruch=true;
      }
      if (Modus>0 && TastenSperre==false) {
        if (TastenCount==0) {
          if (bitRead(NeuTasten, VorTastenBit)==1)   StellDelta=1;
          if (bitRead(NeuTasten, RueckTastenBit)==1) StellDelta=-1;
          TastenCount=20;
        }
        else {
          TastenCount--;
        }
      }
    }
  }
  else  {
    TastenCount=0;
    TastenSperre=false;
  }
  if (WeckerSchellt==0) digitalWrite(WeckerPin, LOW);
}

//---------------------------------------------------------------------------

void Multiplexen(int AnzeigeDauer) {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    char Muster=HauptMatrix[6-Spalte];

    // Dekoder (Spalte) ansteuern
    for (char Bit=0; Bit<3; Bit++) digitalWrite(DecoderPins[Bit], bitRead(Spalte, Bit));

    // Kathoden ansteuern, Zeilen einschalten
    for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) digitalWrite(ZeilenPins[Zeile], bitRead(Muster, Zeile));
    delayMicroseconds(AnzeigeDauer);

   // Zeilen ausschalten
    for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) digitalWrite(ZeilenPins[Zeile], LOW);
    delayMicroseconds(MaxAnzeigeDauer-AnzeigeDauer);

    // Tasten/Jumper einlesen
    bitWrite(AktTasten, Spalte, !digitalRead(TastenPin));
  }
}

//---------------------------------------------------------------------------

void ZeigeMatrix(byte ZeigeDauer) {
  int AnzeigeDauer=2*analogRead(A0);
  if (WeckerSchellt>0) AnzeigeDauer=MaxAnzeigeDauer-1;
  AnzeigeDauer=constrain(AnzeigeDauer,1,MaxAnzeigeDauer-1);
  AktTasten=0;
  while (ZeigeDauer>0 && Abbruch==false) {
    Multiplexen(AnzeigeDauer);
    TastenAuswertung();
    ZeigeDauer--;
  }
  BlinkCount++;
  if (BlinkCount>MaxBlinkCount) BlinkCount=0;
}

//---------------------------------------------------------------------------

boolean GeaendertMatrix() {
  static char VergleichsMatrix[8];
  boolean Unterschied=false;
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    if (HauptMatrix[Spalte]!=VergleichsMatrix[Spalte]) Unterschied=true;
    VergleichsMatrix[Spalte]=HauptMatrix[Spalte];
  }
  return Unterschied;
}

//---------------------------------------------------------------------------

void ZeigeMatrixLaufgeschwindigkeit() {
  if (ZeigeImmer || GeaendertMatrix()) ZeigeMatrix(Laufgeschwindigkeit);
}

//---------------------------------------------------------------------------

void ZeigeMatrixLaufgeschwindigkeit(boolean Zeigen) {
  if (Zeigen==true) ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeMatrixZeigedauer() {
  ZeigeMatrix(Zeigedauer);
}

//---------------------------------------------------------------------------

void ZeigeMatrixZeigedauer(boolean Zeigen) {
  if (Zeigen==true) ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeMatrixZeigedauer2() {
  ZeigeMatrix(byte(Zeigedauer/2));
}

//---------------------------------------------------------------------------

void ZeigeMatrixPausendauer() {
   if (PauseOk==true) ZeigeMatrix(Pausendauer);
}

//---------------------------------------------------------------------------

char BcdBin(char Bcd) {
  return Bcd-(Bcd/16)*6;
}

//---------------------------------------------------------------------------

char BinBcd(char Bin) {
  return Bin+(Bin/10)*6;
}

//---------------------------------------------------------------------------

char WochenTag(char Tag, char Monat, char Jahr) {
  Jahr=Jahr+((Monat+9)/12)-1;
  Monat=(Monat+9)%12;
  int AnzahlDerTage=Jahr+(Jahr/4)+Monat*30+((6*Monat+5)/10)+Tag+1;
  return AnzahlDerTage%Wochentage;
}

//---------------------------------------------------------------------------

void SpeichereUhr() {
  if  (UhrWurdeGestellt==true) {
    WTag=WochenTag(Tag, Monat, Jahr);
    Konfig=0x11;
    Sekunden=0;
    Wire.beginTransmission(DS1307_I2C_SlaveAdr);
    Wire.write(UhrSpeicherAdr);
    Wire.write(BinBcd(Sekunden));
    Wire.write(BinBcd(Minuten));
    Wire.write(BinBcd(Stunden));
    Wire.write(WTag+1);
    Wire.write(BinBcd(Tag));
    Wire.write(BinBcd(Monat));
    Wire.write(BinBcd(Jahr));
    Wire.write(Konfig);
    Wire.endTransmission();
  }
  UhrWurdeGestellt=false;
}

//---------------------------------------------------------------------------

boolean HoleUhr() {
  boolean UhrSteht=true;
  char AltMinuten=Minuten;
  Wire.beginTransmission(DS1307_I2C_SlaveAdr);
  Wire.write(UhrSpeicherAdr);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_SlaveAdr, 8); // max. 32 Byte
  if (Wire.available()==8) {
    Sekunden=Wire.read();
    UhrSteht=bitRead(Sekunden, MSB); // MSB 1 => Spannung war weg

    Sekunden=BcdBin(Sekunden);
    Minuten=BcdBin(Wire.read());
    Stunden=BcdBin(Wire.read());
    WTag=Wire.read()-1;
    Tag=BcdBin(Wire.read());
    Monat=BcdBin(Wire.read());
    Jahr=BcdBin(Wire.read());
    Konfig=Wire.read();

    Sekunden=constrain(Sekunden, 0, 59);
    Minuten=constrain(Minuten, 0, 59);
    Stunden=constrain(Stunden, 0, 23);
    WTag=constrain(WTag, Montag, Sonntag);
    Tag=constrain(Tag, 1, MaxTage[Monat-1]);
    Monat=constrain(Monat, 1, 12);
    Jahr=constrain(Jahr, 0, 99);
  }

  if (Minuten!=AltMinuten) {
    if (WeckerEinAus[WTag]==WeckerEin && Minuten==WeckerMinuten[WTag] && Stunden==WeckerStunden[WTag]) {
      WeckerSchellt=MaxWeckerSchellt;
      digitalWrite(WeckerPin, HIGH);
      Abbruch=true;
    }
    else  {
      if (WeckerSchellt>0) {
        WeckerSchellt--;
      }
    }
  }
//  Stunden=12;  Minuten=34; Sekunden=56; // zum testen
  return !UhrSteht;
}

//---------------------------------------------------------------------------

void SpeichereWecker() {
  Wire.beginTransmission(DS1307_I2C_SlaveAdr);
  Wire.write(WeckerSpeicherAdr);
  for (char WeckerTag=Montag; WeckerTag<=Sonntag; WeckerTag++) {
    Wire.write(WeckerMinuten[WeckerTag]);
    Wire.write(WeckerStunden[WeckerTag]);
    Wire.write(WeckerEinAus[WeckerTag]);
  }
  Wire.endTransmission();
}

//---------------------------------------------------------------------------

void HoleWecker() {
  Wire.beginTransmission(DS1307_I2C_SlaveAdr);
  Wire.write(WeckerSpeicherAdr);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_SlaveAdr, 21); // max. 32 Byte
//  while (Wire.available()!=21) ;
  delay(10);
  if (Wire.available()==21) {
    for (char WeckerTag=Montag; WeckerTag<=Sonntag ; WeckerTag++) {
      WeckerMinuten[WeckerTag]=Wire.read();
      WeckerStunden[WeckerTag]=Wire.read();
      WeckerEinAus[WeckerTag]=Wire.read();

      WeckerMinuten[WeckerTag]=constrain(WeckerMinuten[WeckerTag], 0, 59);
      WeckerStunden[WeckerTag]=constrain(WeckerStunden[WeckerTag], 0, 23);
      WeckerEinAus[WeckerTag]=constrain(WeckerEinAus[WeckerTag], WeckerAus, WeckerEin);
    }
  }
}

//---------------------------------------------------------------------------

void HoleTemperatur() {
  Temperatur=120;
  byte Nachkomma;
  Wire.beginTransmission(LM75_I2C_SlaveAdr);
  Wire.write(0);
  Wire.endTransmission();

  Wire.requestFrom(LM75_I2C_SlaveAdr, 2);
  if (Wire.available()==2) {
    Temperatur=Wire.read();
    Nachkomma=Wire.read();
    if (bitRead(Nachkomma,MSB)==1) Temperatur++; // Runden
  }
  Temperatur=Temperatur+TemperaturKorrektur;
  Temperatur=constrain(Temperatur, 0, 99); // Temperatur auf 0..99 beschraenken
//  Temperatur=23; // zum testen
  Fahrenheit=(int(Temperatur)*9)/5+32;
  Fahrenheit=constrain(Fahrenheit, 0, 99);
  Kelvin=273+Temperatur;
}

//---------------------------------------------------------------------------
// Tools
//---------------------------------------------------------------------------

const char AnzahlWarSchonDran=50;

boolean WarSchonDran(byte NeueZufallsZahl) {
  static byte WarSchonZahlen[AnzahlWarSchonDran];
  boolean SchonDa=false;
  for (byte Test=0; Test<AnzahlWarSchonDran; Test++)
    if (WarSchonZahlen[Test]==NeueZufallsZahl) SchonDa=true;
  if (SchonDa==false) {
    for (byte Test=0; Test<AnzahlWarSchonDran-1; Test++)
     WarSchonZahlen[Test]=WarSchonZahlen[Test+1];
    WarSchonZahlen[AnzahlWarSchonDran-1]=NeueZufallsZahl;
  }
  return SchonDa;
}

//---------------------------------------------------------------------------

char Random(char Max) {
  return random(Max);
}

//---------------------------------------------------------------------------

char Random(char Von, char Bis) {
  return random(Von, Bis);
}

//---------------------------------------------------------------------------

void Tausche(char & Zahl1, char & Zahl2) {
  char Hilf=Zahl1; Zahl1=Zahl2; Zahl2=Hilf;
}

//---------------------------------------------------------------------------

static byte AlteLaufgeschwindigkeit;

void SetzeNeueLaufgeschwindigkeit(byte Neu) {
  AlteLaufgeschwindigkeit=Laufgeschwindigkeit;
  Laufgeschwindigkeit=Neu;
}

//---------------------------------------------------------------------------

void ZurueckZurAltenLaufgeschwindigkeit() {
  Laufgeschwindigkeit=AlteLaufgeschwindigkeit;
}

//---------------------------------------------------------------------------

void RichtungUmkehr() {
  Richtung=Richtung^1;
}

//---------------------------------------------------------------------------

void ZufallZuerstUmkehr() {
   ZufallZuerst=ZufallZuerst^1;
}

//---------------------------------------------------------------------------

void LoescheMatrix(char Matrix[]) {
  for (char Spalte=0; Spalte<8; Spalte++)
    Matrix[Spalte]=0;
}

//---------------------------------------------------------------------------

void LoescheHauptMatrix() {
  LoescheMatrix(HauptMatrix);
}

//---------------------------------------------------------------------------

void LoescheSchattenMatrix() {
  LoescheMatrix(SchattenMatrix);
}

//---------------------------------------------------------------------------

void KopiereMatrixSpaltenVonBis(char Matrix1[], char Matrix2[], char VonSpalte, char BisSpalte) {
  for (char Spalte=VonSpalte; Spalte<=BisSpalte; Spalte++)
    Matrix1[Spalte]=Matrix2[Spalte];
}

//---------------------------------------------------------------------------

void KopiereGanzeMatrix(char Matrix1[], char Matrix2[]) {
  KopiereMatrixSpaltenVonBis(Matrix1, Matrix2, LinkeSpalte, RechteSpalte);
}

//---------------------------------------------------------------------------

void TauscheMatrix() {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++)
    Tausche(HauptMatrix[Spalte], SchattenMatrix[Spalte]);
}

//---------------------------------------------------------------------------

char HolePunkt(char Matrix[], char x, char y) {
  return bitRead(Matrix[x],y);
}

//---------------------------------------------------------------------------

char HolePunktNr(char Matrix[], char Nr) {
  return HolePunkt(Matrix, Nr%AnzahlSpalten, Nr/AnzahlSpalten);
}

//---------------------------------------------------------------------------

void SetzePunkt(char Matrix[], char x, char y, char Punkt) {
  if (x>=LinkeSpalte&&x<=RechteSpalte)
    bitWrite(Matrix[x], y, Punkt);
}

//---------------------------------------------------------------------------

void SetzePunktHauptMatrix(char x, char y, char Punkt) {
  SetzePunkt(HauptMatrix, x, y,Punkt);
}

//---------------------------------------------------------------------------

void SetzePunktNr(char Matrix[], char Nr, char Punkt) {
  SetzePunkt(Matrix, Nr%AnzahlSpalten, Nr/AnzahlSpalten, Punkt);
}

//---------------------------------------------------------------------------

void SetzePunktNrHauptMatrix(char Nr, char Punkt) {
  SetzePunktHauptMatrix(Nr%AnzahlSpalten, Nr/AnzahlSpalten, Punkt);
}

//---------------------------------------------------------------------------

void SetzeKopierePunkt(char x, char y, byte PunktArt, byte Dauer) {
  byte Punkt1=HolePunkt(HauptMatrix, x, y);
  byte Punkt2=HolePunkt(SchattenMatrix, x, y);
  if (PunktArt<PunktKopier) Punkt2=PunktArt;
  if (Punkt1!=Punkt2) {
    SetzePunktHauptMatrix(x, y, Punkt2);
    ZeigeMatrix(Dauer);
  }
}

//---------------------------------------------------------------------------

void SetzeKopierePunktLaufgeschwindigkeit(char x, char y, char PunktArt) {
  SetzeKopierePunkt(x, y, PunktArt, Laufgeschwindigkeit);
}

//---------------------------------------------------------------------------

char HoleSpalte(char Matrix[], char Spalte) {
  return Matrix[Spalte];
}

//---------------------------------------------------------------------------

char HoleSpalteSchattenMatrix(char Spalte) {
  return SchattenMatrix[Spalte];
}

//---------------------------------------------------------------------------

char HoleSpalteHauptMatrix(char Spalte) {
  return HauptMatrix[Spalte];
}

//---------------------------------------------------------------------------

void SetzeSpalte(char Matrix[], char Spalte, char Muster) {
  if (Spalte>=LinkeSpalte&&Spalte<=RechteSpalte) {
    Matrix[Spalte]=Muster;
  }
}

//---------------------------------------------------------------------------

void SetzeSpalteHauptMatrix(char Spalte, char Muster) {
  SetzeSpalte(HauptMatrix, Spalte, Muster);
}

//---------------------------------------------------------------------------

void SetzeSpaltenBalken(char Spalte) {
  if(Balken!=KeinBalken) SetzeSpalteHauptMatrix(Spalte, Balken);
}

//---------------------------------------------------------------------------

void SetzeSpalteSchattenMatrix(char Spalte, char Muster) {
  SetzeSpalte(SchattenMatrix, Spalte, Muster);
}

//---------------------------------------------------------------------------

char HoleZeile(char Matrix[], char Zeile) {
  char Muster=0;
  if (Zeile>=ObereZeile&&Zeile<=UntereZeile) {
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++)
      bitWrite(Muster, Spalte, bitRead(Matrix[Spalte], Zeile));
    }
  return Muster;
}

//---------------------------------------------------------------------------

char HoleZeileHauptMatrix(char Zeile) {
  return HoleZeile(HauptMatrix, Zeile);
}

//---------------------------------------------------------------------------

char HoleZeileSchattenMatrix(char Zeile) {
  return HoleZeile(SchattenMatrix, Zeile);
}

//---------------------------------------------------------------------------

void SetzeZeile(char Matrix[], char Zeile, char Muster) {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++)
    bitWrite(Matrix[Spalte], Zeile, bitRead(Muster, Spalte));
}

//---------------------------------------------------------------------------

void SetzeZeileHauptMatrix(char Zeile, char Muster) {
  SetzeZeile(HauptMatrix, Zeile, Muster);
}

//---------------------------------------------------------------------------

void SetzeZeileSchattenMatrix(char Zeile, char Muster) {
  SetzeZeile(SchattenMatrix, Zeile, Muster);
}

//---------------------------------------------------------------------------

void SetzeZeilenBalken(char Zeile) {
  if(Balken!=KeinBalken) SetzeZeile(HauptMatrix, Zeile, Balken);
}

//---------------------------------------------------------------------------

void SpiegelSpalten(char Matrix[]) {
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++)
    Tausche(Matrix[Spalte],Matrix[RechteSpalte-Spalte]);
}

//---------------------------------------------------------------------------

void SpiegelSpaltenSchattenMatrix() {
  SpiegelSpalten(SchattenMatrix);
}

//---------------------------------------------------------------------------

void SpiegelZeilen(char Matrix[]) {
  char Hilf;
  for (char Zeile=0; Zeile<=1; Zeile++) {
    Hilf=HoleZeile(Matrix,Zeile);
    SetzeZeile(Matrix,Zeile,HoleZeile(Matrix,UntereZeile-Zeile));
    SetzeZeile(Matrix,UntereZeile-Zeile,Hilf);
  }
}

//---------------------------------------------------------------------------

void SpiegelZeilenSchattenMatrix() {
  SpiegelZeilen(SchattenMatrix);
}

//---------------------------------------------------------------------------

void SetzeZeichen(char Matrix[], char Zeichen, char Pos) {
  for (byte Spalte=0; Spalte<ZeichenBreite; Spalte++)  {
    SetzeSpalte(Matrix, Pos+Spalte, pgm_read_byte(CodeTab+ZeichenBreite*Zeichen+Spalte));
  }
}

//---------------------------------------------------------------------------

void SetzeZehner(char Matrix[], char Zehner) {
  if (Zehner<0) Zehner=15-Zehner; // Grad, Celsius, ...
  SetzeZeichen(Matrix, Zehner, ZehnerPos);
}

//---------------------------------------------------------------------------

void SetzeEiner(char Matrix[], char Einer) {
  if (Einer<0) Einer=15-Einer;  // Grad, Celsius, ...
  SetzeZeichen(Matrix, Einer, EinerPos);
}

//---------------------------------------------------------------------------

void SetzeZahl(char Matrix[], char Zahl, char Trenner) {
  LoescheMatrix(Matrix);
  char Zehner=Zahl/10;
  char Einer=Zahl%10;
  if (Zehner==0 && Nullunterdrueckung==true) Zehner=Leerzeichen;
  SetzeZehner(Matrix, Zehner);
  Matrix[3]=Trenner;
  SetzeEiner(Matrix, Einer);
}

//---------------------------------------------------------------------------

void SetzeZahl(char Matrix[], char Zahl) {
  SetzeZahl(Matrix, Zahl, KeinTrenner);
}

//---------------------------------------------------------------------------

void SetzeZahlHauptMatrix(char Zahl) {
  SetzeZahl(HauptMatrix, Zahl, KeinTrenner);
}

//---------------------------------------------------------------------------

void ZeigeSetzeZahlHauptMatrix(char Zahl) {
  SetzeZahlHauptMatrix(Zahl);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void SetzeZahlSchattenMatrix(char Zahl) {
  SetzeZahl(SchattenMatrix, Zahl, KeinTrenner);
}

//---------------------------------------------------------------------------

void ZeigeSetzeZehner(char Zahl, byte Dauer) {
  SetzeZahlSchattenMatrix(Zahl);
  KopiereMatrixSpaltenVonBis(HauptMatrix, SchattenMatrix, LinkeZehnerSpalte, RechteZehnerSpalte);
  ZeigeMatrix(Dauer);
}

//---------------------------------------------------------------------------

void ZeigeSetzeEiner(char Zahl, byte Dauer) {
  SetzeZahlSchattenMatrix(Zahl);
  KopiereMatrixSpaltenVonBis(HauptMatrix, SchattenMatrix, LinkeEinerSpalte, RechteEinerSpalte);
  ZeigeMatrix(Dauer);
}

//---------------------------------------------------------------------------

void ZeigeSetzeZehnerEiner(char Zahl, byte Dauer) {
  if (ZufallZuerst==ZehnerZuerst)
    ZeigeSetzeZehner(Zahl, Dauer);
  else
    ZeigeSetzeEiner(Zahl, Dauer);
}

//---------------------------------------------------------------------------

void ZeigeSetzeZahlZehnerEiner(char Zahl) {
  ZeigeSetzeZehnerEiner(Zahl, Zeigedauer/2);
  ZufallZuerstUmkehr();
  ZeigeSetzeZehnerEiner(Zahl, Zeigedauer);
  ZufallZuerstUmkehr();
}

//---------------------------------------------------------------------------

void SetzeKopiereDiagonale(char Diagonale, byte Spiegel, byte PunktArt) {
  for (char x=LinkeSpalte; x<=RechteSpalte; x++) {
    for (char y=ObereZeile; y<=UntereZeile; y++) {
      char x2=x; if (bitRead(Spiegel,0)) x2=RechteSpalte-x; // x spiegeln
      char y2=y; if (bitRead(Spiegel,1)) y2=UntereZeile-y;  // y speigeln
      if (x+y==Diagonale) {
        SetzeKopierePunkt(x2, y2, PunktArt, Keinedauer);
      }
    }
  }
}

//---------------------------------------------------------------------------

void KopiereDiagonalLaufgeschwindigkeit(byte Spiegel) {
  for (char d=0; d<=(AnzahlZeilen-1)+(AnzahlSpalten-1); d++) {
    if (Balken!=KeinBalken) SetzeKopiereDiagonale(d, Spiegel, PunktEin);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeKopiereDiagonale(d, Spiegel, PunktKopier);
  }
}

//---------------------------------------------------------------------------

void KopiereLinksLaufgeschwindigkeit() {
  for (char Spalte=RechteSpalte; Spalte>=LinkeSpalte; Spalte--) {
    SetzeSpaltenBalken(Spalte);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeSpalteHauptMatrix(Spalte, HoleSpalteSchattenMatrix(Spalte));
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereRechtsLaufgeschwindigkeit() {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    SetzeSpaltenBalken(Spalte);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeSpalteHauptMatrix(Spalte, HoleSpalteSchattenMatrix(Spalte));
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereHochLaufgeschwindigkeit() {
  for (char Zeile=UntereZeile; Zeile>=ObereZeile; Zeile--) {
    SetzeZeilenBalken(Zeile);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeZeileHauptMatrix(Zeile, HoleZeileSchattenMatrix(Zeile));
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereRunterLaufgeschwindigkeit() {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    SetzeZeilenBalken(Zeile);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeZeileHauptMatrix(Zeile, HoleZeileSchattenMatrix(Zeile));
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereInnenLaufgeschwindigkeit() {
  for (char Spalte=0; Spalte<=ZeichenBreite; Spalte++) {
    SetzeSpaltenBalken(Spalte);
    SetzeSpaltenBalken(RechteSpalte-Spalte);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeSpalteHauptMatrix(Spalte, HoleSpalteSchattenMatrix(Spalte));
    SetzeSpalteHauptMatrix(RechteSpalte-Spalte, HoleSpalteSchattenMatrix(RechteSpalte-Spalte));
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereAussenLaufgeschwindigkeit() {
  for (char Spalte=0; Spalte<=ZeichenBreite; Spalte++) {
    SetzeSpaltenBalken(MitteSpalte+Spalte);
    SetzeSpaltenBalken(MitteSpalte-Spalte);
    ZeigeMatrixLaufgeschwindigkeit();
    SetzeSpalteHauptMatrix(MitteSpalte+Spalte, HoleSpalteSchattenMatrix(MitteSpalte+Spalte));
    SetzeSpalteHauptMatrix(MitteSpalte-Spalte, HoleSpalteSchattenMatrix(MitteSpalte-Spalte));
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  KopiereLinksLaufgeschwindigkeit();  break;
    case Rechts: KopiereRechtsLaufgeschwindigkeit(); break;
    case Hoch:   KopiereHochLaufgeschwindigkeit();   break;
    case Runter: KopiereRunterLaufgeschwindigkeit(); break;
    case Innen:  KopiereInnenLaufgeschwindigkeit();   break;
    case Aussen: KopiereAussenLaufgeschwindigkeit(); break;
    case LinksOben:
    case RechtsOben:
    case LinksUnten:
    case RechtsUnten: KopiereDiagonalLaufgeschwindigkeit(Richtung-LinksOben); break;
  }
}

//---------------------------------------------------------------------------

void ZeigeKopiere() {
  KopiereLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void KopiereSpaltenHochLaufgeschwindigkeit(byte SchiebeSpalten) {
  for (char BitZeile=bit(UntereZeile+1); BitZeile>=bit(ObereZeile); BitZeile=BitZeile>>1) {
    char BitZeile2=~BitZeile;
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++)
      if (bitRead(SchiebeSpalten, Spalte)==1)
        HauptMatrix[Spalte]=(HauptMatrix[Spalte]&BitZeile2) | (SchattenMatrix[Spalte]&BitZeile);
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void KopiereSpaltenRunterLaufgeschwindigkeit(byte KopierSpalten) {
  for (char BitZeile=bit(ObereZeile); BitZeile<=bit(UntereZeile); BitZeile=BitZeile<<1) {
    char BitZeile2=~BitZeile;
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++)
      if (bitRead(KopierSpalten, Spalte)==1)
        HauptMatrix[Spalte]=(HauptMatrix[Spalte]&BitZeile2) | (SchattenMatrix[Spalte]&BitZeile);
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void KopiereSpaltenSenkrechtLaufgeschwindigkeit(byte KopierSpalten) {
  switch(Richtung) {
    case Hoch:   KopiereSpaltenHochLaufgeschwindigkeit(KopierSpalten); break;
    case Runter: KopiereSpaltenRunterLaufgeschwindigkeit(KopierSpalten); break;
  }
}

//---------------------------------------------------------------------------

void KopiereNachAussenGleichzeitigLaufgeschwindigkeit() {
  for (char Spalte=ZeichenBreite-1; Spalte>=0; Spalte--) {
    HauptMatrix[Spalte]=SchattenMatrix[Spalte];
    HauptMatrix[RechteSpalte-Spalte]=SchattenMatrix[RechteSpalte-Spalte];
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void KopiereNachInnenGleichzeitigLaufgeschwindigkeit() {
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    HauptMatrix[Spalte]=SchattenMatrix[Spalte];
    HauptMatrix[RechteSpalte-Spalte]=SchattenMatrix[RechteSpalte-Spalte];
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

char SchiebeSpaltenLinksVonBis(char Matrix[], char VonSpalte, char BisSpalte, char NeueSpalte) {
  char AlteSpalte=HoleSpalte(Matrix, VonSpalte);
  for (char Spalte=VonSpalte; Spalte<BisSpalte; Spalte++)
    SetzeSpalte(Matrix,Spalte,HoleSpalte(Matrix,Spalte+1));
  SetzeSpalte(Matrix,BisSpalte,NeueSpalte);
  return AlteSpalte;
}

//---------------------------------------------------------------------------

char SchiebeSpaltenLinksVonBisHauptMatrix(char VonSpalte, char BisSpalte, char NeueSpalte) {
  return SchiebeSpaltenLinksVonBis(HauptMatrix, VonSpalte, BisSpalte, NeueSpalte);
}

//---------------------------------------------------------------------------

char SchiebeSpaltenLinksVonBisSchattenMatrix(char VonSpalte, char BisSpalte, char NeueSpalte) {
  return SchiebeSpaltenLinksVonBis(SchattenMatrix, VonSpalte, BisSpalte, NeueSpalte);
}

//---------------------------------------------------------------------------

void SchiebeLeereSpalteLinksHauptMatrix() {
  SchiebeSpaltenLinksVonBis(HauptMatrix, LinkeSpalte, RechteSpalte, LeerMuster);
}

//---------------------------------------------------------------------------

char SchiebeSpaltenRechtsVonBis(char Matrix[], char VonSpalte, char BisSpalte, char NeueSpalte) {
  char AlteSpalte=HoleSpalte(Matrix,BisSpalte);
  for (char Spalte=BisSpalte; Spalte>VonSpalte; Spalte--)
    SetzeSpalte(Matrix,Spalte,HoleSpalte(Matrix,Spalte-1));
  SetzeSpalte(Matrix,VonSpalte,NeueSpalte);
  return AlteSpalte;
}

//---------------------------------------------------------------------------

char SchiebeSpaltenRechtsVonBisHauptMatrix(char VonSpalte, char BisSpalte, char NeueSpalte) {
  return SchiebeSpaltenRechtsVonBis(HauptMatrix, VonSpalte, BisSpalte, NeueSpalte);
}

//---------------------------------------------------------------------------

char SchiebeSpaltenRechtsVonBisSchattenMatrix(char VonSpalte, char BisSpalte, char NeueSpalte) {
  return SchiebeSpaltenRechtsVonBis(SchattenMatrix, VonSpalte, BisSpalte, NeueSpalte);
}

//---------------------------------------------------------------------------

void SchiebeLeereSpalteRechtsHauptMatrix() {
  SchiebeSpaltenRechtsVonBisHauptMatrix(LinkeSpalte, RechteSpalte, LeerMuster);
}

//---------------------------------------------------------------------------

void SchiebeAlleSpaltenLinksRechtsLaufgeschwindigkeit() {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    switch(Richtung){
      case Links:
        SchiebeSpaltenLinksVonBisHauptMatrix(LinkeSpalte,RechteSpalte,
          SchiebeSpaltenLinksVonBisSchattenMatrix(LinkeSpalte,RechteSpalte,LeerMuster));
        break;
      case Rechts:
        SchiebeSpaltenRechtsVonBisHauptMatrix(LinkeSpalte,RechteSpalte,
          SchiebeSpaltenRechtsVonBisSchattenMatrix(LinkeSpalte,RechteSpalte,LeerMuster));
        break;
    }
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

char SchiebeSpaltenVonBisHoch(char Matrix[], char VonSpalte, char BisSpalte, char NeueZeile) {
  char AlteZeile=HoleZeile(Matrix,ObereZeile);
  for (char Spalte=VonSpalte; Spalte<=BisSpalte; Spalte++)
    SetzeSpalte(Matrix,Spalte,(HoleSpalte(Matrix,Spalte)>>1)+bit(UntereZeile+1)*bitRead(NeueZeile,Spalte));
  return AlteZeile;
}

//---------------------------------------------------------------------------

void SchiebeLeereZeileHochHauptMatrix() {
  SchiebeSpaltenVonBisHoch(HauptMatrix, LinkeSpalte, RechteSpalte, LeerMuster);
}

//---------------------------------------------------------------------------

char SchiebeSpaltenVonBisRunter(char Matrix[], char VonSpalte, char BisSpalte, char NeueZeile) {
  char AlteZeile=HoleZeile(Matrix,DummyZeile);
  for (char Spalte=VonSpalte; Spalte<=BisSpalte; Spalte++)
    SetzeSpalte(Matrix,Spalte,(HoleSpalte(Matrix,Spalte)<<1)+bitRead(NeueZeile,Spalte));
  return AlteZeile;
}

//---------------------------------------------------------------------------

void SchiebeLeereZeileRunterHauptMatrix() {
  SchiebeSpaltenVonBisRunter(HauptMatrix, LinkeSpalte, RechteSpalte, LeerMuster);
}

//---------------------------------------------------------------------------

char SchiebeSpaltenKodiertHoch1x(char Matrix[], byte SchiebeSpalten, char NeueZeile) {
  char AlteZeile=0;
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    if (bitRead(SchiebeSpalten, Spalte)==1) {
      bitWrite(AlteZeile, Spalte, bitRead(Matrix[Spalte], ObereZeile));
      Matrix[Spalte]=Matrix[Spalte]>>1;
      bitWrite(Matrix[Spalte], DummyZeile, bitRead(NeueZeile, Spalte));
    }
  }
  return AlteZeile;
}

//---------------------------------------------------------------------------

char SchiebeSpaltenKodiertRunter1x(char Matrix[], byte SchiebeSpalten, char NeueZeile) {
  char AlteZeile=0;
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    if (bitRead(SchiebeSpalten, Spalte)==1) {
      bitWrite(AlteZeile, Spalte, bitRead(Matrix[Spalte], DummyZeile));
      Matrix[Spalte]=Matrix[Spalte]<<1;
      bitWrite(Matrix[Spalte], ObereZeile, bitRead(NeueZeile, Spalte));
    }
  }
  return AlteZeile;
}

//---------------------------------------------------------------------------

void SchiebeSpaltenHochRunterKodiert(char Anzahl, byte SchiebeSpalten, byte Dauer) {
  for (char anz=0; anz<Anzahl; anz++) {
    if (Richtung==Hoch)
      SchiebeSpaltenKodiertHoch1x(HauptMatrix, SchiebeSpalten, SchiebeSpaltenKodiertHoch1x(SchattenMatrix, SchiebeSpalten, LeerMuster));
    else
      SchiebeSpaltenKodiertRunter1x(HauptMatrix, SchiebeSpalten, SchiebeSpaltenKodiertRunter1x(SchattenMatrix, SchiebeSpalten, LeerMuster));
    ZeigeMatrix(Dauer);
  }
}

//---------------------------------------------------------------------------

void SchiebeSpaltenHochRunterKodiertLaufgeschwindigkeit(char Anzahl, byte SchiebeSpalten) {
  SchiebeSpaltenHochRunterKodiert(Anzahl, SchiebeSpalten, Laufgeschwindigkeit);
}


//---------------------------------------------------------------------------

void SchiebeSpalten6xHochRunterLaufgeschwindigkeit(unsigned long SchiebeSpalten) {
  while (SchiebeSpalten!=0) {
    SchiebeSpaltenHochRunterKodiert(6, lowByte(SchiebeSpalten), Laufgeschwindigkeit);
    SchiebeSpalten=SchiebeSpalten>>8;
  }
}

//---------------------------------------------------------------------------

void SchiebeSpalten12(byte SchiebeSpalten, byte Richtung1, byte Richtung2) {
  Richtung=Richtung1;
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(SchiebeSpalten);
  Richtung=Richtung2;
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(SchiebeSpalten^AlleSpalten);
}

//---------------------------------------------------------------------------

void SchiebeSpalten25GleichzeitigLaufgeschwindigkeit(byte SchiebeSpalten) {
  for (char Zeile=0; Zeile<=AnzahlZeilen; Zeile++) {
    SchiebeSpaltenHochRunterKodiert(1, SchiebeSpalten, Keinedauer);
    RichtungUmkehr();
    SchiebeSpaltenHochRunterKodiertLaufgeschwindigkeit(1, SchiebeSpalten^AlleSpalten);
    RichtungUmkehr();
  }
}

//---------------------------------------------------------------------------

void SchiebeZeilenKodiertLinks(byte SchiebeZeilen, byte Dauer) {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    if (bitRead(SchiebeZeilen,Zeile)==1) {
      char ZeilenMuster1=HoleZeileHauptMatrix(Zeile);
      char ZeilenMuster2=HoleZeileSchattenMatrix(Zeile);
      ZeilenMuster1=ZeilenMuster1>>1;
      bitWrite(ZeilenMuster1,RechteSpalte,bitRead(ZeilenMuster2,LinkeSpalte));
      ZeilenMuster2=ZeilenMuster2>>1;
      SetzeZeileHauptMatrix(Zeile,ZeilenMuster1);
      SetzeZeileSchattenMatrix(Zeile,ZeilenMuster2);
    }
  }
  ZeigeMatrix(Dauer);
}

//---------------------------------------------------------------------------

void SchiebeZeilenKodiertRechts(byte SchiebeZeilen, byte Dauer) {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    if (bitRead(SchiebeZeilen,Zeile)==1) {
      char ZeilenMuster1=HoleZeileHauptMatrix(Zeile);
      char ZeilenMuster2=HoleZeileSchattenMatrix(Zeile);
      ZeilenMuster1=ZeilenMuster1<<1;
      bitWrite(ZeilenMuster1,LinkeSpalte,bitRead(ZeilenMuster2,RechteSpalte));
      ZeilenMuster2=ZeilenMuster2<<1;
      SetzeZeileHauptMatrix(Zeile,ZeilenMuster1);
      SetzeZeileSchattenMatrix(Zeile,ZeilenMuster2);
    }
  }
  ZeigeMatrix(Dauer);
}

//---------------------------------------------------------------------------

void SchiebeZeilenKodiert(byte SchiebeZeilen, byte Dauer) {
  if (Richtung==Links)
    SchiebeZeilenKodiertLinks(SchiebeZeilen, Dauer);
  else
    SchiebeZeilenKodiertRechts(SchiebeZeilen, Dauer);
}

//---------------------------------------------------------------------------

void SchiebeZeilenKodiert6xLaufgeschwindigkeit(byte SchiebeZeilen) {
  for (char Zeilen=0; Zeilen<=AnzahlZeilen+1; Zeilen++)
    SchiebeZeilenKodiert(SchiebeZeilen, Laufgeschwindigkeit);
}

//---------------------------------------------------------------------------

void SchiebeZeilenLaufgeschwindigkeit(byte SchiebeZeilen, byte Richtung1, byte Richtung2) {
  Richtung=Richtung1;
  SchiebeZeilenKodiert6xLaufgeschwindigkeit(SchiebeZeilen);
  Richtung=Richtung2;
  SchiebeZeilenKodiert6xLaufgeschwindigkeit(SchiebeZeilen^AlleZeilen);
}

//---------------------------------------------------------------------------

void SchiebeZeilenGleichzeitigLaufgeschwindigkeit(byte SchiebeZeilen1, byte SchiebeZeilen2) {
  for (char Zeilen=0; Zeilen<=AnzahlZeilen+1; Zeilen++) {
    SchiebeZeilenKodiert(SchiebeZeilen1, Keinedauer);
    RichtungUmkehr();
    SchiebeZeilenKodiert(SchiebeZeilen2, Laufgeschwindigkeit);
    RichtungUmkehr();
  }
}

//---------------------------------------------------------------------------

void SchiebeEinerLaufgeschwindigkeit() {
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(EinerSpalten);
}

//---------------------------------------------------------------------------

void SchiebeZehnerLaufgeschwindigkeit() {
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(ZehnerSpalten);
}

//---------------------------------------------------------------------------

void SchiebeZehnerEinerGleichzeitigLaufgeschwindigkeit() {
  for (char Zeile=0; Zeile<AnzahlZeilen+1; Zeile++) {
    SchiebeSpaltenHochRunterKodiert(1, ZehnerSpalten, Keinedauer);
    RichtungUmkehr();
    SchiebeSpaltenHochRunterKodiertLaufgeschwindigkeit(1, EinerSpalten);
    RichtungUmkehr();
  }
}

//---------------------------------------------------------------------------

void SchiebeSpalten123Laufgeschwindigkeit(byte SchiebeSpalten1, byte SchiebeSpalten2, byte SchiebeSpalten3) {
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(SchiebeSpalten1);
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(SchiebeSpalten2);
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(SchiebeSpalten3);
}

//---------------------------------------------------------------------------

void SchiebeLinksLaufgeschwindigkeit(char Oft) {
  for (char o=0; o<Oft; o++) {
    SchiebeSpaltenLinksVonBisHauptMatrix(LinkeSpalte, RechteSpalte,
      SchiebeSpaltenLinksVonBisSchattenMatrix(LinkeSpalte, RechteSpalte, LeerMuster));
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void SchiebeRechtsLaufgeschwindigkeit(char Oft) {
  for (char o=0; o<Oft; o++) {
    SchiebeSpaltenRechtsVonBisHauptMatrix(LinkeSpalte, RechteSpalte,
      SchiebeSpaltenRechtsVonBisSchattenMatrix(LinkeSpalte, RechteSpalte, LeerMuster));
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void SchiebeHochDirektLaufgeschwindigkeit(char Oft, byte SchiebeSpaltenSpalten) {
  for (char o=0; o<Oft; o++) {
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
      if (bitRead(SchiebeSpaltenSpalten, Spalte)==1) {
        HauptMatrix[Spalte]=HauptMatrix[Spalte]>>1;
        bitWrite(HauptMatrix[Spalte], DummyZeile, bitRead(SchattenMatrix[Spalte], ObereZeile));
        SchattenMatrix[Spalte]=SchattenMatrix[Spalte]>>1;
      }
    }
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void SchiebeHochLaufgeschwindigkeit(char Oft) {
  SchiebeHochDirektLaufgeschwindigkeit(Oft, AlleSpalten);
}

//---------------------------------------------------------------------------

void SchiebeRunterDirektLaufgeschwindigkeit(char Oft, byte SchiebeSpaltenSpalten) {
  for (char o=0; o<Oft; o++) {
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
      if (bitRead(SchiebeSpaltenSpalten, Spalte)==1) {
        HauptMatrix[Spalte]=HauptMatrix[Spalte]<<1;
        bitWrite(HauptMatrix[Spalte], ObereZeile, bitRead(SchattenMatrix[Spalte], DummyZeile));
        SchattenMatrix[Spalte]=SchattenMatrix[Spalte]<<1;
      }
    }
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void SchiebeRunterLaufgeschwindigkeit(char Oft) {
  SchiebeRunterDirektLaufgeschwindigkeit(Oft, AlleSpalten);
}

//---------------------------------------------------------------------------

void SchiebeLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  SchiebeLinksLaufgeschwindigkeit(AnzahlSpalten); break;
    case Rechts: SchiebeRechtsLaufgeschwindigkeit(AnzahlSpalten); break;
    case Hoch:   SchiebeHochLaufgeschwindigkeit(AnzahlZeilen+1); break; // ???
    case Runter: SchiebeRunterLaufgeschwindigkeit(AnzahlZeilen+1); break;
  }
}

//---------------------------------------------------------------------------

void SchiebeOftLaufgeschwindigkeit(char Oft) {
  switch(Richtung) {
    case Links:  SchiebeLinksLaufgeschwindigkeit(Oft); break;
    case Rechts: SchiebeRechtsLaufgeschwindigkeit(Oft); break;
    case Hoch:   SchiebeHochLaufgeschwindigkeit(Oft); break;
    case Runter: SchiebeRunterLaufgeschwindigkeit(Oft); break;
  }
}

//---------------------------------------------------------------------------

void SchiebeMusterLaufgeschwindigkeit(char Muster) {
  switch(Richtung) {
    case Links:
      SetzeSpalteSchattenMatrix(LinkeSpalte, Muster);
      SchiebeLinksLaufgeschwindigkeit(1);
      break;
    case Rechts:
      SetzeSpalteSchattenMatrix(RechteSpalte, Muster);
      SchiebeRechtsLaufgeschwindigkeit(1);
      break;
    case Hoch:
      SetzeZeileSchattenMatrix(ObereZeile, Muster);
      SchiebeHochLaufgeschwindigkeit(1);
      break;
    case Runter:
      SetzeZeileSchattenMatrix(UntereZeile, Muster);
      SchiebeRunterLaufgeschwindigkeit(1);
      break;
  }
}

//---------------------------------------------------------------------------

void KodierTasterZehnerLaufgeschwindigkeit(char Zahl, char MaxZehner) {
  byte RichtungKodierTaster=Richtung;
  char SollZehner=Zahl/10;
  char IstZehner=AlteZahl/10;
  char DifZehner=SollZehner-IstZehner;
  if (DifZehner<0) DifZehner=DifZehner+(MaxZehner+1);
  if (DifZehner>(MaxZehner+1)/2) RichtungUmkehr;
  if (IstZehner!=SollZehner) {
    do {
      if (Richtung==RichtungKodierTaster) {
        IstZehner++;
        if (IstZehner>MaxZehner) IstZehner=0;
      }
      else {
        IstZehner--;
        if (IstZehner<0) IstZehner=MaxZehner;
      }
      SetzeZahlSchattenMatrix(IstZehner*10);
      SchiebeZehnerLaufgeschwindigkeit();
    } while (IstZehner!=SollZehner);
  }
  Richtung=RichtungKodierTaster;
}

//---------------------------------------------------------------------------

void KodierTasterEinerLaufgeschwindigkeit(char Zahl) {
  byte RichtungKodierTaster=Richtung;
  char SollEiner=Zahl%10;
  char IstEiner=AlteZahl%10;
  char DifEiner=SollEiner-IstEiner;
  if (DifEiner<0) DifEiner=DifEiner+10;
  if (DifEiner>5) RichtungUmkehr();
  if (IstEiner!=SollEiner) {
    do {
      if (Richtung==RichtungKodierTaster) {
        IstEiner++;
        if (IstEiner>9) IstEiner=0;
      }
      else {
        IstEiner--;
        if (IstEiner<0) IstEiner=9;
      }
      SetzeZahlSchattenMatrix(IstEiner);
      SchiebeEinerLaufgeschwindigkeit();
    } while (IstEiner!=SollEiner);
  }
  Richtung=RichtungKodierTaster;
}

//---------------------------------------------------------------------------

void Mischen(char MaxZahl) {
  char Zahl, Zufall1, Zufall2;
  for (Zahl=0; Zahl<MaxZahl; Zahl++)
    ZufallsZahlen[Zahl]=Zahl;
  for (char Zahl=0; Zahl<MaxZahl; Zahl++) {
    Zufall1=Random(MaxZahl);
    Zufall2=Random(MaxZahl);
    Tausche(ZufallsZahlen[Zufall1], ZufallsZahlen[Zufall2]);
  }
}

//---------------------------------------------------------------------------

void PunkteZufallLaufgeschwindigkeit(char VonSpalte, char BisSpalte){
  Mischen(AnzahlLeds);
  for(char Led=0; Led<AnzahlLeds; Led++) {
    char x=ZufallsZahlen[Led]%AnzahlSpalten;
    char y=ZufallsZahlen[Led]/AnzahlSpalten;
    if (x>=VonSpalte && x<=BisSpalte) SetzeKopierePunktLaufgeschwindigkeit(x, y, PunktKopier);
  }
}

//---------------------------------------------------------------------------

void ZehnerEinerPunkteZufallLaufgeschwindigkeit() {
  Mischen(AnzahlLeds);
  if (ZufallZuerst==ZehnerZuerst) PunkteZufallLaufgeschwindigkeit(LinkeSpalte,MitteSpalte);
  PunkteZufallLaufgeschwindigkeit(MitteSpalte,RechteSpalte);
  if (ZufallZuerst==!ZehnerZuerst) PunkteZufallLaufgeschwindigkeit(LinkeSpalte,MitteSpalte);
}

//---------------------------------------------------------------------------

void SpaltenZufallLaufgeschwindigkeit(boolean Schieben) {
  char Warschon=bit(MitteSpalte);
  char ZufallsSpalte;
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  do {
    do {
      ZufallsSpalte=Random(AnzahlSpalten);
    } while (bitRead(Warschon, ZufallsSpalte)==1);
    bitSet(Warschon, ZufallsSpalte);
    if (HoleSpalteHauptMatrix(ZufallsSpalte)!=HoleSpalteSchattenMatrix(ZufallsSpalte))
      if (Schieben==true)
        SchiebeSpalten6xHochRunterLaufgeschwindigkeit(bit(ZufallsSpalte));
      else
        SetzeSpalteHauptMatrix(ZufallsSpalte,HoleSpalteSchattenMatrix(ZufallsSpalte));
    ZeigeMatrixLaufgeschwindigkeit();
  } while (Warschon!=AlleSpalten);
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeilenZufallLaufgeschwindigkeit(boolean Schieben) {
  char Warschon=0;
  char ZufallsZeile;
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  do {
    do {
      ZufallsZeile=Random(AnzahlZeilen);
    } while (bitRead(Warschon, ZufallsZeile)==1);
    bitSet(Warschon, ZufallsZeile);
    if (HoleZeileHauptMatrix(ZufallsZeile)!=HoleZeileSchattenMatrix(ZufallsZeile))
      if (Schieben==true)
        SchiebeZeilenKodiert6xLaufgeschwindigkeit(bit(ZufallsZeile));
      else
       SetzeZeileHauptMatrix(ZufallsZeile, HoleZeileSchattenMatrix(ZufallsZeile));
    ZeigeMatrixLaufgeschwindigkeit();
  } while (Warschon!=AlleZeilen);
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KopiereNachLinkGleichzeitigLaufgeschwindigkeit(){
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    HauptMatrix[Spalte]=SchattenMatrix[Spalte];
    HauptMatrix[Spalte+LinkeEinerSpalte]=SchattenMatrix[Spalte+LinkeEinerSpalte];
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void KopiereNachRechtsGleichzeitigLaufgeschwindigkeit() {
  for (char Spalte=ZeichenBreite-1; Spalte>=0; Spalte--) {
    HauptMatrix[Spalte]=SchattenMatrix[Spalte];
    HauptMatrix[Spalte+LinkeEinerSpalte]=SchattenMatrix[Spalte+LinkeEinerSpalte];
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void KopiereNachGleichzeitigLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  KopiereNachLinkGleichzeitigLaufgeschwindigkeit(); break;
    case Rechts: KopiereNachRechtsGleichzeitigLaufgeschwindigkeit(); break;
    case Hoch:   KopiereHochLaufgeschwindigkeit(); break;
    case Runter: KopiereRunterLaufgeschwindigkeit(); break;
    case Innen:  KopiereNachInnenGleichzeitigLaufgeschwindigkeit(); break;
    case Aussen: KopiereNachAussenGleichzeitigLaufgeschwindigkeit(); break;
  }
}

//---------------------------------------------------------------------------

void ZeigeKopiereZehnerEiner(byte ZehnerRichtung, byte EinerRichtung) {
  if (ZufallZuerst==ZehnerZuerst) {
    Richtung=ZehnerRichtung;
    KopiereSpaltenSenkrechtLaufgeschwindigkeit(ZehnerSpalten);
  }

  Richtung=EinerRichtung;
  KopiereSpaltenSenkrechtLaufgeschwindigkeit(EinerSpalten);

  if (ZufallZuerst==!ZehnerZuerst) {
    Richtung=ZehnerRichtung;
    KopiereSpaltenSenkrechtLaufgeschwindigkeit(ZehnerSpalten);
  }
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void SpiralpunktLaufgeschwindigkeit(char Punkt, char Spiegel, byte Bereich) {
  char x, y;
  if (Punkt<99) {
    x=(Punkt%AnzahlLeds)%AnzahlSpalten;
    y=(Punkt%AnzahlLeds)/AnzahlSpalten;
    if (bitRead(Spiegel,0)==1) x=RechteSpalte-x;  // x spiegeln
    if (bitRead(Spiegel,1)==1) y=UntereZeile-y;   // y spiegeln
    byte Punkt2=HolePunkt(SchattenMatrix, x, y);
    if (bitRead(Bereich,0)==1 && Punkt<AnzahlLeds || bitRead(Bereich,1)==1 && Punkt>=AnzahlLeds) {
      if (bitRead(Spiegel,3)==0) SetzePunktHauptMatrix(x,y,1);    // 2=rueckwaerts, 3=Zeigepunkt
      SetzePunktHauptMatrix(x,y,Punkt2);
      if (Punkt<AnzahlLeds  || Bereich==0x02) ZeigeMatrixLaufgeschwindigkeit();
    }
  }
}

//---------------------------------------------------------------------------

void SpiraleLaufgeschwindigkeit(char Nr, char Spiegel, byte Bereich) {
  ZeigeImmer=false;
  char z;
  for (char Durchgang=0; Durchgang<2; Durchgang++) {
    for (char Led=0; Led<AnzahlLeds; Led++) {
      z=pgm_read_byte(Spiralen+AnzahlLeds*Nr+Led);
      if (bitRead(Spiegel,2)) z=pgm_read_byte(Spiralen+AnzahlLeds*Nr+(AnzahlLeds-1)-Led); // rueckwaerts
      SpiralpunktLaufgeschwindigkeit(z, Spiegel,  Bereich);
    }
    Bereich=Bereich^0x03;
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void RotiereSpaltenLinks() {
  char Hilf=SchattenMatrix[LinkeSpalte];
  for (char Spalte=LinkeSpalte; Spalte<RechteSpalte; Spalte++)
    SchattenMatrix[Spalte]=SchattenMatrix[Spalte+1];
  SchattenMatrix[RechteSpalte]=Hilf;
}

//---------------------------------------------------------------------------

void RotiereSpaltenRechts() {
  char Hilf=SchattenMatrix[RechteSpalte];
  for (char Spalte=RechteSpalte; Spalte>LinkeSpalte; Spalte--)
    SchattenMatrix[Spalte]=SchattenMatrix[Spalte-1];
  SchattenMatrix[LinkeSpalte]=Hilf;
}

//---------------------------------------------------------------------------

void RotiereZeilenHoch() {
  char Hilf=HoleZeileSchattenMatrix(ObereZeile);
  for (char Zeile=ObereZeile; Zeile<UntereZeile; Zeile++)
    SetzeZeileSchattenMatrix(Zeile,HoleZeileSchattenMatrix(Zeile+1));
  SetzeZeileSchattenMatrix(UntereZeile, Hilf);
}

//---------------------------------------------------------------------------

void RotiereZeilenRunter() {
  char Hilf=HoleZeileSchattenMatrix(UntereZeile);
  for (char Zeile=UntereZeile; Zeile>ObereZeile; Zeile--)
    SetzeZeileSchattenMatrix(Zeile,HoleZeileSchattenMatrix(Zeile-1));
  SetzeZeileSchattenMatrix(ObereZeile, Hilf);
}

//---------------------------------------------------------------------------

void Rotiere() {
  if (Richtung==Rechts) RotiereSpaltenRechts();
  if (Richtung==Links)  RotiereSpaltenLinks();
  if (Richtung==Hoch)   RotiereZeilenHoch();
  if (Richtung==Runter) RotiereZeilenRunter();
}

//---------------------------------------------------------------------------

void DaumenKinoZehnerLaufgeschwindigkeit(char Zahl, char MaxZehner) {
  char IstZehner=AlteZahl/10;
  char SollZehner=Zahl/10;
  if (IstZehner!=SollZehner) {
    do {
      IstZehner++;
//      if (IstZehner>Max) IstZehner=-3; mit Grad und C
      if (IstZehner>MaxZehner) IstZehner=0;
      if (Richtung>=Hoch) {
        SetzeZahlSchattenMatrix(IstZehner*10);
        SchiebeZehnerLaufgeschwindigkeit();
      } else ZeigeSetzeZehner(IstZehner*10,Laufgeschwindigkeit);
    }
    while (IstZehner!=SollZehner);
  }
  AlteZahl=SollZehner*10+AlteZahl%10;
}

//---------------------------------------------------------------------------

void DaumenKinoEinerLaufgeschwindigkeit(char Zahl) {
  char IstEiner=AlteZahl%10;
  char SollEiner=Zahl%10;
  if (IstEiner!=SollEiner) {
    do {
      IstEiner++;
//      if (IstEiner>9) IstEiner=-3; // mit Grad und C
      if (IstEiner>9) IstEiner=0;
      if (Richtung>=Hoch) {
        SetzeZahlSchattenMatrix(IstEiner);
        SchiebeEinerLaufgeschwindigkeit();
      } else ZeigeSetzeEiner(IstEiner,Laufgeschwindigkeit);
    }
    while (IstEiner!=SollEiner);
  }
  AlteZahl=(AlteZahl/10)*10+SollEiner;
}

//---------------------------------------------------------------------------

void ZaehleZehnerLaufgeschwindigkeit(char Zahl, boolean NurVor) {
  char IstZehner=AlteZahl/10;
  char SollZehner=Zahl/10;
  if (IstZehner!=SollZehner) {
    do {
      if (IstZehner<SollZehner || NurVor==true ) {
        IstZehner++; if(IstZehner>=10) IstZehner=0;
      } else if (IstZehner>SollZehner) IstZehner--;
      SetzeZehner(HauptMatrix,IstZehner);
      ZeigeMatrixLaufgeschwindigkeit();
    }
    while (IstZehner!=SollZehner);
  }
  SetzeZehner(HauptMatrix,SollZehner);
  AlteZahl=SollZehner*10+AlteZahl%10;
}

//---------------------------------------------------------------------------

void ZaehleEinerLaufgeschwindigkeit(char Zahl, boolean NurVor) {
  char IstEiner=AlteZahl%10;
  char SollEiner=Zahl%10;
  if (IstEiner!=SollEiner) {
    do {
      if (IstEiner<SollEiner || NurVor==true ) {
        IstEiner++; if(IstEiner>=10) IstEiner=0;
      } else if (IstEiner>SollEiner) IstEiner--;
      SetzeEiner(HauptMatrix,IstEiner);
      ZeigeMatrixLaufgeschwindigkeit();
    }
    while (IstEiner!=SollEiner);
  }
  SetzeEiner(HauptMatrix,SollEiner);
  AlteZahl=(AlteZahl/10)*10+SollEiner;
}

//---------------------------------------------------------------------------

void SchiebeAbstandLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  SchiebeLeereSpalteLinksHauptMatrix(); break;
    case Rechts: SchiebeLeereSpalteRechtsHauptMatrix(); break;
    case Hoch:   SchiebeSpaltenKodiertHoch1x(HauptMatrix, AlleSpalten, Keinedauer); break;
    case Runter: SchiebeSpaltenKodiertRunter1x(HauptMatrix, AlleSpalten, Keinedauer); break;
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SchiebeAbstandLinksLaufgeschwindigkeit() {
  Richtung=Links;
  SchiebeAbstandLaufgeschwindigkeit();
}
//---------------------------------------------------------------------------

void SchiebeAbstandRechtsLaufgeschwindigkeit() {
  Richtung=Rechts;
  SchiebeAbstandLaufgeschwindigkeit();
}
//---------------------------------------------------------------------------

void SchiebeGrosserAbstandLaufgeschwindigkeit() {
  for (char o=0; o<GrosserAbstand; o++)
    SchiebeAbstandLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SchreibeZifferLaufgeschwindigkeit(char Ziffer, char Posi, byte Dauer) {
  if (Ziffer<0) Ziffer=8-Ziffer;  // 10=Grad (-2), 11=Celsius(-3)
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) SetzeSpalteHauptMatrix(Posi+Spalte, LeerMuster);
  for (char Punkt=0; Punkt<=13; Punkt++) {
    char SchreibPunkt=pgm_read_byte(Schreibzahl+14*Ziffer+Punkt)+Posi;
    if (SchreibPunkt<99) {
      SetzePunktNrHauptMatrix(SchreibPunkt, PunktEin);
      ZeigeMatrix(Dauer);
    }
  }
}

//---------------------------------------------------------------------------

void SchiebeZeichenLaufgeschwindigkeit(char Zeichen) {
  SetzeZehner(SchattenMatrix, Zeichen);
  SetzeEiner(SchattenMatrix, Zeichen);
  SchiebeOftLaufgeschwindigkeit(ZeichenBreite);
}

//---------------------------------------------------------------------------

void SchiebeZeichenLinksLaufgeschwindigkeit(char Zeichen) {
  Richtung=Links;
  SchiebeZeichenLaufgeschwindigkeit(Zeichen);
}

//---------------------------------------------------------------------------

void SchiebeDoppelpunktLaufgeschwindigkeit() {
  if (Richtung<=Rechts) {
    if (Zahl1>=0 && Zahl2>=0)
      SchiebeZeichenLaufgeschwindigkeit(Doppelpunkt);
    else
      SchiebeAbstandLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void SchiebeLeerLaufgeschwindigkeit() {
  LoescheSchattenMatrix();
  SchiebeLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SchiebeLeerLinksLaufgeschwindigkeit() {
  Richtung=Links;
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SchiebeLeerRechtsLaufgeschwindigkeit() {
  Richtung=Rechts;
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void LoescheNachAussenLaufgeschwindigkeit(){
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    SchiebeSpaltenLinksVonBisHauptMatrix(LinkeZehnerSpalte, RechteZehnerSpalte, LeerMuster);
    SchiebeSpaltenRechtsVonBisHauptMatrix(LinkeEinerSpalte, RechteEinerSpalte, LeerMuster);
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void LoescheZehnerEinerNachLinksLaufgeschwindigkeit(){
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    SchiebeSpaltenLinksVonBisHauptMatrix(LinkeZehnerSpalte, RechteZehnerSpalte, LeerMuster);
    ZeigeMatrixLaufgeschwindigkeit();
  }
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void LoescheEinerZehnerNachRechtsLaufgeschwindigkeit(){
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    SchiebeSpaltenRechtsVonBisHauptMatrix(LinkeEinerSpalte, RechteEinerSpalte, LeerMuster);
    ZeigeMatrixLaufgeschwindigkeit();
  }
  Richtung=Rechts;
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void PunktlaufLaufgeschwindigkeit(char x1, char y1, char x2, char y2, char Punkt) {
//  char Dif=max(abs(x1-x2),abs(y1-y2)); Laufgeschwindigkeit=16/(Dif+2)+2;
//  char Dif=max(abs(x1-x2),abs(y1-y2)); Laufgeschwindigkeit=31/(Dif+2);
  while (x1!=x2 || y1!=y2) {
    if (Punkt==PunktEin) {
      SetzePunktHauptMatrix(x1, y1, PunktEin);
      ZeigeMatrixLaufgeschwindigkeit();
    }
    SetzePunktHauptMatrix(x1,y1,PunktAus);
    if (x1<x2) x1++;
    if (x1>x2) x1--;
    if (y1<y2) y1++;
    if (y1>y2) y1--;
    if (Punkt==PunktAus) {
      SetzePunktHauptMatrix(x1,y1,PunktEin);
      ZeigeMatrixLaufgeschwindigkeit();
    }
  }
  SetzePunktHauptMatrix(x2,y2,Punkt);
//  if (Punkt==PunktEin)
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SpaltenLaufenReinLinksLaufgeschwindigkeit() {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    char LaufMuster=SchattenMatrix[Spalte];
    if (LaufMuster!=LeerMuster) {
      for (char LaufSpalte=RechteSpalte; LaufSpalte>=Spalte; LaufSpalte--) {
        HauptMatrix[LaufSpalte]=LaufMuster;
        ZeigeMatrixLaufgeschwindigkeit();
        HauptMatrix[LaufSpalte]=LeerMuster;
      }
    }
    HauptMatrix[Spalte]=LaufMuster;
  }
}

//---------------------------------------------------------------------------

void SpaltenLaufenRausLinksLaufgeschwindigkeit() {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    char LaufMuster=HauptMatrix[Spalte];
    if (LaufMuster!=LeerMuster) {
      for (char LaufSpalte=Spalte; LaufSpalte>=LinkeSpalte; LaufSpalte--) {
        HauptMatrix[LaufSpalte]=LaufMuster;
        ZeigeMatrixLaufgeschwindigkeit();
        HauptMatrix[LaufSpalte]=LeerMuster;
      }
    }
  }
}

//---------------------------------------------------------------------------

void SpaltenLaufenReinRechtsLaufgeschwindigkeit() {
  for (char Spalte=RechteSpalte; Spalte>=LinkeSpalte; Spalte--) {
    char LaufMuster=SchattenMatrix[Spalte];
    if (LaufMuster!=LeerMuster) {
      for (char LaufSpalte=LinkeSpalte; LaufSpalte<=Spalte; LaufSpalte++) {
        HauptMatrix[LaufSpalte]=LaufMuster;
        ZeigeMatrixLaufgeschwindigkeit();
        HauptMatrix[LaufSpalte]=LeerMuster;
      }
    }
    HauptMatrix[Spalte]=LaufMuster;
  }
}

//---------------------------------------------------------------------------

void SpaltenLaufenRausRechtsLaufgeschwindigkeit() {
  for (char Spalte=RechteSpalte; Spalte>=LinkeSpalte; Spalte--) {
    char LaufMuster=HauptMatrix[Spalte];
    if (LaufMuster!=LeerMuster) {
      for (char LaufSpalte=Spalte; LaufSpalte<=RechteSpalte; LaufSpalte++) {
        HauptMatrix[LaufSpalte]=LaufMuster;
        ZeigeMatrixLaufgeschwindigkeit();
        HauptMatrix[LaufSpalte]=LeerMuster;
      }
    }
  }
}

//---------------------------------------------------------------------------

void ZeilenLaufenReinHochLaufgeschwindigkeit() {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    char LaufMuster=HoleZeileSchattenMatrix(Zeile);
    for (char LaufZeile=UntereZeile; LaufZeile>=Zeile; LaufZeile--) {
      SetzeZeileHauptMatrix(LaufZeile, LaufMuster);
      ZeigeMatrixLaufgeschwindigkeit();
      SetzeZeileHauptMatrix(LaufZeile, LeerMuster);
    }
    SetzeZeileHauptMatrix(Zeile, LaufMuster);
  }
}

//---------------------------------------------------------------------------

void ZeilenLaufenRausHochLaufgeschwindigkeit() {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    char LaufMuster=HoleZeileHauptMatrix(Zeile);
    for (char LaufZeile=Zeile; LaufZeile>=ObereZeile; LaufZeile--) {
      SetzeZeileHauptMatrix(LaufZeile, LaufMuster);
      ZeigeMatrixLaufgeschwindigkeit();
      SetzeZeileHauptMatrix(LaufZeile, LeerMuster);
    }
  }
}

//---------------------------------------------------------------------------

void ZeilenLaufenReinRunterLaufgeschwindigkeit() {
  for (char Zeile=UntereZeile; Zeile>=ObereZeile; Zeile--) {
    char LaufMuster=HoleZeileSchattenMatrix(Zeile);
    for (char LaufZeile=ObereZeile; LaufZeile<=Zeile; LaufZeile++) {
      SetzeZeileHauptMatrix(LaufZeile, LaufMuster);
      ZeigeMatrixLaufgeschwindigkeit();
      SetzeZeileHauptMatrix(LaufZeile, LeerMuster);
    }
    SetzeZeileHauptMatrix(Zeile, LaufMuster);
  }
}

//---------------------------------------------------------------------------

void ZeilenLaufenRausRunterLaufgeschwindigkeit() {
  for (char Zeile=UntereZeile; Zeile>=ObereZeile; Zeile--) {
    char LaufMuster=HoleZeileSchattenMatrix( Zeile);
    for (char LaufZeile=Zeile; LaufZeile<=UntereZeile; LaufZeile++) {
      SetzeZeileHauptMatrix(LaufZeile, LaufMuster);
      ZeigeMatrixLaufgeschwindigkeit();
      SetzeZeileHauptMatrix(LaufZeile, LeerMuster);
    }
  }
}

//---------------------------------------------------------------------------

void LaufenReinLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  SpaltenLaufenReinLinksLaufgeschwindigkeit(); break;
    case Rechts: SpaltenLaufenReinRechtsLaufgeschwindigkeit(); break;
    case Hoch:   ZeilenLaufenReinHochLaufgeschwindigkeit(); break;
    case Runter: ZeilenLaufenReinRunterLaufgeschwindigkeit(); break;
  }
}

//---------------------------------------------------------------------------

void LaufenRausLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  SpaltenLaufenRausLinksLaufgeschwindigkeit(); break;
    case Rechts: SpaltenLaufenRausRechtsLaufgeschwindigkeit(); break;
    case Hoch:   ZeilenLaufenRausHochLaufgeschwindigkeit(); break;
    case Runter: ZeilenLaufenRausRunterLaufgeschwindigkeit(); break;
  }
}

//---------------------------------------------------------------------------

void ZeigeLaufenReinRaus() {
  LaufenReinLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer();
  LaufenRausLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SchichteSpaltenLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  Richtung=Richtung2;
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  byte BitSpalte;
  if (Richtung1==Links) BitSpalte=bit(LinkeSpalte); else BitSpalte=bit(RechteSpalte);
  do {
    if (BitSpalte!=bit(MitteSpalte))
      SchiebeSpalten6xHochRunterLaufgeschwindigkeit(BitSpalte);
    if (Richtung1==Links) BitSpalte=BitSpalte<<1; else BitSpalte=BitSpalte>>1;
  } while ((BitSpalte&AlleSpalten)!=0);
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SchichteZeilenLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  Richtung=Richtung2;
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  byte BitZeile;
  if (Richtung1==Runter) BitZeile=bit(ObereZeile); else BitZeile=bit(UntereZeile);
  do {
    SchiebeZeilenKodiert6xLaufgeschwindigkeit(BitZeile);
    if (Richtung1==Runter) BitZeile=BitZeile<<1; else BitZeile=BitZeile>>1;
  } while ((BitZeile&AlleZeilen)!=0);
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void FuelleSpaltenLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  char BitSpalte=bit(LinkeSpalte);
  if (Richtung1==Links) BitSpalte=bit(RechteSpalte);
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    Richtung=Richtung1;
    SchiebeAbstandLaufgeschwindigkeit();
    Rotiere();
    if (Spalte!=MitteSpalte) {
      Richtung=Richtung2;
      SchiebeSpalten6xHochRunterLaufgeschwindigkeit(BitSpalte);
    } else ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void LeereSpaltenLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  char BitSpalte=bit(LinkeSpalte);
  if (Richtung1==Rechts) BitSpalte=bit(RechteSpalte);
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    if (Spalte!=MitteSpalte) {
      Richtung=Richtung2;
      SchiebeSpalten6xHochRunterLaufgeschwindigkeit(BitSpalte);
    } else ZeigeMatrixLaufgeschwindigkeit();
    Richtung=Richtung1;
    SchiebeAbstandLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void FuelleZeilenLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  char BitZeile=bit(ObereZeile);
  if (Richtung1==Hoch) BitZeile=bit(UntereZeile);
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    Richtung=Richtung1;
    SchiebeAbstandLaufgeschwindigkeit();
    Rotiere();
    Richtung=Richtung2;
    SchiebeZeilenKodiert6xLaufgeschwindigkeit(BitZeile);
  }
}

//---------------------------------------------------------------------------

void LeereZeilenLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  char BitZeile=bit(ObereZeile);
  if (Richtung1==Runter) BitZeile=bit(UntereZeile);
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    Richtung=Richtung2;
    SchiebeZeilenKodiert6xLaufgeschwindigkeit(BitZeile);
    Richtung=Richtung1;
    SchiebeAbstandLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void KopierePunkteLaufgeschwindigkeit(char x1, char y1, char Spiegel) {
  char x2=RechteSpalte-x1;  // gegenueber
  char y2=UntereZeile-y1;
  if (bitRead(Spiegel,0)) { x1=RechteSpalte-x1; x2=RechteSpalte-x2; } // x spiegeln
  if (bitRead(Spiegel,1)) { y1=UntereZeile-y1;  y2=UntereZeile-y2; }  // y spiegeln
  char x=x1, y=y1;
  char Abbruch=false;
  while(Abbruch==false) {
    SetzeKopierePunktLaufgeschwindigkeit(x, y, PunktKopier);
    if (x==x2 && y==y2) Abbruch=true;
    if (bitRead(Spiegel,2)==0) {
      if (x==x2)
        {x=x1; if (y<y2) y++; if (y>y2) y--; }
      else
        {if (x<x2) x++; if (x>x2) x--; }
    } else {
      if (y==y2)
        {y=y1; if (x<x2) x++; if (x>x2) x--; }
      else
        {if (y<y2) y++; if (y>y2) y--; }
    }
  }
}

//---------------------------------------------------------------------------

void KarteAuflegenLinksLaufgeschwindigkeit() {
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
      for (char KopierSpalte=0; KopierSpalte<=Spalte; KopierSpalte++)
        SetzeSpalteHauptMatrix(RechteSpalte-Spalte+KopierSpalte,HoleSpalteSchattenMatrix(KopierSpalte));
      ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteAuflegenRechtsLaufgeschwindigkeit() {
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
      for (char KopierSpalte=0; KopierSpalte<=Spalte; KopierSpalte++)
        SetzeSpalteHauptMatrix(KopierSpalte,HoleSpalteSchattenMatrix(RechteSpalte-Spalte+KopierSpalte));
      ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteAuflegenHochLaufgeschwindigkeit() {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    for (char KopierZeile=0; KopierZeile<=Zeile; KopierZeile++)
      SetzeZeileHauptMatrix(UntereZeile-Zeile+KopierZeile,HoleZeileSchattenMatrix(KopierZeile));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteAuflegenRunterLaufgeschwindigkeit() {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    for (char KopierZeile=0; KopierZeile<=Zeile; KopierZeile++)
      SetzeZeileHauptMatrix(KopierZeile,HoleZeileSchattenMatrix(UntereZeile-Zeile+KopierZeile));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteAuflegenLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  KarteAuflegenLinksLaufgeschwindigkeit(); break;
    case Rechts: KarteAuflegenRechtsLaufgeschwindigkeit(); break;
    case Hoch:   KarteAuflegenHochLaufgeschwindigkeit(); break;
    case Runter: KarteAuflegenRunterLaufgeschwindigkeit(); break;
  }
}

//---------------------------------------------------------------------------

void KarteWegnehmenLinksLaufgeschwindigkeit() {
  SchiebeLeereSpalteLinksHauptMatrix();
  ZeigeMatrixLaufgeschwindigkeit();
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    SchiebeLeereSpalteLinksHauptMatrix();
    for (char KopierSpalte=0; KopierSpalte<=Spalte; KopierSpalte++)
      SetzeSpalteHauptMatrix(RechteSpalte-KopierSpalte,HoleSpalteSchattenMatrix(RechteSpalte-KopierSpalte));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteWegnehmenRechtsLaufgeschwindigkeit() {
  SchiebeLeereSpalteRechtsHauptMatrix();
  ZeigeMatrixLaufgeschwindigkeit();
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    SchiebeLeereSpalteRechtsHauptMatrix();
    for (char KopierSpalte=0; KopierSpalte<=Spalte; KopierSpalte++)
      SetzeSpalteHauptMatrix(KopierSpalte,HoleSpalteSchattenMatrix(KopierSpalte));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteWegnehmenHochLaufgeschwindigkeit() {
  SchiebeLeereZeileHochHauptMatrix();
  ZeigeMatrixLaufgeschwindigkeit();
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    SchiebeLeereZeileHochHauptMatrix();
    for (char KopierZeile=0; KopierZeile<=Zeile; KopierZeile++)
      SetzeZeileHauptMatrix(UntereZeile-KopierZeile,HoleZeileSchattenMatrix(UntereZeile-KopierZeile));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteWegnehmenRunterLaufgeschwindigkeit() {
  SchiebeLeereZeileRunterHauptMatrix();
  ZeigeMatrixLaufgeschwindigkeit();
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    SchiebeLeereZeileRunterHauptMatrix();
    for (char KopierZeile=0; KopierZeile<=Zeile; KopierZeile++)
      SetzeZeileHauptMatrix(KopierZeile,HoleZeileSchattenMatrix(KopierZeile));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void KarteWegnehmenLaufgeschwindigkeit() {
  switch(Richtung) {
    case Links:  KarteWegnehmenLinksLaufgeschwindigkeit(); break;
    case Rechts: KarteWegnehmenRechtsLaufgeschwindigkeit(); break;
    case Hoch:   KarteWegnehmenHochLaufgeschwindigkeit(); break;
    case Runter: KarteWegnehmenRunterLaufgeschwindigkeit(); break;
  }
}

//---------------------------------------------------------------------------

void VorhangLaufgeschwindigkeit(const byte Muster[]) {
  byte HilfsMuster=Muster[0];
  Balken=Muster[2];
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    SetzeZeileSchattenMatrix(Zeile, HilfsMuster);
    HilfsMuster=HilfsMuster^Muster[1];
  }
  KopiereLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void SpaltenRauteLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  unsigned long SchiebeSpalten=0x0FC0;
  Richtung=Richtung1;
  for (char Zeile=0; Zeile<AnzahlZeilen+AnzahlSpalten; Zeile++) {
    if (Richtung2==Links) {
      SchiebeSpaltenHochRunterKodiertLaufgeschwindigkeit(1, lowByte(SchiebeSpalten));
      SchiebeSpalten=SchiebeSpalten>>1;
    } else {
      SchiebeSpaltenHochRunterKodiertLaufgeschwindigkeit(1, lowByte(SchiebeSpalten>>11));
      SchiebeSpalten=SchiebeSpalten<<1;
    }
  }
}

//---------------------------------------------------------------------------

void ZeilenRauteLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  unsigned long SchiebeZeilen=0x07F0;
  Richtung=Richtung1;
  for (char Zeile=0; Zeile<AnzahlZeilen+AnzahlSpalten; Zeile++) {
    if (Richtung2==Hoch) {
      SchiebeZeilenKodiert(lowByte(SchiebeZeilen), Laufgeschwindigkeit);
      SchiebeZeilen=SchiebeZeilen>>1;
    } else {
      SchiebeZeilenKodiert(lowByte(SchiebeZeilen>>11), Laufgeschwindigkeit);
      SchiebeZeilen=SchiebeZeilen<<1;
    }
  }
}

//---------------------------------------------------------------------------

void RauteLaufgeschwindigkeit(byte Richtung1, byte Richtung2) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  switch (Richtung1) {
    case Links:
    case Rechts: ZeilenRauteLaufgeschwindigkeit(Richtung1, Richtung2); break;
    case Hoch:
    case Runter: SpaltenRauteLaufgeschwindigkeit(Richtung1, Richtung2); break;
  }
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeText(char const *Text, boolean Pause, boolean Leeren) {
  char Muster;
  do {
    Muster=pgm_read_byte(Text);
    if (Muster!=Ende) {
      SchiebeAbstandLinksLaufgeschwindigkeit();
      SchiebeZeichenLinksLaufgeschwindigkeit(Muster);
      if (Pause) ZeigeMatrixZeigedauer();
    }
    Text++;
  } while(Muster!=Ende);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  if (Leeren==true) SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

int TagImJahr(char Tag, char Monat, char Jahr) {
  int Tage=Tag;
  for (char m=0; m<Monat-1; m++) Tage=Tage+MaxTage[m];
  if ((Jahr%4)==0 && Monat>=3) Tage++;
  return Tage;
}

//---------------------------------------------------------------------------

char WocheImJahr(void) {
  int Tage=TagImJahr(Tag, Monat, Jahr);
  int Do=WochenTag(1,1,Jahr);
  if (Do>=4) Tage=Tage+Do-1; else Tage=Tage+Do+6; //01.01. >= Donnerstag
  char Woche=Tage/Wochentage; if(Woche==0) Woche=53;
  return Woche;
}

//---------------------------------------------------------------------------

void MachePause(){
  LoescheHauptMatrix();
  if (PauseOk==true) ZeigeMatrixPausendauer();
}

//---------------------------------------------------------------------------

void Stelle(char &Was, char Trenner, char Min, char Max) {
  Was=constrain(Was, Min, Max);
  if (StellDelta==1) {
    Was=Was+StellDelta;
    if (Was>Max) Was=Min;
    StellDelta=0;
    if (Modus>=ZeitStellModus && Modus<= ZeitStellModus+4) UhrWurdeGestellt=true;
  }
  if (StellDelta==-1) {
    Was=Was+StellDelta;
    if (Was<Min) Was=Max;
    StellDelta=0;
    if (Modus>=ZeitStellModus && Modus<= ZeitStellModus+4) UhrWurdeGestellt=true;
  }
  if (BlinkCount>MaxBlinkCount/2) Trenner=0;
  if (Modus==WeckerStellModus)   {
    SetzeZeichen(HauptMatrix, WochenTagTexte[WeckerWTag][0], ZehnerPos);
    SetzeSpalteHauptMatrix(TrennerPos, Trenner);
    SetzeZeichen(HauptMatrix, WochenTagTexte[WeckerWTag][1], EinerPos);
  }
  else  {
    if (Modus==WeckerStellModus+1)   {
      SetzeSpalteHauptMatrix(TrennerPos, Trenner);
      if (WeckerEinAus[WeckerWTag]==WeckerAus)
        SetzeZeichen(HauptMatrix, _A, EinerPos);
      else
        SetzeZeichen(HauptMatrix, _E, EinerPos);
    }
    else {
      SetzeZahl(HauptMatrix, Was, Trenner);
    }
  }
  ZeigeMatrix(byte(StellZeigeZeit));
  if (millis()-Moduszeit>MaxModusZeit) {
    Modus=0;
  }
}

//---------------------------------------------------------------------------

void Vorbereitung() {
  LoescheHauptMatrix();
  LoescheSchattenMatrix();
  Pausendauer=60*ZeitLupe/ZeitRaffer;
  Zeigedauer=60*ZeitLupe/ZeitRaffer;
  Laufgeschwindigkeit=MaxVariLaufgeschwindigkeit*ZeitLupe/ZeitRaffer;
  Nullunterdrueckung=false;
  PauseOk=true;
  AlteZahl=0;
  Balken=KeinBalken;
  Richtung=Links;
  ZeigeImmer=true;
  BildVersatz=0;
  byte Zufall=Random(127); // 128 ???
  ZufallWaagerecht1=bitRead(Zufall,0);
  ZufallWaagerecht2=bitRead(Zufall,1);
  ZufallSenkrecht1=ZufallWaagerecht1+2;
  ZufallSenkrecht2=ZufallWaagerecht2+2;
  Zufall4Richtungen=Random(4);
  Zufall6Richtungen=Random(6);
  Zufall10Richtungen=Random(10);
  ZufallArt16=Random(16);
  ZufallZuerst=bitRead(Zufall,2);
  ZufallBoolean1=bitRead(Zufall,3);
  ZufallBoolean2=bitRead(Zufall,4);
  ZufallBoolean3=bitRead(Zufall,5);
  if (Modus==0) HoleUhr();
  Zahl1=Stunden; Zahl2=Minuten;
}

//---------------------------------------------------------------------------
// Zeige Zahlen
//---------------------------------------------------------------------------

void TauscheZahlen() {
  Tausche(Zahl1, Zahl2);
}

//---------------------------------------------------------------------------

void SchiebeZahlLaufgeschwindigkeit(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeLaufgeschwindigkeit();
}


//---------------------------------------------------------------------------

void SchiebeZeigeZahl(char Zahl) {
  SchiebeZahlLaufgeschwindigkeit(Zahl);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void SchiebeZeigeZahlLinks(char Zahl) {
  Richtung=Links;
  SchiebeZeigeZahl(Zahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlen() {
  SchiebeZeigeZahl(Zahl1);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahl(Zahl2);
  SchiebeZahlLaufgeschwindigkeit(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenLinksLinksRechts() {
  SchiebeZeigeZahlLinks(Zahl1);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahlLinks(Zahl2);
  Richtung=Rechts;
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahl(Zahl1);
  SchiebeZahlLaufgeschwindigkeit(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenRechtsRechtsLinks() {
  Richtung=Rechts;
  SchiebeZeigeZahl(Zahl2);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahl(Zahl1);
  Richtung=Links;
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahl(Zahl2);
  SchiebeZahlLaufgeschwindigkeit(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSenkrechtLinksSenkrecht(byte Richtung1, byte Richtung2) {
  Richtung=Richtung1;
  SchiebeZeigeZahl(Zahl1);
  Richtung=Links;
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahl(Zahl2);
  Richtung=Richtung2;
  SchiebeZahlLaufgeschwindigkeit(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSenkrechtRechtsSenkrecht(byte Richtung1, byte Richtung2) {
  Richtung=Richtung1;
  SchiebeZeigeZahl(Zahl1);
  Richtung=Rechts;
  SchiebeDoppelpunktLaufgeschwindigkeit();
  SchiebeZeigeZahl(Zahl2);
  Richtung=Richtung2;
  SchiebeZahlLaufgeschwindigkeit(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSetzen() {
  ZeigeSetzeZahlHauptMatrix(Zahl1);
  ZeigeSetzeZahlHauptMatrix(Zahl2);
  ZeigeSetzeZahlHauptMatrix(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSetzenZehnerEiner() {
  ZeigeSetzeZahlZehnerEiner(Zahl1);
  ZeigeSetzeZahlZehnerEiner(Zahl2);
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlZehnerLinksEiner(byte ZehnerRichtung, byte EinerRichtung, char Zahl) {
  SetzeEiner(SchattenMatrix, Zahl/10);
  Richtung=ZehnerRichtung;
  SchiebeEinerLaufgeschwindigkeit();
  Richtung=Links;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  SetzeZahlSchattenMatrix(Zahl);
  Richtung=EinerRichtung;
  SchiebeEinerLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlEinerRechtsZehner(byte EinerRichtung, byte ZehnerRichtung, char Zahl) {
  SetzeZehner(SchattenMatrix, Zahl%10);
  Richtung=EinerRichtung;
  SchiebeZehnerLaufgeschwindigkeit();
  Richtung=Rechts;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  SetzeZahlSchattenMatrix(Zahl);
  Richtung=ZehnerRichtung;
  SchiebeZehnerLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenEinerRechtsZehner(byte Richtung1, byte Richtung2) {
  ZeigeZahlEinerRechtsZehner(Richtung1, Richtung2, Zahl1);
  Richtung=Rechts;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  ZeigeZahlEinerRechtsZehner(Richtung1, Richtung2, Zahl2);
  SchiebeLeerRechtsLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlSchiebeZehnerEiner(byte ZehnerRichtung, byte EinerRichtung, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  if (ZufallZuerst==ZehnerZuerst) {
    Richtung=ZehnerRichtung;
    SchiebeZehnerLaufgeschwindigkeit();
  }
  Richtung=EinerRichtung;
  SchiebeEinerLaufgeschwindigkeit();
  if (ZufallZuerst==!ZehnerZuerst) {
    Richtung=ZehnerRichtung;
    SchiebeZehnerLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeZehnerEiner(byte ZehnerRichtung, byte EinerRichtung) {
  ZeigeZahlSchiebeZehnerEiner(ZehnerRichtung, EinerRichtung, Zahl1);
  ZeigeZahlSchiebeZehnerEiner(ZehnerRichtung, EinerRichtung, Zahl2);
  ZeigeZahlSchiebeZehnerEiner(ZehnerRichtung, EinerRichtung, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlSchiebeZehnerEinerGleichzeitig(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeZehnerEinerGleichzeitigLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeZehnerEinerGleichzeitig() {
  ZeigeZahlSchiebeZehnerEinerGleichzeitig(Zahl1);
  ZeigeZahlSchiebeZehnerEinerGleichzeitig(Zahl2);
  ZeigeZahlSchiebeZehnerEinerGleichzeitig(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenZehnerLinksEiner(byte Richtung1, byte Richtung2) {
  ZeigeZahlZehnerLinksEiner(Richtung1, Richtung2, Zahl1);
  Richtung=Links;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  ZeigeZahlZehnerLinksEiner(Richtung1, Richtung2, Zahl2);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlSchreibe(char Zahl) {
  if(ZufallZuerst==ZehnerZuerst) SchreibeZifferLaufgeschwindigkeit(Zahl/10, ZehnerPos, Laufgeschwindigkeit);
  SchreibeZifferLaufgeschwindigkeit(Zahl%10, EinerPos, Laufgeschwindigkeit);
  if(ZufallZuerst==!ZehnerZuerst) SchreibeZifferLaufgeschwindigkeit(Zahl/10, ZehnerPos, Laufgeschwindigkeit);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchreibeZehnerEiner() {
  ZeigeZahlSchreibe(Zahl1);
  ZeigeZahlSchreibe(Zahl2);
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeBisZahlZaehle(char Zahl) {
  char z=AlteZahl;
  do {
    if (z<Zahl) z++;
    if (z>Zahl) z--;
    SetzeNeueLaufgeschwindigkeit(max(18-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    SetzeZahlHauptMatrix(z);
    ZeigeMatrixLaufgeschwindigkeit();
    ZurueckZurAltenLaufgeschwindigkeit();
  } while (z!=Zahl);
  ZeigeMatrixZeigedauer();
  AlteZahl=Zahl;
}

//---------------------------------------------------------------------------

void ZeigeZahlHexadezimal(char Zahl) {
  SchiebeZeichenLinksLaufgeschwindigkeit(0);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(_x);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(Zahl/16);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(Zahl%16);
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeZahlOktal(char Zahl) {
  SchiebeZeichenLinksLaufgeschwindigkeit(0);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(Zahl/8);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(Zahl%8);
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeZahlSchiebeSpalten124(unsigned long Spalten, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeSpalten6xHochRunterLaufgeschwindigkeit(Spalten);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeSpalten124(unsigned long Spalten) {
  ZeigeZahlSchiebeSpalten124(Spalten, Zahl1);
  ZeigeZahlSchiebeSpalten124(Spalten, Zahl2);
  ZeigeZahlSchiebeSpalten124(Spalten, LeerZahl);
}
//---------------------------------------------------------------------------

void ZeigeZahlSchiebeSpalten12(byte Spalten, byte Richtung1, byte Richtung2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeSpalten12(Spalten, Richtung1, Richtung2);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeSpalten25(byte Spalten, byte Richtung1, byte Richtung2) {
  ZeigeZahlSchiebeSpalten12(Spalten, Richtung1, Richtung2, Zahl1);
  ZeigeZahlSchiebeSpalten12(Spalten, Richtung1, Richtung2, Zahl2);
  ZeigeZahlSchiebeSpalten12(Spalten, Richtung1, Richtung2, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlSchiebeSpalten25Gleichzeitig(byte Spalten, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeSpalten25GleichzeitigLaufgeschwindigkeit(Spalten);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeSpalten25Gleichzeitig(byte Spalten) {
  ZeigeZahlSchiebeSpalten25Gleichzeitig(Spalten, Zahl1);
  ZeigeZahlSchiebeSpalten25Gleichzeitig(Spalten, Zahl2);
  ZeigeZahlSchiebeSpalten25Gleichzeitig(Spalten, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlTauschen(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  for (char Spalte=RechteSpalte; Spalte>=LinkeSpalte; Spalte--) {
    LoescheHauptMatrix();
    for (char TauschSpalte=0; TauschSpalte<MitteSpalte; TauschSpalte++) {
      if (Spalte+TauschSpalte<=RechteSpalte) {
        HauptMatrix[Spalte+TauschSpalte]=HauptMatrix[Spalte+TauschSpalte] | SchattenMatrix[TauschSpalte];
        HauptMatrix[RechteSpalte-Spalte-TauschSpalte]=HauptMatrix[RechteSpalte-Spalte-TauschSpalte] | SchattenMatrix[RechteSpalte-TauschSpalte];
      }
    }
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer();
  LoescheNachAussenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlenTauschen() {
  ZeigeZahlTauschen(Zahl1);
  ZeigeZahlTauschen(Zahl2);
}

//---------------------------------------------------------------------------

void ZahlKopiereLaufgeschwindigkeit(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KopiereLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlKopiere(char Zahl) {
  ZahlKopiereLaufgeschwindigkeit(Zahl);
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeZahlenKopieren() {
  ZeigeZahlKopiere(Zahl1);
  ZeigeZahlKopiere(Zahl2);
  ZahlKopiereLaufgeschwindigkeit(LeerZahl);
}

//--------------------------------------------------------------------------

void ZeigeZahlenHinHer() {
  Balken=AlleSpalten;
  ZeigeZahlKopiere(Zahl1);
  RichtungUmkehr();
  ZeigeZahlKopiere(Zahl2);
  RichtungUmkehr();
  ZahlKopiereLaufgeschwindigkeit(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlKopiereNachGleichzeitig(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KopiereNachGleichzeitigLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenKopiereNachGleichzeitig() {
  ZeigeZahlKopiereNachGleichzeitig(Zahl1);
  ZeigeZahlKopiereNachGleichzeitig(Zahl2);
  ZeigeZahlKopiereNachGleichzeitig(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlKopiereZehnerEiner(byte ZehnerRichtung, byte EinerRichtung, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  ZeigeKopiereZehnerEiner(ZehnerRichtung, EinerRichtung);
}

//---------------------------------------------------------------------------

void ZeigeZahlenKopiereZehnerEiner(byte ZehnerRichtung, byte EinerRichtung) {
  ZeigeZahlKopiereZehnerEiner(ZehnerRichtung, EinerRichtung, Zahl1);
  ZeigeZahlKopiereZehnerEiner(ZehnerRichtung, EinerRichtung, Zahl2);
  ZeigeZahlKopiereZehnerEiner(ZehnerRichtung, EinerRichtung, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlPunkteZufall(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  PunkteZufallLaufgeschwindigkeit(LinkeSpalte, RechteSpalte);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenPunkteZufall() {
//  ZeigeImmer=false;
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  ZeigeZahlPunkteZufall(Zahl1);
  ZeigeZahlPunkteZufall(Zahl2);
  ZeigeZahlPunkteZufall(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlZehnerEinerPunkteZufall(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  ZehnerEinerPunkteZufallLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenZehnerEinerPunkteZufall() {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  ZeigeZahlZehnerEinerPunkteZufall(Zahl1);
  ZeigeZahlZehnerEinerPunkteZufall(Zahl2);
  ZeigeZahlZehnerEinerPunkteZufall(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlSpaltenZufall(boolean Schieben, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SpaltenZufallLaufgeschwindigkeit(Schieben);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSpaltenZufall(boolean Schieben) {
  ZeigeZahlSpaltenZufall(Schieben, Zahl1);
  ZeigeZahlSpaltenZufall(Schieben, Zahl2);
  ZeigeZahlSpaltenZufall(Schieben, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlZeilenZufall(boolean Schieben, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  ZeilenZufallLaufgeschwindigkeit(Schieben);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenZeilenZufall(boolean Schieben) {
  ZeigeZahlZeilenZufall(Schieben, Zahl1);
  ZeigeZahlZeilenZufall(Schieben, Zahl2);
  ZeigeZahlZeilenZufall(Schieben, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeBisZahlZufall(char Zahl, char Max, char Oft) {
  while (Oft>0) {
    char Zufall=Random(Max);
    if (Zufall/10!=Zahl/10 && Zufall%10!=Zahl%10) {
      SetzeZahlHauptMatrix(Zufall);
      ZeigeMatrixLaufgeschwindigkeit();
    }
    Oft--;
  }
  LoescheHauptMatrix();
  ZeigeSetzeZahlHauptMatrix(Zahl);
}

//---------------------------------------------------------------------------

void ZeigeBisZahlZufallZehnerEiner(char Zahl, char Max, char Oft) {
  char Oft2=Oft;
  char AltZufall=0;
  while (Oft>0) {
    char Zufall=Random(Max);
    if (Zufall/10!=Zahl/10 && Zufall%10!=Zahl%10 && Zufall/10!=AltZufall/10 && Zufall%10!=AltZufall%10) {
      AltZufall=Zufall;
      ZeigeSetzeZehnerEiner(Zufall, Laufgeschwindigkeit);
    }
    Oft--;
  }
  ZeigeSetzeZehnerEiner(Zahl, Laufgeschwindigkeit);

  ZufallZuerstUmkehr();
  while (Oft2>0) {
    char Zufall=Random(Max);
    if (Zufall/10!=Zahl/10 && Zufall%10!=Zahl%10 && Zufall/10!=AltZufall/10 && Zufall%10!=AltZufall%10) {
      AltZufall=Zufall;
      ZeigeSetzeZehnerEiner(Zufall, Laufgeschwindigkeit);
    }
    Oft2--;
  }
  ZufallZuerstUmkehr();
  ZeigeSetzeZahlHauptMatrix(Zahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlZehnerLinksEinerLinks(char Zahl) {
  SetzeZehner(SchattenMatrix,Zahl/10);
  Richtung=Links;
  SchiebeAlleSpaltenLinksRechtsLaufgeschwindigkeit();
  SetzeEiner(SchattenMatrix,Zahl%10);
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    SchiebeSpaltenLinksVonBisHauptMatrix(LinkeEinerSpalte, RechteEinerSpalte,
      SchiebeSpaltenLinksVonBisSchattenMatrix(LinkeEinerSpalte, RechteEinerSpalte, LeerMuster));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenZehnerLinksEinerLinks() {
  ZeigeZahlZehnerLinksEinerLinks(Zahl1);
  LoescheZehnerEinerNachLinksLaufgeschwindigkeit();
  ZeigeZahlZehnerLinksEinerLinks(Zahl2);
  LoescheZehnerEinerNachLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlEinerRechtsZehnerRechts(char Zahl) {
  SetzeEiner(SchattenMatrix,Zahl%10);
  Richtung=Rechts;
  SchiebeAlleSpaltenLinksRechtsLaufgeschwindigkeit();
  SetzeZehner(SchattenMatrix,Zahl/10);
  for (char Spalte=0; Spalte<ZeichenBreite; Spalte++) {
    SchiebeSpaltenRechtsVonBisHauptMatrix(LinkeZehnerSpalte,RechteZehnerSpalte,
      SchiebeSpaltenRechtsVonBisSchattenMatrix(LinkeZehnerSpalte, RechteZehnerSpalte, LeerMuster));
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenEinerRechtsZehnerRechts() {
  ZeigeZahlEinerRechtsZehnerRechts(Zahl1);
  LoescheEinerZehnerNachRechtsLaufgeschwindigkeit();
  ZeigeZahlEinerRechtsZehnerRechts(Zahl2);
  LoescheEinerZehnerNachRechtsLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlSpirale(char Nr, char Art, byte Bereich, char Zahl) {
  if (Nr>=AnzahlEnfachSpiralen) Art=8+Art%4;
  SetzeZahlSchattenMatrix(Zahl);
  SpiraleLaufgeschwindigkeit(Nr, Art, Bereich);
  ZeigeMatrixZeigedauer();
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  SetzeZahlSchattenMatrix(LeerZahl);
  SpiraleLaufgeschwindigkeit(Nr, Art, Bereich);
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlenSpirale(char Nr, char Art) {
  byte Bereich=Random(4);
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  ZeigeZahlSpirale(Nr, Art, Bereich, Zahl1);
  ZeigeZahlSpirale(Nr, Art, Bereich, Zahl2);
}

//---------------------------------------------------------------------------

void ZeigeZahlZehnerVonRechtsEiner(char EinerRichtung, char Zahl) {
  SchiebeZeichenLinksLaufgeschwindigkeit(Zahl/10);
  Richtung=Links;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  SetzeZahlSchattenMatrix(Zahl);
  Richtung=EinerRichtung;
  SchiebeEinerLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenZehnerVonRechtsEiner(char ZehnerRichtung) {
  ZeigeZahlZehnerVonRechtsEiner(ZehnerRichtung, Zahl1);
  Richtung=Links;
  SchiebeAbstandLaufgeschwindigkeit();
//  SchiebeLeerLinksLaufgeschwindigkeit();
  ZeigeZahlZehnerVonRechtsEiner(ZehnerRichtung, Zahl2);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlEinerVonLinksZehner(char ZehnerRichtung, char Zahl) {
  Richtung=Rechts;
  SchiebeZeichenLaufgeschwindigkeit(Zahl%10);
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  SetzeZahlSchattenMatrix(Zahl);
  Richtung=ZehnerRichtung;
  SchiebeZehnerLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenEinerVonLinksZehner(char ZehnerRichtung) {
  ZeigeZahlEinerVonLinksZehner(ZehnerRichtung, Zahl2);
//  SchiebeAbstandRechts();
  SchiebeLeerRechtsLaufgeschwindigkeit();
  ZeigeZahlEinerVonLinksZehner(ZehnerRichtung, Zahl1);
  SchiebeLeerRechtsLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlenLaufenReinRaus() {
  SetzeZahlSchattenMatrix(Zahl1); ZeigeLaufenReinRaus();
  SetzeZahlSchattenMatrix(Zahl2); ZeigeLaufenReinRaus();
}

//---------------------------------------------------------------------------

void ZeigeBisZahlTacho(char Zahl) {
  char z=AlteZahl;
  byte RichtungTacho=Richtung;
  SetzeZahlHauptMatrix(z);
  while (z!=Zahl) {
    AlteZahl=z;
    if (z<Zahl) { z++; Richtung=RichtungTacho; }
    if (z>Zahl) { z--; Richtung=RichtungTacho^1; }
    byte Spalten=EinerSpalten;
    if (AlteZahl/10!=z/10) Spalten=Spalten | ZehnerSpalten;
    SetzeNeueLaufgeschwindigkeit(max(MaxVariLaufgeschwindigkeit-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    SetzeZahlSchattenMatrix(z);
    SchiebeSpalten6xHochRunterLaufgeschwindigkeit(Spalten);
    ZurueckZurAltenLaufgeschwindigkeit();
    ZeigeMatrixLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer();
  AlteZahl=Zahl;
//  Richtung=RichtungTacho;
}

//---------------------------------------------------------------------------

void ZeigeBisZahlDaumenKinoZehnerEiner(char Zahl, char MaxZehner) {
  SetzeZahlHauptMatrix(AlteZahl);
  ZeigeMatrixLaufgeschwindigkeit();
  if (ZufallZuerst==ZehnerZuerst) DaumenKinoZehnerLaufgeschwindigkeit(Zahl, MaxZehner);
  DaumenKinoEinerLaufgeschwindigkeit(Zahl);
  if (ZufallZuerst==!ZehnerZuerst) DaumenKinoZehnerLaufgeschwindigkeit(Zahl, MaxZehner);
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeBisZahlZaehleZehnerEiner(char Zahl, boolean NurVor) {
  if (ZufallZuerst==ZehnerZuerst) ZaehleZehnerLaufgeschwindigkeit(Zahl, NurVor);
  ZaehleEinerLaufgeschwindigkeit(Zahl, NurVor);
  if (ZufallZuerst==!ZehnerZuerst) ZaehleZehnerLaufgeschwindigkeit(Zahl, NurVor);
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeBisZahlKodiertaster(char Zahl, char Max) {
  SetzeZahlHauptMatrix(AlteZahl);
  ZeigeMatrixLaufgeschwindigkeit();
  if (ZufallZuerst==ZehnerZuerst) KodierTasterZehnerLaufgeschwindigkeit(Zahl, Max);
  KodierTasterEinerLaufgeschwindigkeit(Zahl);
  if (ZufallZuerst==!ZehnerZuerst) KodierTasterZehnerLaufgeschwindigkeit(Zahl, Max);
  ZeigeMatrixZeigedauer();
  AlteZahl=Zahl;
}

//---------------------------------------------------------------------------

void ZeigeBisZahlFlughafen(char Zahl, boolean Nullstellen) {
  char Zehner=Zahl/10;
  char Einer=Zahl%10;
  char z;
  byte Spalten;
  for (z=-1; z<=9; z++) {
//    SetzeNeueLaufgeschwindigkeit(max(MaxVariLaufgeschwindigkeit-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    LoescheSchattenMatrix();
    if (z>=0) SetzeZahlSchattenMatrix(z*11);
    Spalten=0;
    if (Zehner>=z) Spalten=Spalten | ZehnerSpalten;
    if (Einer>=z) Spalten=Spalten | EinerSpalten;
    if (Spalten>0) {
      SchiebeSpalten6xHochRunterLaufgeschwindigkeit(Spalten);
    }
  }
  ZeigeMatrixZeigedauer();

  if (Nullstellen==true) {
    for (z=min(Einer,Zehner); z<=10; z++) {
      Spalten=0;
      LoescheSchattenMatrix();
      if (z<10) SetzeZahlSchattenMatrix(z*11);
      if (Zehner<z) { Spalten=Spalten | ZehnerSpalten; Zehner++; }
      if (Einer<z)  { Spalten=Spalten | EinerSpalten;  Einer++; }
      if (Spalten>0) {
        SchiebeSpalten6xHochRunterLaufgeschwindigkeit(Spalten);
        ZeigeMatrixLaufgeschwindigkeit();
      }
    }
  }
}

//---------------------------------------------------------------------------

void ZeigeZahlKopierePunkte(char x, char y, char Art, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KopierePunkteLaufgeschwindigkeit(x, y, Art);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenKopierePunkte(char x, char y, char Art) {
  ZeigeZahlKopierePunkte(x, y, Art, Zahl1);
  ZeigeZahlKopierePunkte(x, y, Art, Zahl2);
  ZeigeZahlKopierePunkte(x, y, Art, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlSchichteSpalten(byte Richtung1, byte Richtung2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchichteSpaltenLaufgeschwindigkeit(Richtung1, Richtung2);
  ZeigeMatrixZeigedauer();
  SetzeZahlSchattenMatrix(LeerZahl);
  SchichteSpaltenLaufgeschwindigkeit(Richtung1, Richtung2);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchichteSpalten(char Richtung1, char Richtung2) {
  ZeigeZahlSchichteSpalten(Richtung1, Richtung2, Zahl1);
  ZeigeZahlSchichteSpalten(Richtung1, Richtung2, Zahl2);
}

//---------------------------------------------------------------------------

void ZeigeZahlSchichteZeilen(byte Richtung1, byte Richtung2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchichteZeilenLaufgeschwindigkeit(Richtung1, Richtung2);
  ZeigeMatrixZeigedauer();
  SetzeZahlSchattenMatrix(LeerZahl);
  SchichteZeilenLaufgeschwindigkeit(Richtung1, Richtung2);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchichteZeilen(char Richtung1, char Richtung2) {
  ZeigeZahlSchichteZeilen(Richtung1, Richtung2, Zahl1);
  ZeigeZahlSchichteZeilen(Richtung1, Richtung2, Zahl2);
}

//---------------------------------------------------------------------------

void ZeigeZahlFuelleSpalten(byte Richtung1, byte Richtung2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  FuelleSpaltenLaufgeschwindigkeit(Richtung1, Richtung2);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
  LeereSpaltenLaufgeschwindigkeit(Richtung1, Richtung2);
}

//---------------------------------------------------------------------------

void ZeigeZahlenFuelleLeereSpalten(byte Richtung1, byte Richtung2) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  if (Richtung1==Links) {
    ZeigeZahlFuelleSpalten(Richtung1, Richtung2, Zahl1);
    Richtung=Richtung1; SchiebeAbstandLaufgeschwindigkeit();
    ZeigeZahlFuelleSpalten(Richtung1, Richtung2, Zahl2);
  } else {
    ZeigeZahlFuelleSpalten(Richtung1, Richtung2, Zahl2);
    Richtung=Richtung1; SchiebeAbstandLaufgeschwindigkeit();
    ZeigeZahlFuelleSpalten(Richtung1, Richtung2, Zahl1);
  }
  ZurueckZurAltenLaufgeschwindigkeit();;
}

//---------------------------------------------------------------------------

void ZeigeZahlFuelleZeilen(byte Richtung1, byte Richtung2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  FuelleZeilenLaufgeschwindigkeit(Richtung1, Richtung2);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
  LeereZeilenLaufgeschwindigkeit(Richtung1, Richtung2);
}

//---------------------------------------------------------------------------

void ZeigeZahlenFuelleLeereZeilen(char Richtung1, char Richtung2) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  ZeigeZahlFuelleZeilen(Richtung1, Richtung2, Zahl1);
  Richtung=Richtung1; SchiebeAbstandLaufgeschwindigkeit();
  ZeigeZahlFuelleZeilen(Richtung1, Richtung2, Zahl2);
  ZurueckZurAltenLaufgeschwindigkeit();
  Richtung=Richtung1; SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZahlMassbandLaufgeschwindigkeit(char Zahl) {
  switch(Richtung) {
    case Hoch:
    case Runter:
      SchiebeMusterLaufgeschwindigkeit(AlleSpalten);
      SchiebeMusterLaufgeschwindigkeit(LeerMuster);
      SchiebeZahlLaufgeschwindigkeit(Zahl);
      break;
    case Links:
    case Rechts:
      SchiebeMusterLaufgeschwindigkeit(LeerMuster);
      SchiebeMusterLaufgeschwindigkeit(AlleSpalten);
      SchiebeMusterLaufgeschwindigkeit(LeerMuster);
      SchiebeZahlLaufgeschwindigkeit(Zahl);
      break;
  }
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlMassband(char Zahl) {
  ZahlMassbandLaufgeschwindigkeit(Zahl);
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeBisZahlMassband(char Zahl) {
  for (char z=0; z<=Zahl; z++) {
    SetzeNeueLaufgeschwindigkeit(max(MaxVariLaufgeschwindigkeit-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    ZahlMassbandLaufgeschwindigkeit(z);
    ZurueckZurAltenLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZahlKarteAuflegenLaufgeschwindigkeit(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KarteAuflegenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeBisZahlKarteAuflegen(char Zahl) {
  for (char z=0; z<=Zahl; z++) {
    SetzeNeueLaufgeschwindigkeit(max(MaxVariLaufgeschwindigkeit-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    ZahlKarteAuflegenLaufgeschwindigkeit(z);
    ZurueckZurAltenLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlEineKarteAuflegen(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KarteAuflegenLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenEineKarteAuflegen() {
  if (Richtung==Rechts) TauscheZahlen();
  ZeigeZahlEineKarteAuflegen(Zahl1);
  ZeigeZahlEineKarteAuflegen(Zahl2);
  ZeigeZahlEineKarteAuflegen(LeerZahl);
}

//---------------------------------------------------------------------------

void ZahlKarteWegnehmenLaufgeschwindigkeit(char Zahl) {
  if (Richtung==Rechts) TauscheZahlen();
  SetzeZahlSchattenMatrix(Zahl);
  KarteWegnehmenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeBisZahlKarteWegnehmen(char Zahl) {
  for (char z=0; z<=Zahl; z++) {
    SetzeNeueLaufgeschwindigkeit(max(MaxVariLaufgeschwindigkeit-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    ZahlKarteWegnehmenLaufgeschwindigkeit(z);
    ZurueckZurAltenLaufgeschwindigkeit();
  }
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlEineKarteWegnehmen(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KarteWegnehmenLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenEineKarteWegnehmen() {
  ZeigeZahlEineKarteWegnehmen(Zahl1);
  ZeigeZahlEineKarteWegnehmen(Zahl2);
  ZeigeZahlEineKarteWegnehmen(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlPunktlauf(char x1, char y1, char LaufArt, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  char x2=RechteSpalte-x1; char y2=UntereZeile-y1;
  char SollPunkt=PunktEin; if (Zahl==LeerZahl) SollPunkt=PunktAus;
  if (bitRead(LaufArt,0)) {x1=RechteSpalte-x1; x2=RechteSpalte-x2; } // x spiegeln
  if (bitRead(LaufArt,1)) {y1=UntereZeile-y1;  y2=UntereZeile-y2; }  // y spiegeln
  char x=x1, y=y1;
  char Abbruch=false;
  while(Abbruch==false) {
    char Punkt;
    if (Zahl!=LeerZahl)
      Punkt=HolePunkt(SchattenMatrix,x,y);
    else
      Punkt=HolePunkt(HauptMatrix,x,y);
    if (Punkt==PunktEin) {
      char xs=x, ys=y, xz=x, yz=y;
      if (Zahl!=LeerZahl) {
        if (bitRead(LaufArt,2)==0) ys=y2; else xs=x2;
      } else {
        if (bitRead(LaufArt,2)==0) yz=y1; else xz=x1;
      }
      PunktlaufLaufgeschwindigkeit(xs, ys, xz, yz, SollPunkt);
    }
    if (x==x2 && y==y2) Abbruch=true;
    if (bitRead(LaufArt,3)==0) { // Fuellrichtung
      if (x==x2) {
        x=x1; if (y<y2) y++; if (y>y2) y--;
      } else {
        if (x<x2) x++; if (x>x2) x--;
      }
    } else {
      if (y==y2) {
        y=y1; if (x<x2) x++; if (x>x2) x--;
      } else {
        if (y<y2) y++; if (y>y2) y--;
      }
    }
  }
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenPunktlauf(char x, char y, char Art) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  ZeigeZahlPunktlauf(x, y, Art, Zahl1);
  ZeigeZahlPunktlauf(x, y, Art, LeerZahl);
  ZeigeZahlPunktlauf(x, y, Art, Zahl2);
  ZeigeZahlPunktlauf(x, y, Art, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlSchiebeZeilen(byte Zeilen1, byte Richtung1, byte Richtung2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeZeilenLaufgeschwindigkeit(Zeilen1, Richtung1, Richtung2);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeZeilen(byte Zeilen, byte Richtung1, byte Richtung2) {
  ZeigeZahlSchiebeZeilen(Zeilen, Richtung1, Richtung2, Zahl1);
  ZeigeZahlSchiebeZeilen(Zeilen, Richtung1, Richtung2, Zahl2);
  ZeigeZahlSchiebeZeilen(Zeilen, Richtung1, Richtung2, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlSchiebeZeilenGleichzeitig(byte Zeilen1, byte Zeilen2, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SchiebeZeilenGleichzeitigLaufgeschwindigkeit(Zeilen1, Zeilen2);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenSchiebeZeilenGleichzeitig(byte Zeilen) {
  ZeigeZahlSchiebeZeilenGleichzeitig(Zeilen, Zeilen^AlleZeilen, Zahl1);
  ZeigeZahlSchiebeZeilenGleichzeitig(Zeilen, Zeilen^AlleZeilen, Zahl2);
  ZeigeZahlSchiebeZeilenGleichzeitig(Zeilen, Zeilen^AlleZeilen, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlRomEiner(char Zahl, char Offset, boolean Zwoelf) {
  if (Zwoelf==true && Zahl==0) Zahl=12;
  byte Muster=RomZiffern[Zahl];
  while (Muster!=0) {
    switch((Muster&0x03)+Offset) {
      case 1: SchiebeZeichenLinksLaufgeschwindigkeit(_I); break;
      case 2: SchiebeZeichenLinksLaufgeschwindigkeit(_V); break;
      case 3: SchiebeZeichenLinksLaufgeschwindigkeit(_X); break;
      case 5: SchiebeZeichenLinksLaufgeschwindigkeit(_X); break;
      case 6: SchiebeZeichenLinksLaufgeschwindigkeit(_L); break;
      case 7: SchiebeZeichenLinksLaufgeschwindigkeit(_C); break;
    }
    Muster=Muster>>2;
    if (Muster!=0) SchiebeAbstandLinksLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void ZeigeZahlRomEiner(char Zahl, char Offset) {
  ZeigeZahlRomEiner(Zahl, Offset, true);
}

//---------------------------------------------------------------------------

void ZeigeZahlRomischZehner(char Zahl) {
  if (Zahl>=10) ZeigeZahlRomEiner(Zahl/10, 4, false); // statt IVX XLC
  SchiebeAbstandLinksLaufgeschwindigkeit();
  ZeigeZahlRomEiner(Zahl%10, 0, false);
}

//---------------------------------------------------------------------------

void ZeigeZahlVorhang(const byte Muster[], char Zahl) {
  VorhangLaufgeschwindigkeit(Muster);
  ZeigeMatrixLaufgeschwindigkeit();
  SetzeZahlSchattenMatrix(Zahl);
  Balken=Muster[2];
  RichtungUmkehr();
  KopiereLaufgeschwindigkeit();
  RichtungUmkehr();
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenVorhang(const byte Muster[]) {
  ZeigeZahlVorhang(Muster, Zahl1);
  ZeigeZahlVorhang(Muster, Zahl2);
  ZeigeZahlVorhang(Muster, LeerZahl);
}

//---------------------------------------------------------------------------

void ZahlRadarLaufgeschwindigkeit(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KopiereLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlRadar(char Zahl) {
  ZahlRadarLaufgeschwindigkeit(Zahl);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeBisZahlRadar(char Zahl) {
  char z=AlteZahl;
  byte RichtungRadar=Richtung;
  do {
    if (z<Zahl) {z++; Richtung=RichtungRadar;}
    if (z>Zahl) {z--; Richtung=RichtungRadar^1;}
    SetzeNeueLaufgeschwindigkeit(max(MaxVariLaufgeschwindigkeit-abs(Zahl-z), MinVariLaufgeschwindigkeit));
    ZahlRadarLaufgeschwindigkeit(z);
    ZurueckZurAltenLaufgeschwindigkeit();
  } while(z!=Zahl);
  ZeigeMatrixZeigedauer();
  AlteZahl=Zahl;
  Richtung=RichtungRadar;
}

//---------------------------------------------------------------------------

void ZeigeZahlenRadar() {
  Balken=AlleSpalten;
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  ZeigeBisZahlRadar(Zahl1);
  ZeigeBisZahlRadar(Zahl2);
  ZeigeZahlRadar(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlKopiereDiagonal(byte Spiegel, char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  KopiereDiagonalLaufgeschwindigkeit(Spiegel);
  ZeigeMatrixZeigedauer(Zahl!=LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlenKopiereDiagonal(byte Spiegel) {
  ZeigeZahlKopiereDiagonal(Spiegel, Zahl1);
  ZeigeZahlKopiereDiagonal(Spiegel, Zahl2);
  ZeigeZahlKopiereDiagonal(Spiegel, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeZahlRaute(byte Richtung1, byte Richtung2, char Zahl) {
  LoescheHauptMatrix();
  SetzeZahlSchattenMatrix(Zahl);
  RauteLaufgeschwindigkeit(Richtung1, Richtung2);
  ZeigeMatrixZeigedauer();
  LoescheSchattenMatrix();
  RauteLaufgeschwindigkeit(Richtung1, Richtung2);
}

//--------------------------------------------------------------------------

void ZeigeZahlenRaute(byte Richtung1, byte Richtung2) {
   if (Random(2)==0) Richtung1=Richtung1+2; else Richtung2=Richtung2+2;
   ZeigeZahlRaute(Richtung1, Richtung2, Zahl1);
   ZeigeZahlRaute(Richtung1, Richtung2, Zahl2);
}

//---------------------------------------------------------------------------

void ZeigeZahlBinaer01(char Zahl, boolean Bcd, boolean LH) {
  if (Bcd) Zahl=BinBcd(Zahl);
  for (char BitPos=MSB; BitPos>=LSB; BitPos--) {
    char Zeichen=bitRead(Zahl,BitPos);
    if (LH==true) Zeichen=Zeichen+_L; // statt 0,1 L,H benutzen
    SchiebeZeichenLinksLaufgeschwindigkeit(Zeichen);
    if (BitPos>0) SchiebeAbstandLinksLaufgeschwindigkeit();
    if (BitPos==4 && Bcd==1) SchiebeAbstandLinksLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void ZeigeZahlGespiegeltRechts(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SpiegelSpaltenSchattenMatrix();
  Richtung=Rechts;
  SchiebeLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeZahlenGespiegelt() {
  Richtung=Rechts;
  ZeigeZahlGespiegeltRechts(Zahl1);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  ZeigeZahlGespiegeltRechts(Zahl2);
  SchiebeLeerRechtsLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlKopfUeber(char Zahl) {
  SetzeZahlSchattenMatrix(Zahl);
  SpiegelSpaltenSchattenMatrix();
  SpiegelZeilenSchattenMatrix();
  Richtung=Rechts;  SchiebeLaufgeschwindigkeit();
  ZeigeMatrixZeigedauer();
}

//---------------------------------------------------------------------------

void ZeigeZahlenKopfueber() {
  Richtung=Rechts;
  ZeigeZahlKopfUeber(Zahl1);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  ZeigeZahlKopfUeber(Zahl2);
  SchiebeLeerRechtsLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeZahlFibonacci(char Zahl) {
  Zahl=Zahl%12;
  if (Zahl==0) Zahl=12;
  char Summe, Zufall;
  do {
    Summe=0;
    Zufall=Random(32);
    if (bitRead(Zufall,0)==1) Summe=Summe+1;
    if (bitRead(Zufall,1)==1) Summe=Summe+1;
    if (bitRead(Zufall,2)==1) Summe=Summe+2;
    if (bitRead(Zufall,3)==1) Summe=Summe+3;
    if (bitRead(Zufall,4)==1) Summe=Summe+5;
  } while (Summe!=Zahl);
  if (bitRead(Zufall,0)==1) SetzePunktHauptMatrix(2,0,1);
  if (bitRead(Zufall,1)==1) SetzePunktHauptMatrix(2,1,1);
  if (bitRead(Zufall,2)==1) {
    for (char Spalte=0; Spalte<=1; Spalte++)
      SetzeSpalteHauptMatrix(Spalte,HoleSpalteHauptMatrix(Spalte)|0x03);
  }
  if (bitRead(Zufall,3)==1) {
    for (char Spalte=0; Spalte<=2; Spalte++)
      SetzeSpalteHauptMatrix(Spalte,HoleSpalteHauptMatrix(Spalte)|0x1C);
  }
  if (bitRead(Zufall,4)==1) {
    for (char Spalte=3; Spalte<=6; Spalte++)
      SetzeSpalteHauptMatrix(Spalte,0x1F);
  }
  ZeigeMatrix(byte(3*Zeigedauer));
}

//---------------------------------------------------------------------------
// Zeige Datum
//---------------------------------------------------------------------------

void ZeigeDatumUS() {
  SchiebeZeigeZahlLinks(Monat);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(Geteilt);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeigeZahlLinks(Tag);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(Geteilt);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  if (ZufallBoolean1==1) {
    SchiebeZeigeZahlLinks(20); // Jahrhundert
    SchiebeAbstandLinksLaufgeschwindigkeit();
  }
  SchiebeZeigeZahlLinks(Jahr);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeTagImJahr(void) {
  int Tage=TagImJahr(Tag, Monat, Jahr);
  Nullunterdrueckung=true;
  Richtung=Links;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  if (Tage/100>0) {
    SchiebeZahlLaufgeschwindigkeit(Tage/100);
    SchiebeAbstandLinksLaufgeschwindigkeit();
    Nullunterdrueckung=false;
  }
  SchiebeZahlLaufgeschwindigkeit(Tage%100);
  SchiebeZeichenLinksLaufgeschwindigkeit(Punkt);
  SchiebeZeichenLinksLaufgeschwindigkeit(_T);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(_A);
  SchiebeAbstandLinksLaufgeschwindigkeit();
  SchiebeZeichenLinksLaufgeschwindigkeit(6);  // soll ein G sein
  Nullunterdrueckung=false;
}

//---------------------------------------------------------------------------

void ZeigeWocheImJahr(void) {
  char Woche=WocheImJahr();
  Richtung=Links;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
  Nullunterdrueckung=true;
  SchiebeZeigeZahl(Woche);
  ZeigeText(WocheText, false, false);
  Nullunterdrueckung=false;
}

//---------------------------------------------------------------------------
// Zeige Uhrzeit
//---------------------------------------------------------------------------

void ZeigeUhrzeitKodiertaster() {
  ZeigeBisZahlKodiertaster(Stunden, 5); // Zehner nur bis 5
  ZeigeBisZahlKodiertaster(Minuten, 5); // Zehner nur bis 5
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitZaehle() {
  ZeigeBisZahlZaehle(Stunden);
  ZeigeBisZahlZaehle(Minuten);
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitHexadezimal() {
  ZeigeZahlHexadezimal(Stunden);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  ZeigeZahlHexadezimal(Minuten);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitOktal() {
  ZeigeZahlOktal(Stunden);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  ZeigeZahlOktal(Minuten);
  SchiebeLeerLinksLaufgeschwindigkeit();
}


//---------------------------------------------------------------------------

void ZeigeUhrzeitRomischEiner() {
  char RomMinuten=Minuten;
  char RomStunden=Stunden;
  RomMinuten=RomMinuten+2;
  if (RomMinuten>=60) { RomMinuten=RomMinuten-60; RomStunden++; } // Zeit runden
  ZeigeZahlRomEiner(RomStunden%12, 0);     // 12 Stunden Modus
  SchiebeDoppelpunktLaufgeschwindigkeit();
  ZeigeZahlRomEiner(RomMinuten/5, 0);      // nur 12 Werte (I, II, III, IV, V, VI, usw.)
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitRomischZehner() {
  if (Stunden>0 && Minuten>0) { // sonst keine Anzeige bei Stunden oder Minuten
    ZeigeZahlRomischZehner(Stunden);
    SchiebeDoppelpunktLaufgeschwindigkeit();
    ZeigeZahlRomischZehner(Minuten);
    SchiebeLeerLinksLaufgeschwindigkeit();
  } else PauseOk=false;
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitBinaer(boolean Bcd, boolean Spiegeln) {
  char AltSekunden=Sekunden;
  char Zaehler=0;
  while (Zaehler<10/ZeitRaffer && Abbruch==false) { // ###
    HoleUhr();
    if (AltSekunden!=Sekunden) {
      AltSekunden=Sekunden; Zaehler++;
    }
    if (Bcd==true) {
      SetzeZeileHauptMatrix(0,BinBcd(Stunden));
      SetzeZeileHauptMatrix(2,BinBcd(Minuten));
      SetzeZeileHauptMatrix(4,BinBcd(Sekunden));
    } else {
      SetzeZeileHauptMatrix(0,Stunden);
      SetzeZeileHauptMatrix(2,Minuten);
      SetzeZeileHauptMatrix(4,Sekunden);
    }
    if (Spiegeln==true) SpiegelSpalten(HauptMatrix);
    ZeigeMatrixLaufgeschwindigkeit();
  }
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitZufall() {
  ZeigeBisZahlZufall(Stunden, 100, 20); // 20 Zahlen bis 100
  ZeigeBisZahlZufall(Minuten, 100, 10); // 10 Zahlen bis 100
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitZufallZehnerEiner() {
  SetzeZahlHauptMatrix(0);
  ZeigeBisZahlZufallZehnerEiner(Stunden, 100, 10); // 10 Zahlen bis 100
  ZeigeBisZahlZufallZehnerEiner(Minuten, 100, 10); // 10 Zahlen bis 100
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------


void ZeigeUhrzeitFlughafen() {
  SetzeNeueLaufgeschwindigkeit((Laufgeschwindigkeit*2)/3);
  ZeigeBisZahlFlughafen(Stunden, false);
  ZeigeBisZahlFlughafen(Minuten, false);
  SchiebeLeerLaufgeschwindigkeit();
}

//--------------------------------------------------------------------------

void ZeigeUhrzeitDaumenKino() {
  ZeigeBisZahlDaumenKinoZehnerEiner(Stunden, 5);  // Zehner nur bis 5
  ZeigeBisZahlDaumenKinoZehnerEiner(Minuten, 5);  // Zehner nur bis 5
  LoescheSchattenMatrix();
  if (Richtung>=Hoch) {
    if (ZufallZuerst==ZehnerZuerst)
      SchiebeZehnerLaufgeschwindigkeit();
    else
      SchiebeEinerLaufgeschwindigkeit();
    SchiebeLeerLaufgeschwindigkeit();
  }
}

//--------------------------------------------------------------------------

void ZeigeUhrzeitTacho() {
  Nullunterdrueckung=false;
  AlteZahl=0;
  ZeigeBisZahlTacho(Stunden);
  ZeigeBisZahlTacho(Minuten);
  SchiebeLeerLaufgeschwindigkeit();
}

//--------------------------------------------------------------------------

void ZeigeUhrzeitBinaer01(boolean Bcd, boolean LH) {
  ZeigeZahlBinaer01(Stunden,Bcd,LH);
  SchiebeDoppelpunktLaufgeschwindigkeit();
  ZeigeZahlBinaer01(Minuten,Bcd,LH);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//--------------------------------------------------------------------------

void ZeigeUhrzeitZaehleZehnerEiner(boolean NurVor) {
  ZeigeBisZahlZaehleZehnerEiner(Stunden, NurVor);
  ZeigeBisZahlZaehleZehnerEiner(Minuten, NurVor);
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//--------------------------------------------------------------------------

void ZeigeUhrFibonacci() {
  char FibonacciMinuten=Minuten;
  char FibonacciStunden=Stunden;
  FibonacciMinuten=FibonacciMinuten+2; // Zeit runden
  if (FibonacciMinuten>=60) {
    FibonacciMinuten=FibonacciMinuten-60;
    FibonacciStunden++;
  }
  ZeigeZahlFibonacci(FibonacciStunden);
  LoescheHauptMatrix();
  ZeigeMatrixLaufgeschwindigkeit();
  ZeigeZahlFibonacci(FibonacciMinuten/5); // nur 12 Werte
}

//--------------------------------------------------------------------------

const char UhrText[] PROGMEM={_U, _h, _r2, Ende};

void ZeigeUhrzeitMitText(boolean Textmitte) {
  Laufgeschwindigkeit=(Laufgeschwindigkeit*3)/2;
  SchiebeZeigeZahlLinks(Stunden);
  if (Textmitte==true)
    ZeigeText(UhrText, false, false); // 12 Uhr 34
  else
    SchiebeDoppelpunktLaufgeschwindigkeit(); // 12:34 Uhr
  if (Minuten>0) SchiebeZeigeZahlLinks(Minuten); // keine Minutenanzeige bei 0 (z.B. 14:00 => 14 Uhr)
  if (Textmitte==false) ZeigeText(UhrText, false, false);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//--------------------------------------------------------------------------

void ZeigeGemeinsam(byte Zufall) {
  switch (Zufall) {
    case   0: Richtung=Links; ZeigeZahlen(); break;
    case   1: Richtung=Rechts; TauscheZahlen(); ZeigeZahlen(); break;
    case   2: Richtung=Hoch; ZeigeZahlen(); break;
    case   3: Richtung=Runter; TauscheZahlen(); ZeigeZahlen(); break;

    case   4: ZeigeZahlenLinksLinksRechts(); break;
    case   5: ZeigeZahlenRechtsRechtsLinks(); break;
    case   6: ZeigeZahlenSenkrechtLinksSenkrecht(ZufallSenkrecht1, ZufallSenkrecht2); break;
    case   7: TauscheZahlen(); ZeigeZahlenSenkrechtRechtsSenkrecht(ZufallSenkrecht1, ZufallSenkrecht2); break;

    case   8: ZeigeZahlenZehnerLinksEiner(ZufallSenkrecht1, ZufallSenkrecht2); break;
    case   9: TauscheZahlen(); ZeigeZahlenEinerRechtsZehner(ZufallSenkrecht1, ZufallSenkrecht2); break;
    case  10: ZeigeZahlenZehnerLinksEinerLinks(); break;
    case  11: TauscheZahlen(); ZeigeZahlenEinerRechtsZehnerRechts(); break;
    case  12: ZeigeZahlenZehnerVonRechtsEiner(ZufallSenkrecht1); break;
    case  13: ZeigeZahlenEinerVonLinksZehner(ZufallSenkrecht1); break;
    case  14: ZeigeZahlenSchiebeZehnerEiner(ZufallSenkrecht1, ZufallSenkrecht2); break;
    case  15: Richtung=ZufallSenkrecht1; ZeigeZahlenSchiebeZehnerEinerGleichzeitig(); break;
    case  16: ZeigeZahlenSetzen(); break;
    case  17: ZeigeZahlenSetzenZehnerEiner(); break;

    case  18: Richtung=Zufall4Richtungen; ZeigeZahlenLaufenReinRaus(); break;
    case  19: ZeigeZahlenSchichteSpalten(ZufallWaagerecht1, ZufallSenkrecht2); break;
    case  20: ZeigeZahlenFuelleLeereSpalten(ZufallWaagerecht1, ZufallSenkrecht2); break;
    case  21: ZeigeZahlenSchichteZeilen(ZufallSenkrecht1, ZufallWaagerecht2); break;
    case  22: ZeigeZahlenFuelleLeereZeilen(ZufallSenkrecht1, ZufallWaagerecht2); break;

    case  23: Richtung=Zufall4Richtungen; Balken=ZufallBoolean1?-1:0x7F; ZeigeZahlenKopieren(); break;
    case  24: ZeigeZahlenKopiereZehnerEiner(ZufallSenkrecht1, ZufallSenkrecht2); break;
    case  25: Richtung=Random(4,6); ZeigeZahlenKopiereNachGleichzeitig(); break;
    case  26: Richtung=ZufallWaagerecht1; ZeigeZahlenKopiereNachGleichzeitig(); break;

    case  27: Richtung=ZufallSenkrecht1; ZeigeZahlenSchiebeSpalten124(MusterSpalten124[Random(6)]); break;
    case  28: ZeigeZahlenSchiebeSpalten25(MusterSpalten25[Random(6)], ZufallSenkrecht1, ZufallSenkrecht2); break;
    case  29: Richtung=ZufallSenkrecht1; ZeigeZahlenSchiebeSpalten25Gleichzeitig(MusterSpalten25[Random(6)]); break;
    case  30: ZeigeZahlenSchiebeZeilen(MusterZeilen[Random(2)], ZufallWaagerecht1, ZufallWaagerecht2); break;
    case  31: Richtung=ZufallWaagerecht1; ZeigeZahlenSchiebeZeilenGleichzeitig(MusterZeilen[Random(2)]); break;

    case  32: ZeigeZahlenPunkteZufall(); break;
    case  33: ZeigeZahlenZehnerEinerPunkteZufall(); break;
    case  34: ZeigeZahlenSpaltenZufall(0); break;
    case  35: ZeigeZahlenZeilenZufall(ZufallBoolean1); break;

    case  36: ZeigeZahlenTauschen(); break;
    case  37: ZeigeZahlenSchreibeZehnerEiner(); break;

    case  38: ZeigeZahlenKopierePunkte(6*ZufallBoolean1, 4*ZufallBoolean2, ZufallBoolean3); break;
    case  39: ZeigeZahlenPunktlauf(6*ZufallBoolean1, 4*ZufallBoolean2, Random(16)); break;

    case  40: ZeigeZahlenKopiereDiagonal(Zufall4Richtungen); break;
    case  41: Richtung=Zufall10Richtungen; ZeigeZahlenHinHer(); break;
    case  42: ZeigeZahlenRaute(ZufallWaagerecht1, ZufallWaagerecht2); break;

    case  43: Richtung=Random(3,5); ZeigeZahlenVorhang(MusterVorhang[Random(AnzahlVorhang)]); break;
    case  44: Richtung=Zufall4Richtungen; ZeigeZahlenEineKarteAuflegen(); break;
    case  45: Richtung=Zufall4Richtungen; ZeigeZahlenEineKarteWegnehmen(); break;

    case  46: ZeigeZahlenSpirale( 0, ZufallArt16); break;
    case  47: ZeigeZahlenSpirale( 1, ZufallArt16); break;
    case  48: ZeigeZahlenSpirale( 2, ZufallArt16); break;
    case  49: ZeigeZahlenSpirale( 3, ZufallArt16); break;
    case  50: ZeigeZahlenSpirale( 4, ZufallArt16); break;
    case  51: ZeigeZahlenSpirale( 5, ZufallArt16); break;
    case  52: ZeigeZahlenSpirale( 6, ZufallArt16); break;
    case  53: ZeigeZahlenSpirale( 7, ZufallArt16); break;
    case  54: ZeigeZahlenSpirale( 8, ZufallArt16); break;
    case  55: ZeigeZahlenSpirale( 9, ZufallArt16); break;
    case  56: ZeigeZahlenSpirale(10, ZufallArt16); break;
    case  57: ZeigeZahlenSpirale(11, ZufallArt16); break;
    case  58: ZeigeZahlenSpirale(12, ZufallArt16); break;

    case  59: ZeigeZahlenGespiegelt(); break;
    case  60: ZeigeZahlenKopfueber(); break;

    default: PauseOk=false;
  }
}
// const char MaxGleich=60;

//--------------------------------------------------------------------------

void ZeigeUhrzeitZufaellig(byte Zufall) {
  Vorbereitung();

  if (Zufall==0xFF) { do { Zufall=Random(MaxUhrzeit+1); } while (WarSchonDran(Zufall)==true); }

  if (Zufall<=MaxGleich) {
    ZeigeGemeinsam(Zufall);
  } else {
    switch(Zufall) {
      case  MaxGleich+ 1: ZeigeUhrzeitZufall(); break;
      case  MaxGleich+ 2: ZeigeUhrzeitZufallZehnerEiner(); break;
      case  MaxGleich+ 3: ZeigeUhrzeitZaehle(); break;
      case  MaxGleich+ 4: ZeigeUhrzeitHexadezimal(); break;
      case  MaxGleich+ 5: ZeigeUhrzeitOktal(); break;
      case  MaxGleich+ 6: Richtung=Zufall4Richtungen; ZeigeZahlenRadar(); break;
      case  MaxGleich+ 7: Richtung=ZufallSenkrecht1; ZeigeUhrzeitTacho(); break;
      case  MaxGleich+ 8: Richtung=Zufall4Richtungen; ZeigeUhrzeitDaumenKino(); break;
      case  MaxGleich+ 9: Richtung=ZufallSenkrecht1; ZeigeUhrzeitFlughafen(); break;
      case  MaxGleich+10: ZeigeUhrzeitRomischZehner(); break;

      case  MaxGleich+11: ZeigeUhrzeitZaehleZehnerEiner(ZufallBoolean1); break;
      case  MaxGleich+12: ZeigeUhrzeitBinaer01(ZufallBoolean1,ZufallBoolean2); break;

      case  MaxGleich+13: ZeigeUhrzeitRomischEiner(); break;
      case  MaxGleich+14: Richtung=ZufallSenkrecht1; ZeigeUhrzeitKodiertaster(); break;
      case  MaxGleich+15: ZeigeUhrzeitBinaer(ZufallBoolean1, ZufallBoolean2); break;
      case  MaxGleich+16: ZeigeUhrzeitMitText(ZufallBoolean1); break;
      case  MaxGleich+17: ZeigeUhrFibonacci(); break;

      default: PauseOk=false;
    }
  }
  MachePause();
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitZufaellig2x() {
  if (bitRead(AktTasten,XJ2_Bit)==1) {
    ZeigeUhrzeitZufaellig(0xFF);
    ZeigeUhrzeitZufaellig(0xFF);
  }
}

//---------------------------------------------------------------------------
// Zeige Temperatur
//---------------------------------------------------------------------------

void SchiebeGradCelsius() {
  SchiebeZeigeZahl(GradCelsius);
}

//---------------------------------------------------------------------------

void AbspannGradCelsiusLinks() {
  SchiebeAbstandLinksLaufgeschwindigkeit();
  Richtung=Links; SchiebeGradCelsius();
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturTacho() {
  Nullunterdrueckung=true;
  ZeigeBisZahlTacho(Temperatur);
  SchiebeZeigeZahl(GradCelsius);
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturDaumenKino() {
  ZeigeBisZahlDaumenKinoZehnerEiner(Temperatur, 9); // Zehner bis 9
  ZeigeZahlSchiebeZehnerEiner(Richtung, Richtung, GradCelsius);
  ZeigeZahlSchiebeZehnerEiner(Richtung, Richtung, LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturFlughafen() {
  ZeigeBisZahlFlughafen(Temperatur, false); // nicht leeren
  SchiebeZeigeZahl(GradCelsius);
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturZufall() {
  ZeigeBisZahlZufall(Temperatur, 100, 20);  // 20 Zahlen bis 100
  ZeigeBisZahlZufall(GradCelsius, 100, 10); // 10 Zahlen bis 100
  ZeigeSetzeZahlHauptMatrix(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturZufallZehnerEiner() {
  SetzeZahlHauptMatrix(0);
  ZeigeBisZahlZufallZehnerEiner(Temperatur, 100, 20);  // 20 Zahlen bis 100
  ZeigeBisZahlZufallZehnerEiner(GradCelsius, 100, 10); // 10 Zahlen bis 100
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturZaehler() {
  Nullunterdrueckung=true;
  ZeigeBisZahlZaehle(Temperatur);
  ZeigeSetzeZahlZehnerEiner(GradCelsius);
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturHexadezimal() {
  ZeigeZahlHexadezimal(Temperatur);
  AbspannGradCelsiusLinks();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturOktal() {
  ZeigeZahlOktal(Temperatur);
  AbspannGradCelsiusLinks();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturMassband() {
  ZeigeBisZahlMassband(Temperatur);
  ZeigeZahlMassband(GradCelsius);
  ZeigeZahlMassband(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturKarteAuflegen() {
  ZeigeBisZahlKarteAuflegen(Temperatur);
  ZeigeZahlEineKarteAuflegen(GradCelsius);
  ZeigeZahlEineKarteAuflegen(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturKarteWegnehmen() {
  ZeigeBisZahlKarteWegnehmen(Temperatur);
  ZeigeZahlEineKarteWegnehmen(GradCelsius);
  ZeigeZahlEineKarteWegnehmen(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturRadar() {
  Balken=AlleSpalten;
  ZeigeBisZahlRadar(Temperatur);
  ZeigeZahlRadar(GradCelsius);
  ZeigeZahlRadar(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturKelvin(boolean NurKelvin) {
  if (NurKelvin==false) {
    SchiebeZeigeZahl(Temperatur);
    SchiebeAbstandLaufgeschwindigkeit();
    SchiebeGradCelsius();
    SchiebeAbstandLaufgeschwindigkeit();
    SchiebeZeichenLaufgeschwindigkeit(Gleich);
    SchiebeAbstandLaufgeschwindigkeit();
  }
  SchiebeZeichenLaufgeschwindigkeit(Kelvin/100); // Hunderter
  ZeigeMatrixZeigedauer();
  SchiebeAbstandLaufgeschwindigkeit();
  SchiebeZeigeZahl(Kelvin%100);                  // Einer und Zehner
  SchiebeAbstandLaufgeschwindigkeit();
  SchiebeZeichenLaufgeschwindigkeit(_K);
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturFahrenheit(boolean NurFahrenheit) {
  if (NurFahrenheit==false) {
    SchiebeZeigeZahl(Temperatur);
    SchiebeAbstandLaufgeschwindigkeit();
    SchiebeGradCelsius();
    SchiebeAbstandLaufgeschwindigkeit();
    SchiebeZeichenLaufgeschwindigkeit(Gleich);
    SchiebeAbstandLaufgeschwindigkeit();
  }
  SchiebeZeigeZahl(Fahrenheit);
  SchiebeAbstandLaufgeschwindigkeit();
  SchiebeZeichenLaufgeschwindigkeit(Grad);
  SchiebeAbstandLaufgeschwindigkeit();
  SchiebeZeichenLaufgeschwindigkeit(_F);
  ZeigeMatrixZeigedauer();
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------


void ZeigeTemperaturBinaer01(boolean Bcd, boolean LH) {
  ZeigeZahlBinaer01(Temperatur,Bcd,LH);
  AbspannGradCelsiusLinks();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturRomischZehner() {
  ZeigeZahlRomischZehner(Temperatur);
  AbspannGradCelsiusLinks();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturCountZehnerEiner(boolean NurVor) {
  ZeigeBisZahlZaehleZehnerEiner(Temperatur, NurVor);
  ZeigeSetzeZahlZehnerEiner(GradCelsius);
  ZeigeSetzeZahlZehnerEiner(LeerZahl);
}

//---------------------------------------------------------------------------

void ZeigeTemperaturZufaellig(byte Zufall) {
  if (bitRead(AktTasten,XJ3_Bit)==1) {
    Vorbereitung();
    HoleTemperatur();

    if (Zufall==0xFF) { do { Zufall=Random(MaxTemperatur+1); } while (WarSchonDran(Zufall)==true); }

    Zahl1=Temperatur; Zahl2=GradCelsius;

    if (Zufall<=MaxGleich) {
      ZeigeGemeinsam(Zufall);
    } else {
      switch(Zufall) {
        case MaxGleich+ 1: ZeigeTemperaturZufall(); break;
        case MaxGleich+ 2: ZeigeTemperaturZufallZehnerEiner(); break;
        case MaxGleich+ 3: ZeigeTemperaturZaehler(); break;
        case MaxGleich+ 4: ZeigeTemperaturHexadezimal(); break;
        case MaxGleich+ 5: ZeigeTemperaturOktal();  break;
        case MaxGleich+ 6: Richtung=Zufall4Richtungen; ZeigeTemperaturRadar(); break;
        case MaxGleich+ 7: Richtung=ZufallSenkrecht1; ZeigeTemperaturTacho(); break;
        case MaxGleich+ 8: Richtung=ZufallSenkrecht1; ZeigeTemperaturDaumenKino(); break;
        case MaxGleich+ 9: Richtung=ZufallSenkrecht1; ZeigeTemperaturFlughafen(); break;
        case MaxGleich+10: ZeigeTemperaturRomischZehner(); break;

        case MaxGleich+11: ZeigeTemperaturCountZehnerEiner(ZufallBoolean1); break;
        case MaxGleich+12: ZeigeTemperaturBinaer01(ZufallBoolean1,ZufallBoolean2); break;

        case MaxGleich+13: Richtung=Zufall4Richtungen; ZeigeTemperaturMassband(); break;
        case MaxGleich+14: Richtung=Zufall4Richtungen; ZeigeTemperaturKarteAuflegen(); break;
        case MaxGleich+15: Richtung=Zufall4Richtungen; ZeigeTemperaturKarteWegnehmen(); break;
        case MaxGleich+16: ZeigeTemperaturKelvin(ZufallBoolean1); break;
        case MaxGleich+17: ZeigeTemperaturFahrenheit(ZufallBoolean1); break;

        default: PauseOk=false;
      }
    }
    MachePause();
  }
}

//---------------------------------------------------------------------------
// zeige Intermezzo
//---------------------------------------------------------------------------

//0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

const char  Drehen90[AnzahlLeds] PROGMEM = {
  0, 5,12,19,26,33, 6, 7, 4,11,18,25,32,13,14, 3,10,17,24,31,20,21, 2, 9,16,23,30,27,28, 1, 8,15,22,29,34};

const char Drehen45[AnzahlLeds] PROGMEM = {
  0, 3, 4, 5,12,19, 6, 7, 2,10,11,18,26,13,14, 1, 9,17,25,33,20,21, 8,16,23,24,32,27,28,15,22,29,30,31,34};

const char Umlauf1[AnzahlLeds] PROGMEM = {
  0, 2, 3, 4, 5,12, 6, 7, 1,10,11,18,19,13,14, 8, 9,17,25,26,20,21,15,16,23,24,33,27,28,22,29,30,31,32,34};

const char Umlauf2[AnzahlLeds] PROGMEM = {
  0, 2, 3, 4, 5,12, 6, 7, 1,16, 9,10,19,13,14, 8,23,17,11,26,20,21,15,24,25,18,33,27,28,22,29,30,31,32,34};

const char AnzahlWinkel=4;
const char *const WinkelArten[AnzahlWinkel] PROGMEM = {Umlauf1, Umlauf2, Drehen45, Drehen90};

//const char PalText[] PROGMEM = {0x11, 0x1F, 0x11, 0x00, 0x06, 0x0F, 0x1E, 0x0F, 0x06, 0x40, 0x1F, 0x05, 0x02, 0x00, 0x1E, 0x05, 0x1E, 0x00, 0x1F, 0x10, 0x10, 0x00, 0x00, 0x00, 0x09, 0x10, 0x16, 0x10, 0x09, 0x20, Ende};
const char EGSMuster[] PROGMEM = {0x11, 0x1F, 0x11, 0x00, 0x00, 0x06, 0x0F, 0x1E, 0x0F, 0x06, 0x40, 0x00, 0x1F, 0x15, 0x15, 0x11, 0x00, 0x40, 0x0E, 0x11, 0x15, 0x1D, 0x00, 0x40, 0x12, 0x15, 0x15, 0x09, 0x00, 0x40, Ende};

const char LeerBild[AnzahlSpalten]      PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
const char KleinHerzBild[AnzahlSpalten] PROGMEM = {0x00, 0x00, 0x06, 0x0C, 0x06, 0x00, 0x00};
const char GrossHerzBild[AnzahlSpalten] PROGMEM = {0x00, 0x06, 0x0F, 0x1E, 0x0F, 0x06, 0x00};
const char LeerHerzBild[AnzahlSpalten]  PROGMEM = {0x00, 0x06, 0x09, 0x12, 0x09, 0x06, 0x00};
const char *const HerzenBilder[] = {LeerHerzBild, GrossHerzBild, KleinHerzBild, LeerBild};

const char Gesicht1Bild[7]  PROGMEM = {0x00, 0x09, 0x10, 0x16, 0x10, 0x09, 0x00}; // :-)
const char Gesicht2Bild[7]  PROGMEM = {0x00, 0x01, 0x00, 0x06, 0x00, 0x01, 0x00}; // :-
const char Gesicht3Bild[7]  PROGMEM = {0x00, 0x09, 0x10, 0x16, 0x10, 0x08, 0x00}; // .-)
const char *const GesichterBilder[] = {Gesicht2Bild, Gesicht3Bild, LeerBild};

const char Raute1Bild[AnzahlSpalten]    PROGMEM = {0x00, 0x04, 0x0E, 0x1F, 0x0E, 0x04, 0x00};
const char Raute2Bild[AnzahlSpalten]    PROGMEM = {0x00, 0x04, 0x0A, 0x11, 0x0A, 0x04, 0x00};
const char Quadrat1Bild[AnzahlSpalten]  PROGMEM = {0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00};
const char Quadrat2Bild[AnzahlSpalten]  PROGMEM = {0x00, 0x1F, 0x11, 0x11, 0x11, 0x1F, 0x00};
const char *const RautenBilder[] = {Raute1Bild, Raute2Bild, LeerBild, Quadrat1Bild, Quadrat2Bild};

const char Hampel1Bild[AnzahlSpalten]   PROGMEM = {0x00, 0x04, 0x1E, 0x0F, 0x1E, 0x04, 0x00};
const char Hampel2Bild[AnzahlSpalten]   PROGMEM = {0x00, 0x11, 0x0E, 0x0F, 0x0E, 0x11, 0x00};

const char AnzahlAutoMuster=6;
const char Auto1Muster[8] PROGMEM = {0x0C, 0x1C, 0x0F, 0x0D, 0x0F, 0x1F, 0x0F, Ende};
const char Auto2Muster[8] PROGMEM = {0x0C, 0x1A, 0x0E, 0x0E, 0x0E, 0x1E, 0x0E, Ende};
const char Auto3Muster[8] PROGMEM = {0x0E, 0x1D, 0x0F, 0x0C, 0x0C, 0x1C, 0x0E, Ende};
const char Auto4Muster[8] PROGMEM = {0x0F, 0x1D, 0x0F, 0x0C, 0x0C, 0x1C, 0x0E, Ende};
const char Auto5Muster[8] PROGMEM = {0x0C, 0x1A, 0x0E, 0x08, 0x08, 0x18, 0x0E, Ende};
const char Auto6Muster[8] PROGMEM = {0x0C, 0x1A, 0x0E, 0x0A, 0x0E, 0x1E, 0x0E, Ende};

const char *const AutoMuster[AnzahlAutoMuster] = {
  Auto1Muster, Auto2Muster, Auto3Muster, Auto4Muster, Auto5Muster, Auto6Muster};

const char AnzahlAnhaengerMuster=3;
const char Anhaenger1Muster[8] PROGMEM = {0x08, 0x08, 0x0E, 0x1A, 0x0A, 0x1A, 0x0E, Ende};
const char Anhaenger2Muster[8] PROGMEM = {0x08, 0x08, 0x0E, 0x1E, 0x0E, 0x1E, 0x0E, Ende};
const char Anhaenger3Muster[8] PROGMEM = {0x08, 0x08, 0x0C, 0x18, 0x08, 0x18, 0x0C, Ende};

const char *const AnhaengerMuster[AnzahlAnhaengerMuster] = {
  Anhaenger1Muster, Anhaenger2Muster, Anhaenger3Muster};

const char AnzahlUbootBilder=4;
const char UBootBilder[4*AnzahlUbootBilder][7]  PROGMEM = {
  {0x1C, 0x14, 0x1C, 0x08, 0x08, 0x08, 0x08},
  {0x1C, 0x14, 0x1C, 0x08, 0x0C, 0x08, 0x10},
  {0x1C, 0x14, 0x1C, 0x08, 0x08, 0x1C, 0x00},
  {0x1C, 0x14, 0x1C, 0x08, 0x18, 0x08, 0x04},

  {0x04, 0x0A, 0x0E, 0x0E, 0x04, 0x04, 0x04},
  {0x04, 0x0A, 0x0E, 0x0E, 0x04, 0x02, 0x01},
  {0x04, 0x0A, 0x0E, 0x0E, 0x04, 0x04, 0x04},
  {0x04, 0x0A, 0x0E, 0x0E, 0x04, 0x08, 0x10},

  {0x08, 0x14, 0x14, 0x17, 0x14, 0x14, 0x08},
  {0x08, 0x14, 0x15, 0x17, 0x15, 0x14, 0x08},
  {0x08, 0x15, 0x15, 0x17, 0x15, 0x15, 0x08},
  {0x08, 0x14, 0x15, 0x17, 0x15, 0x14, 0x08},

  {0x18, 0x14, 0x1F, 0x1C, 0x08, 0x08, 0x1C},
  {0x18, 0x15, 0x1F, 0x1D, 0x08, 0x08, 0x1C},
  {0x19, 0x15, 0x1F, 0x1D, 0x09, 0x08, 0x1C},
  {0x18, 0x15, 0x1F, 0x1D, 0x08, 0x08, 0x1C}};

const char HalloText[] PROGMEM={_H, _A2, _L, _L, _O2, Ende};

//---------------------------------------------------------------------------

void SetzeZeilenMuster(char Matrix[], char MusterZeilen[]) {
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++)
    SetzeZeile(Matrix, Zeile, MusterZeilen[Zeile]);
}

//---------------------------------------------------------------------------

void SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(char Zeilen[]) {
  SetzeZeilenMuster(HauptMatrix, Zeilen);
  ZeigeMatrixLaufgeschwindigkeit();
}
//---------------------------------------------------------------------------

void Drehe(byte Richtung, const char Winkel[], char Oft) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit*2);
  ZeigeMatrixLaufgeschwindigkeit();
  while (Oft>0){
    KopiereGanzeMatrix(SchattenMatrix, HauptMatrix);
    for (char Led=0; Led<AnzahlLeds; Led++) {
      if (Richtung==Links)
       SetzePunktNrHauptMatrix(Led,HolePunktNr(SchattenMatrix,pgm_read_byte(Winkel+Led)));
      else
       SetzePunktNrHauptMatrix(pgm_read_byte(Winkel+Led),HolePunktNr(SchattenMatrix,Led));
    }
    ZeigeMatrixLaufgeschwindigkeit();
    Oft--;
  }
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void DreheZeilenMuster(char Muster[], byte Richtung, char const Winkel[], char Oft) {
  SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(Muster);
  ZeigeMatrixZeigedauer();
  Drehe(Richtung, Winkel, Oft);
}

//---------------------------------------------------------------------------

const char AnzahlRotor=4;
void Rotor(byte Richtung, char Rot, char const Winkel[], char Oft) {
  char Muster[AnzahlRotor][AnzahlZeilen] = {
  {0x08, 0x08, 0x08, 0x00, 0x00},
  {0x22, 0x14, 0x08, 0x00, 0x00},
  {0x08, 0x08, 0x08, 0x08, 0x08},
  {0x36, 0x22, 0x3E, 0x22, 0x36}};
  if (Winkel!=Drehen90 || Rot<2) {
    DreheZeilenMuster(Muster[Rot], Richtung, Winkel, Oft);
    ZeigeMatrixZeigedauer();
    LoescheHauptMatrix();
    ZeigeMatrixZeigedauer();
  }
}

//---------------------------------------------------------------------------

void ZeigeBild(const char Bild[], char Spiegel=0) {
  LoescheHauptMatrix();
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    char SetzSpalte=Spalte-BildVersatz;
    if (SetzSpalte>=LinkeSpalte && SetzSpalte<=RechteSpalte)
      SetzeSpalteHauptMatrix(SetzSpalte,pgm_read_byte(Bild+Spalte));
  }
  if (bitRead(Spiegel,0)==1) SpiegelSpalten(HauptMatrix);
  if (bitRead(Spiegel,1)==1) SpiegelZeilen(HauptMatrix);
  ZeigeMatrixLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void Blinken(char Oft) {
  Oft=Oft*2; // jeweils aus und wieder ein
  LoescheSchattenMatrix();
  while(Oft>0) {
    TauscheMatrix();
    ZeigeMatrixZeigedauer2();
    Oft--;
  }
}

//---------------------------------------------------------------------------

void BlinkenBild(const char Bild[], char Oft) {
  ZeigeBild(Bild);
  Blinken(Oft);
}

//---------------------------------------------------------------------------

void BlinkenBilder(const char Bild1[], const char Bild2[], char Oft) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit*4);
  if (Bild1!=Bild2) {
    while(Oft>0) {
      ZeigeBild(Bild1);
      ZeigeBild(Bild2);
      Oft--;
    }
    ZeigeBild(Bild1);
  } else PauseOk=false;
  ZurueckZurAltenLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeMusterstreifen(char const *Musterstreifen, word BlinkMuster, boolean Leeren) {
  SetzeNeueLaufgeschwindigkeit(10*ZeitLupe/ZeitRaffer);
  char Muster;
  char BlinkOft;
  do {
    Muster=pgm_read_byte(Musterstreifen);
    if (Muster!=Ende) {
      SchiebeMusterLaufgeschwindigkeit(Muster);
      if (bitRead(Muster,5)==1) ZeigeMatrix(byte(2*Zeigedauer));
      if (bitRead(Muster,6)==1) {
        BlinkOft=BlinkMuster&0x03;
        if (BlinkOft>0) {
          ZeigeMatrixZeigedauer();
          Blinken(BlinkOft);
        }
        BlinkMuster=BlinkMuster>>2;
      }
    }
    Musterstreifen++;
  } while(Muster!=Ende);
  if (Leeren==true) {
    SchiebeLeerLaufgeschwindigkeit();
    ZeigeMatrix(Pausendauer);
  }
  ZurueckZurAltenLaufgeschwindigkeit();
}


//---------------------------------------------------------------------------

void DreieckSinusWelle(byte Oft, boolean Sinus) {
  char WellenWert=bit(MitteZeile);
  char RichtungWelle=1;
  Richtung=Links;
  while(Oft>0) {
    SchiebeMusterLaufgeschwindigkeit(WellenWert);
    if (RichtungWelle==1) WellenWert=WellenWert<<1; else WellenWert=WellenWert>>1;
    if (WellenWert==bit(ObereZeile) || WellenWert==bit(UntereZeile)) {
      RichtungWelle=-RichtungWelle;
      if (Sinus==true) SchiebeMusterLaufgeschwindigkeit(WellenWert);
    }
    Oft--;
  }
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

const char AnzahlWuerfelBilder=6;
void Wuerfeln(byte Oft) {
  Laufgeschwindigkeit=2;
  char Muster[AnzahlWuerfelBilder][AnzahlZeilen] = {
    {0x00, 0x00, 0x08, 0x00, 0x00},
    {0x20, 0x00, 0x00, 0x00, 0x02},
    {0x20, 0x00, 0x08, 0x00, 0x02},
    {0x22, 0x00, 0x00, 0x00, 0x22},
    {0x22, 0x00, 0x08, 0x00, 0x22},
    {0x22, 0x00, 0x22, 0x00, 0x22}};
  static char WuerfelZahl=0;
  while(Oft>0) {
    SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(Muster[WuerfelZahl]);
    WuerfelZahl++; if (WuerfelZahl>=AnzahlWuerfelBilder) WuerfelZahl=0;
    if (Oft<17) Laufgeschwindigkeit=Laufgeschwindigkeit+2; // ausrollen
    Oft--;
  }
  ZeigeMatrixZeigedauer();
  Blinken(3);
}

//---------------------------------------------------------------------------

const char AnzahlDreierMuster=3;
void DreierMuster(byte Nr, byte Oft) {
  char Muster[AnzahlDreierMuster][3][AnzahlZeilen] = {
    {{0x00, 0x00, 0x1C, 0x00, 0x00},
     {0x00, 0x3E, 0x22, 0x3E, 0x00},
     {0x7F, 0x41, 0x41, 0x41, 0x7F}},
    {{0x00, 0x08, 0x08, 0x08, 0x7F},
     {0x00, 0x1C, 0x08, 0x08, 0x7F},
     {0x1C, 0x3E, 0x1C, 0x08, 0x7F}},
    {{0x3E, 0x08, 0x3E, 0x41, 0x3E},
     {0x1C, 0x08, 0x3E, 0x41, 0x3E},
     {0x08, 0x08, 0x3E, 0x41, 0x3E}}};
  char BildFolge[] = {0,1,2,1};
  while(Oft>0) {
    for (char BildNr=0; BildNr<sizeof(BildFolge); BildNr++) {
      SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(Muster[Nr][BildFolge[BildNr]]);
    }
    Oft--;
  }
}

//---------------------------------------------------------------------------

const char AnzahlViererMuster=2;
void ViererMuster(byte Nr, byte Oft) {
  char Muster[AnzahlViererMuster][4][AnzahlZeilen] = {
    {{0x08, 0x08, 0x08, 0x08, 0x08},
     {0x14, 0x14, 0x1C, 0x14, 0x14},
     {0x22, 0x22, 0x3E, 0x22, 0x22},
     {0x41, 0x41, 0x7F, 0x41, 0x41}},
    {{0x08, 0x08, 0x08, 0x08, 0x08},
     {0x1C, 0x14, 0x14, 0x14, 0x1C},
     {0x3E, 0x22, 0x22, 0x22, 0x3E},
     {0x7F, 0x41, 0x41, 0x41, 0x7F}}};
  char BildFolge[] = {0,1,2,3,2,1};
  while(Oft>0) {
    for (char BildNr=0; BildNr<sizeof(BildFolge); BildNr++) {
      SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(Muster[Nr][BildFolge[BildNr]]);
    }
    Oft--;
  }
}

//---------------------------------------------------------------------------

const char AnzahlFuenferMuster=3;
void FuenferMuster(byte Nr, byte Oft) {
  char Muster[AnzahlFuenferMuster][5][AnzahlZeilen] = {
    {{0x7F, 0x08, 0x08, 0x08, 0x08},
     {0x08, 0x7F, 0x08, 0x08, 0x08},
     {0x08, 0x08, 0x7F, 0x08, 0x08},
     {0x08, 0x08, 0x08, 0x7F, 0x08},
     {0x08, 0x08, 0x08, 0x08, 0x7F}},
    {{0x3E, 0x2A, 0x6B, 0x08, 0x08},
     {0x00, 0x3E, 0x6B, 0x08, 0x08},
     {0x00, 0x00, 0x7F, 0x08, 0x08},
     {0x00, 0x00, 0x63, 0x3E, 0x08},
     {0x00, 0x00, 0x63, 0x22, 0x3E}},
    {{0x70, 0x10, 0x1C, 0x04, 0x07},
     {0x00, 0x70, 0x1C, 0x07, 0x00},
     {0x00, 0x00, 0x7F, 0x00, 0x00},
     {0x00, 0x07, 0x1C, 0x70, 0x00},
     {0x07, 0x04, 0x1C, 0x10, 0x70}}};
  char BildFolge[] = {2,1,0,1,2,3,4,3};
  while(Oft>0) {
    for (char BildNr=0; BildNr<sizeof(BildFolge); BildNr++) {
      SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(Muster[Nr][BildFolge[BildNr]]);
    }
    Oft--;
  }
}

//---------------------------------------------------------------------------

const char AnzahlSiebenerMuster=2;
void SiebenerMuster(byte Nr, byte Oft) {
  char Muster[AnzahlSiebenerMuster][7][AnzahlZeilen] = {
    {{0x01, 0x01, 0x7F, 0x01, 0x01},
     {0x02, 0x02, 0x7F, 0x02, 0x02},
     {0x04, 0x04, 0x7F, 0x04, 0x04},
     {0x08, 0x08, 0x7F, 0x08, 0x08},
     {0x10, 0x10, 0x7F, 0x10, 0x10},
     {0x20, 0x20, 0x7F, 0x20, 0x20},
     {0x40, 0x40, 0x7F, 0x40, 0x40}},
    {{0x0F, 0x09, 0x7F, 0x48, 0x78},
     {0x0E, 0x0A, 0x3E, 0x28, 0x38},
     {0x0C, 0x0C, 0x1C, 0x18, 0x18},
     {0x08, 0x08, 0x08, 0x08, 0x08},
     {0x18, 0x18, 0x1C, 0x0C, 0x0C},
     {0x38, 0x28, 0x3E, 0x0A, 0x0E},
     {0x78, 0x48, 0x7F, 0x09, 0x0F}}};

  char BildFolge[] = {3,2,1,0,1,2,3,4,5,6,5,4};
  while(Oft>0) {
    for (char BildNr=0; BildNr<sizeof(BildFolge); BildNr++) {
      SetzeZeilenMusterHauptMatrixLaufgeschwindigkeit(Muster[Nr][BildFolge[BildNr]]);
    }
    Oft--;
  }
}

//---------------------------------------------------------------------------

void AlleEinAlleAus(byte Oft) {
  while(Oft>0) {
    Mischen(AnzahlLeds);
    for(char Led=0; Led<AnzahlLeds; Led++) {
      char x=ZufallsZahlen[Led]%AnzahlSpalten;
      char y=ZufallsZahlen[Led]/AnzahlSpalten;
      SetzePunktHauptMatrix(x, y, !HolePunkt(HauptMatrix,x,y));
      ZeigeMatrixLaufgeschwindigkeit();
    }
    Oft--;
  }
}

//---------------------------------------------------------------------------

void Regen(byte Oft) {
  char ZufallSpalte;
  Richtung=Runter;
  while(Oft>0) {
    SchiebeSpaltenKodiertRunter1x(HauptMatrix,AlleSpalten,0);
    ZufallSpalte=Random(AnzahlSpalten);
    if (HoleSpalteHauptMatrix(ZufallSpalte)==LeerMuster) {
      SetzeSpalteHauptMatrix(ZufallSpalte, bit(ObereZeile));
      Oft--;
    }
    ZeigeMatrixLaufgeschwindigkeit();
  }
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

const char AnzahlAufAbMuster=3;
void AufAb(byte Nr, byte Oft) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit*2);
  char StartRichtungen[AnzahlAufAbMuster][AnzahlSpalten] = {
    {   1,    1,    1,    1,    1,    1,    1},
    {   1,   -1,    1,   -1,    1,   -1,    1},
    {  -1,    0,    1,    0,   -1,    0,    1}};

  char Startwerte[AnzahlAufAbMuster][AnzahlSpalten] = {
   { 0x01, 0x02, 0x04, 0x08, 0x04, 0x02, 0x01},
   { 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01},
   { 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04}};

  char Richtungen[AnzahlSpalten];
  for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
    SetzeSpalteHauptMatrix(Spalte, Startwerte[Nr][Spalte]);
    Richtungen[Spalte]=StartRichtungen[Nr][Spalte];
  }
  while(Oft>0) {
    ZeigeMatrixLaufgeschwindigkeit();
    for (char Spalte=LinkeSpalte; Spalte<=RechteSpalte; Spalte++) {
       if (Richtungen[Spalte]== 1) HauptMatrix[Spalte]=HauptMatrix[Spalte]<<1;
       if (Richtungen[Spalte]==-1) HauptMatrix[Spalte]=HauptMatrix[Spalte]>>1;
       if (Oft>7) { // rauslaufen lassen
         if ((HauptMatrix[Spalte]&0x11)!=0) Richtungen[Spalte]=-Richtungen[Spalte];
       }
    }
    Oft--;
  }
}

//---------------------------------------------------------------------------

void UBoot(byte Ofs) {
  SetzeNeueLaufgeschwindigkeit(Laufgeschwindigkeit/2);
  BildVersatz=-7;
  Ofs=Ofs*4;
  char Spiegel=ZufallBoolean2;
  for (char Schiebung=0; Schiebung<15; Schiebung++) {
    ZeigeBild(UBootBilder[0+Ofs], Spiegel);
    ZeigeBild(UBootBilder[1+Ofs], Spiegel);
    ZeigeBild(UBootBilder[2+Ofs], Spiegel);
    ZeigeBild(UBootBilder[3+Ofs], Spiegel);
    ZeigeBild(UBootBilder[0+Ofs], Spiegel);
    BildVersatz++;
  }
}

//---------------------------------------------------------------------------

void Autos(byte Anzahl) {
  while(Anzahl>0) {
    byte MitAnhaenger=Random(4);
    Richtung=ZufallBoolean2;
    ZeigeMusterstreifen(AutoMuster[Random(AnzahlAutoMuster)], Random(4), false);
    if (MitAnhaenger==0) ZeigeMusterstreifen(AnhaengerMuster[Random(AnzahlAnhaengerMuster)], Random(4), false);
    SchiebeGrosserAbstandLaufgeschwindigkeit();
    Anzahl--;
  }
  SchiebeLeerLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeIntermezzoZufaellig(byte Zufall) {
  if (bitRead(AktTasten,XJ4_Bit)==1) {
    Vorbereitung();
    const char * Winkel=(const char*)pgm_read_word(&(WinkelArten[Random(AnzahlWinkel)]));

    if (Zufall==0xFF) Zufall=Random(MaxIntermezzo+1);

    switch(Zufall) {
      case  0: BlinkenBilder(HerzenBilder[Random(2)], HerzenBilder[Random(1,4)], Random(4,7)); break;
      case  1: BlinkenBilder(Gesicht1Bild, GesichterBilder[Random(3)], Random(4,7)); break;
      case  2: BlinkenBilder(RautenBilder[Random(2)+3*ZufallBoolean1], RautenBilder[Random(3)+2*ZufallBoolean1], Random(4,7)); break;
      case  3: BlinkenBilder(Hampel1Bild, Hampel2Bild, Random(4,7)); break;
      case  4: Rotor(ZufallBoolean1, Random(AnzahlRotor), Winkel, 16*Random(2,4)); break;
      case  5: Richtung=Links; ZeigeMusterstreifen(EGSMuster, 0x01*Random(4)+0x54*Random(4), true); break;
      case  6: Richtung=Links; ZeigeMusterstreifen(EGSMuster+11, 0x15*ZufallBoolean1+0x2A*ZufallBoolean2, true); break;
      case  7: Richtung=ZufallBoolean1; Autos(Random(1,6)); break;
      case  8: ZeigeText(HalloText, true, true); break;
      case  9: DreieckSinusWelle(29,ZufallBoolean1); break;
      case 10: AufAb(Random(3),30); break;
      case 11: Regen(60); break;
      case 12: AlleEinAlleAus(2); break;
      case 13: Wuerfeln(Random(50,57)); break;
      case 14: DreierMuster(Random(AnzahlDreierMuster),10); break;
      case 15: ViererMuster(Random(AnzahlViererMuster), 10); break;
      case 16: FuenferMuster(Random(AnzahlFuenferMuster),10); break;
      case 17: SiebenerMuster(Random(AnzahlSiebenerMuster),10); break;
      case 18: UBoot(Random(AnzahlUbootBilder)); break;

      default: PauseOk=false;
    }
    MachePause();
  }
}

//---------------------------------------------------------------------------

void ZeigeDatumLinks(byte Art, byte Art2) {
  if (Art<=7) {
    if (bitRead(Art,0)==1) {
      SchiebeZeichenLinksLaufgeschwindigkeit(WochenTagTexte[WTag][0]);
      SchiebeAbstandLinksLaufgeschwindigkeit();
      SchiebeZeichenLinksLaufgeschwindigkeit(WochenTagTexte[WTag][1]);
      ZeigeMatrixZeigedauer();
      SchiebeZeichenLinksLaufgeschwindigkeit(Punkt);
    }

    SchiebeZeigeZahlLinks(Tag);
    SchiebeZeichenLinksLaufgeschwindigkeit(Punkt);

    SchiebeZeigeZahlLinks(Monat);
    SchiebeZeichenLinksLaufgeschwindigkeit(Punkt);

    if (bitRead(Art,1)==1) {
      if (bitRead(Art,2)==1) {
        SchiebeZeigeZahlLinks(20);  // Jahrhundert
        SchiebeAbstandLinksLaufgeschwindigkeit();
      }
      SchiebeZeigeZahlLinks(Jahr);
      SchiebeAbstandLinksLaufgeschwindigkeit();
    }
   if (Art2==1) ZeigeTagImJahr();
   if (Art2==2) ZeigeWocheImJahr();
  }  else {
    ZeigeDatumUS();
  }
  Richtung=Links;
  SchiebeGrosserAbstandLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeUhrzeitLinks() {
  SchiebeZeigeZahlLinks(Stunden);
  SchiebeZeichenLaufgeschwindigkeit(Doppelpunkt);
  SchiebeZeigeZahlLinks(Minuten);
  SchiebeLeerLinksLaufgeschwindigkeit();
}

//---------------------------------------------------------------------------

void ZeigeNeueUhrzeitLinks() {
  HoleUhr();
  ZeigeUhrzeitLinks();
}

//---------------------------------------------------------------------------

void ZeigeTemperaturLinks() {
  HoleTemperatur();
  SchiebeZeigeZahlLinks(Temperatur);
  AbspannGradCelsiusLinks();
}

//---------------------------------------------------------------------------

void Trio(byte Art1, byte Art2) {
  ZeigeDatumLinks(Art1, Art2);
  ZeigeUhrzeitLinks();
  ZeigeTemperaturLinks();
  MachePause();
}

//---------------------------------------------------------------------------

void setup() {
  Wire.begin();
  for (char Zeile=ObereZeile; Zeile<=UntereZeile; Zeile++) {
    pinMode(ZeilenPins[Zeile], OUTPUT);
    digitalWrite(ZeilenPins[Zeile], LOW);
  }
  for (char i=0; i<3; i++) {
    pinMode(DecoderPins[i], OUTPUT);
    digitalWrite(DecoderPins[i], LOW);
  }

  pinMode(WeckerPin, OUTPUT);
  digitalWrite(WeckerPin, HIGH); // Piezzotest
  delay(100);
  digitalWrite(WeckerPin, LOW);

  pinMode(TastenPin, INPUT_PULLUP);
  do {
    Multiplexen(MaxAnzeigeDauer/2);
  } while ((AktTasten&TastenMaske)!=0);

  Modus=0;
  Abbruch=false;
  if (HoleUhr()==false) SpeichereWecker(); // Batteriespannung war wohl weg
  HoleWecker();
  randomSeed((Stunden*60+Minuten)*60+Sekunden);
  Vorbereitung(); //
// alles zum Testen neuer Muster (auskommentiert)
//  while(!Abbruch) { for(byte i=0; i<=MaxUhrzeit; i++) ZeigeUhrzeitZufaellig(i); } // XJ2 stecken
//  while(!Abbruch) { for(byte i=0; i<=MaxTemperatur; i++) ZeigeTemperaturZufaellig(i); } // XJ3 stecken
//  while(!Abbruch) { for(byte i=0; i<=MaxIntermezzo; i++) ZeigeIntermezzoZufaellig(i); } // XJ4 stecken
//  while(!Abbruch) { ZeigeUhrzeitZufaellig(46); }  // XJ2 stecken
//  while(!Abbruch) { ZeigeTemperaturZufaellig(MaxGleich+13); } // XJ3 stecken
//  while(!Abbruch) { ZeigeIntermezzoZufaellig(18);  }
}

//---------------------------------------------------------------------------

void loop() {
  Vorbereitung();
  switch (Modus) {
    case 0:
      if (WeckerSchellt>0) {
          ZeigeNeueUhrzeitLinks();
      } else {
        if ((AktTasten&JumperMaske)==0){ // keine Jumper gesteckt
          Trio(7, 0); // mit Tag, Jahr 4 stellig, ohne Zusatz
        } else {
          if (bitRead(AktTasten,XJ1_Bit)) Trio(Random(9), Random(8));
          ZeigeUhrzeitZufaellig2x();
          ZeigeTemperaturZufaellig();
          ZeigeUhrzeitZufaellig2x();
          ZeigeIntermezzoZufaellig(0xFF);
          ZeigeUhrzeitZufaellig2x();
          ZeigeTemperaturZufaellig();
          ZeigeUhrzeitZufaellig2x();
        }
      }
      break;
    case ZeitStellModus:    Stelle(Jahr, JahrTrenner, 0, 99); break;
    case ZeitStellModus+1:  Stelle(Monat, MonatTrenner, 1, 12); break;
    case ZeitStellModus+2:  Stelle(Tag, TagTrenner, 1, MaxTage[Monat-1]); break;
    case ZeitStellModus+3:  Stelle(Stunden, StundenTrenner, 0, 23); break;
    case ZeitStellModus+4:  Stelle(Minuten, MinutenTrenner, 0, 59); break;
    case ZeitStellModus+5:  SpeichereUhr(); Modus=0; break;

    case WeckerStellModus:   Stelle(WeckerWTag, WeckerWTagTrenner, Montag, Sonntag); break;
    case WeckerStellModus+1: Stelle(WeckerEinAus[WeckerWTag], WeckerEinAusTrenner, WeckerAus, WeckerEin); break;
    case WeckerStellModus+2: Stelle(WeckerStunden[WeckerWTag], WeckerStundenTrenner, 0, 23); break;
    case WeckerStellModus+3: Stelle(WeckerMinuten[WeckerWTag], WeckerMinutenTrenner, 0, 59); break;
    case WeckerStellModus+4: SpeichereWecker(); Modus=0; break;

    default: Modus=0;
  }
  Abbruch=false;
}

//---------------------------------------------------------------------------