Hier der komplette Sketch.

// Laufschrift

// PINs am PCB Board Leiste 1 (LED 4x4 Feld)

// GND
// (leer)
// 11 SH Shift
// 12 ST Store
// 13 DS Date
// (leer)
// VCC


//Pin verbunden mit dem ST_CP vom 74HC595
const byte latchPin = 12;
//Pin verbunden mit dem SH_CP vom 74HC595
const byte clockPin = 11;
//Pin verbunden mit dem DS vom 74HC595
const byte dataPin = 13;

const char zeichenvorrat[] = " ACDFHILOTU!.";
const char anzeigetext[] = " HALLO DU! ";
const byte textlaenge = strlen(anzeigetext);
byte starter = 0;

const byte zeichen[][4] =
{
  {B0000, B0000, B0000, B0000}, // Leerzeichen
  {B1110, B1010, B1110, B1010}, // A
  {B1110, B1000, B1000, B1110}, // C
  {B1100, B1010, B1010, B1100}, // D
  {B1110, B1000, B1100, B1000}, // F
  {B1010, B1010, B1110, B1010}, // H
  {B0010, B0010, B0010, B0010}, // I
  {B1000, B1000, B1000, B1110}, // L
  {B0100, B1010, B1010, B0100}, // O
  {B1110, B0100, B0100, B0100}, // T
  {B1010, B1010, B1010, B1110}, // U
  {B0100, B0100, B0000, B0100}, // !
  {B0000, B0000, B0000, B0100}  // .
};

void Ausgabe(byte wert)
{
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, LSBFIRST, wert);
  digitalWrite(latchPin, HIGH);
}


void setup() {
  // Pins für den 595 setzen
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}


void multiplexen(char symbol[])
{

  byte ausgabe;
  byte counter;

  for (int i = 0; i < 40; i++)
  {
    for (byte zeile = 0; zeile < 4; zeile++)
    {
      if ( zeile == 0 ) counter = B1000;
      ausgabe = symbol[zeile];
      for (byte led = 0; led < 4; led++)
      {
        byte pin;
        if ( led == 0 ) pin = B0001;
        Ausgabe(counter << 4 | (ausgabe & pin));
        delayMicroseconds(200);
        pin = pin << 1;
      }
      counter = counter >> 1;
    }
  }
}

void loop() {
  char zeichen1[4] = {0, 0, 0, 0};
  char zeichen2[4] = {0, 0, 0, 0};

  byte pZeichen = strchr(zeichenvorrat, anzeigetext[starter]) - zeichenvorrat;

  if ( pZeichen )
  {
    for (byte n = 0; n < 4; n++)
    {
      zeichen1[n] = zeichen[pZeichen][n];
    }
  }
  else
  {
    for (byte n = 0; n < 4; n++)
    {
      zeichen1[n] = zeichen[0][n];
    }
  }

  pZeichen = strchr(zeichenvorrat, anzeigetext[starter + 1]) - zeichenvorrat ;
  if ( pZeichen )
  {
    for (byte n = 0; n < 4; n++)
    {
      zeichen2[n] = zeichen[pZeichen][n];
    }
  }
  else
  {
    for (byte n = 0; n < 4; n++)
    {
      zeichen2[n] = zeichen[0][n];
    }
  }

  starter++;

  if (starter + 1 == textlaenge) starter = 0;

  byte ausgabefeld[4];

  for (byte i = 0; i < 4; i++)
  {
    ausgabefeld[i] = ( zeichen1[i] << 4 ) | zeichen2[i];
  }

  for (byte i = 0; i < 4; i ++)
  {

    char plexfeld[4];
    for (byte zeile = 0; zeile < 4; zeile++)
    {
      byte wert = ausgabefeld[zeile];
      wert = wert << i;
      wert = wert >> 4;
      plexfeld[zeile] = wert;
    }
    multiplexen(plexfeld);
  }
}

Das Prinzip ist leicht skalierbar. Sinnvoll lassen sich Lauftexte erst mit 5 Zeilen realisieren. In einer 4*4 Matrix ist z.B. ein „E“ nicht darstellbar. Ich baue gerade einen „Display“ mit 5 Zeichen á 5*3 Pixeln. Dieses soll als Zwischenanzeige für meine ALU fungieren.