Creación de símbolos con CreateChar LCD20x4 y ShiftRegister

Hola a todos, estoy realizando mi proyecto de fin de Grado con un Arduino UNo, que lleva conectado una pantalla LCD 20x4 QY-2004A que es compatible con HD44780.

Primero decir que utilizo un ShiftRegister 74LS164N para reducir el número de pines que ocupo del Arduino.
Ahora la duda:

Estoy intentando crear el símbolo de mi titulación para que aparezca reflejado en la LCD.
He dividido el símbolo en cuadrantes que se corresponden con cada casilla del LCD, dividiendo a su vez estas casillas en los pixels correspondientes por cada casilla.
Una vez hecha la división he pasado el dibujo a 1 y 0 en función de cada casilla, para crear un nuevo caracter por cada casilla ocupada.
El problema viene a la hora de meter dichos caracteres al Arduino, ya que me funciona perfectamente cuando introduzco hasta 7 caracteres nuevos, y a partir de ahí el dibujo se distorsiona y se entremezcla todo.
He observado que solo funcionan los caracteres que designo entre los números 2 y 9 y a partir de ahí he ido probando a designarlos con otros números, letras, simbolos… pero no funciona.

Alguien sabría ayudarme??

Copio el programa ( la parte activa, es decir la que no está escrita como texto, es el límite hasta el cual funciona mi inclusión de caracteres, a partir de ahí , es decir si activo alguna linea más, se entremezclan y distorsionan los caracteres).

MUCHAS GRACIAS DE ANTEMANO ¡¡¡

#include <ShiftRegLCD123.h>

const byte dataPin = 10; // SR Data from Arduino pin 10
const byte clockPin = 11; // SR Clock from Arduino pin 11
const byte enablePin = 12; // LCD enable from Arduino pin 12

// Instantiate an LCD object using ShiftRegLCD123 wiring.
// LCD enable directly from Arduino.
ShiftRegLCD123 srlcd(dataPin, clockPin, enablePin, SRLCD123);

byte letra2[8] = { B00000,B00000,B00000,B00001,B00001,B00011,B01001,B11100 };
byte letra3[8] = { B00010,B00010,B11111,B10010,B10010,B10010,B10010,B11111 };
byte letra4[8] = { B00000,B00000,B11000,B10100,B10100,B10110,B10100,B11001 };
byte letra6[8] = { B00001,B00011,B00011,B00110,B00011,B00110,B01101,B01110 };
byte letra7[8] = { B01000,B10000,B00000,B00000,B00000,B00011,B00011,B00000 };
byte letra8[8] = { B00000,B00010,B00111,B01010,B10010,B00111,B00010,B00010 };
byte letra9[8] = { B00001,B00000,B00000,B10000,B01000,B00110,B00110,B00000 };
byte letra0[8] = { B11100,B01110,B01110,B00011,B00110,B00010,B00011,B00011 };
/*byte letraw[8] = { B01100,B10100,B01111,B00100,B01111,B00010,B00001,B00101 };
byte letrae[8] = { B00100,B00000,B00100,B00000,B00100,B00000,B00100,B10000 };
byte letrar[8] = { B11010,B11111,B11111,B11111,B11111,B11010,B01111,B00111 };
byte letrat[8] = { B10001,B11100,B11101,B11100,B11101,B10000,B10000,B00000 };
byte letray[8] = { B00101,B00011,B00011,B00111,B00111,B01010,B00011,B01101 };
byte letrau[8] = { B10100,B01011,B00111,B01111,B00011,B00000,B00011,B00001 };
byte letrai[8] = { B00010,B00000,B11000,B11111,B01111,B10011,B01100,B00000 };
byte letrao[8] = { B00000,B00011,B10110,B00111,B11000,B01100,B11110,B00100 };
byte letrap[8] = { B01110,B11000,B00000,B10000,B00000,B00000,B00000,B00000 }; */

void setup()
{
srlcd.createChar(2, letra2);
srlcd.createChar(3, letra3);
srlcd.createChar(4, letra4);
srlcd.createChar(6, letra6);
srlcd.createChar(7, letra7);
srlcd.createChar(8, letra8);
srlcd.createChar(9, letra9);
/*srlcd.createChar(1, letra0);
srlcd.createChar(11, letraw);
srlcd.createChar(12, letrae);
srlcd.createChar(13, letrar);
srlcd.createChar(14, letrat);
srlcd.createChar(15, letray);
srlcd.createChar(17, letrau);
srlcd.createChar(18, letrai);
srlcd.createChar(19, letrao);
srlcd.createChar(20, letrap); */
srlcd.begin(20, 4);
// SITUO EL CURSOR
srlcd.setCursor(9,0);
srlcd.write(2);
srlcd.setCursor(10,0);
srlcd.write(3);
srlcd.setCursor(11,0);
srlcd.write(4);
srlcd.setCursor(8,1);
srlcd.write(6);
srlcd.setCursor(9,1);
srlcd.write(7);
srlcd.setCursor(10,1);
srlcd.write(8);
srlcd.setCursor(11,1);
srlcd.write(9);
/*srlcd.setCursor(12,1);
srlcd.write(1);
srlcd.setCursor(8,2);
srlcd.write(11);
srlcd.setCursor(9,2);
srlcd.write(12);
srlcd.write(13);
srlcd.setCursor(11,2);
srlcd.write(14);
srlcd.setCursor(12,2);
srlcd.write(15);

srlcd.setCursor(9,3);
srlcd.write(17);
srlcd.setCursor(10,3);
srlcd.write(18);
srlcd.setCursor(11,3);
srlcd.write(19);
srlcd.setCursor(12,3);
srlcd.write(20);*/

}

void loop()
{
}

El problema que tienes es debido a que solo se pueden crear 8 caracteres nuevos, luego para que funciona bien tendrías que ponerle números del 0 al 7. A la que pones otros números los empieza a mezclar.

Como veo supongo, que ya te habrá pasado el numero cero da un error de ambigüedad, cuando intentas poner lcd.write(0);
si lo substituyes por lcd.write((uint8_t)0); ya funcionará bien.

Muchas gracias Javi por la respuesta.
El problema que mayormente tengo es que necesito generar más de 8 nuevos caracteres, para poder generar el símbolo completo de la escuela.
alguna posible solución?
Imaginé que había un límite de caracteres nuevos (8) pero no se si es por programa o por sección de programa...
Es decir si yo creo un ... void Escudoparte1() y en el genero 8 caracteres, cuando deje de ejecutarse este void Escudoparte1() esos caracteres no se borran de la pantalla salvo que introduzca un clear().
podría generar un nuevo void Escudoparte2() para generar otros 8 nuevos caracteres? y situarlos en las casillas correspondientes para que se junten con los anteriores??

o el límite de 8 nuevos caracteres es por el programa completo??

un saludo

Podrías probar esto pero no se si funcionara bien.
Por lo que parece es por la poca memoria ram del controlador de la pantalla
http://forum.arduino.cc/index.php/topic,8376.0.html

Gracias, en cuanto llegue a casa le echo un vistazo y ya comento si funciona o no.