Desplazamiento de letras, agregar animaciones MAX7219

International Español Software
1

Buen día con todos del foro.

Tengo un módulo de matriz MAX7219 (4 en 1) controlado con un arduino nano, lo que necesito realizar es que me muestre una serie de textos con distintos efectos y luego mostrar varios tipos de animaciones.
Texto: puede ser una palabra o una oración
Animación: distintos tipos de dibujos que pueda mostrar la matriz

Objetivo: Después de un determinado texto quiero que se muestre una animación que yo elija y luego que siga mostrando los textos que continúen y volver a mostrar otra animación distinta.

Problema: No puedo hacer que muestre una animación distinta que yo elija en cualquier momento. solo pude hacer que salga la misma animación

Uso el IDE Arduino 1.8.9
Librerias:

  • MD_MAX72XX by majicDesigns Versión 3.1.0
  • MD_Parola by majicDesigns Versión 3.1.1

En cada
"#if ENA_SPRITE
{ PA_SPRITE, "FUERZA", 5, 5 },
#endif"
quiero que salga una animación distinta

Código:

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
#include <MD_UISwitch.h>

// Define the number of devices we have in the chain and the hardware interface
// NOTE: These pin numbers will probably not work with your hardware and may
// need to be adapted
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CLK_PIN   13
#define DATA_PIN  11
#define CS_PIN    10

// Hardware SPI connection
MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
// Arbitrary output pins
// MD_Parola P = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(x[0]))

// Global data
struct sCatalog
{
  textEffect_t  effect;   // text effect to display
  char *        psz;      // text string nul terminated
  uint16_t      speed;    // speed multiplier of library default
  uint16_t      pause;    // pause multiplier for library default
};

sCatalog  catalog[] =
{
  { PA_PRINT, "DE:", 2, 3 },
  { PA_SCROLL_LEFT, "POPEYE", 8, 0 },
  { PA_PRINT, "PARA:", 2, 3 },
  { PA_SCROLL_DOWN, "OLIVA", 6, 5 },

#if ENA_SPRITE //
  { PA_SPRITE, "FELIZ", 5, 5 },
#endif

  { PA_SCROLL_LEFT, "TODO ES POSIBLE", 7, 0 },
  { PA_SCROLL_LEFT, "", 7, 0 },
  { PA_SCROLL_LEFT, "EXITOS EN TODOS LOS NUEVOS RETOS", 7, 0 },

#if ENA_SPRITE
  { PA_SPRITE, "FUERZA", 5, 5 },
#endif

{ PA_PRINT, "Y", 1, 1 },

#if ENA_SPRITE
  { PA_SPRITE, "FELICES", 5, 5 },
#endif


};// Sprite Definitions

const uint8_t F_PMAN1 = 6;
const uint8_t W_PMAN1 = 8;
static const uint8_t PROGMEM pacman1[F_PMAN1 * W_PMAN1] =  // gobbling pacman animation
{
 0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
};

const uint8_t F_PMAN2 = 6;
const uint8_t W_PMAN2 = 18;
static const uint8_t PROGMEM pacman2[F_PMAN2 * W_PMAN2] =  // ghost pursued by a pacman
{
  0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x73, 0xfb, 0x7f, 0xf3, 0x7b, 0xfe,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x73, 0xfb, 0x7f, 0xf3, 0x7b, 0xfe,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x73, 0xfb, 0x7f, 0xf3, 0x7b, 0xfe,
};

void setup(void)
{
  P.begin();
#if ENA_SPRITE
  P.setSpriteData(pacman1, W_PMAN1, F_PMAN1, pacman2, W_PMAN2, F_PMAN2);
#endif

  for (uint8_t i=0; i<ARRAY_SIZE(catalog); i++)
  {
    catalog[i].speed *= P.getSpeed();
    catalog[i].pause *= 500;
  }
}

void loop(void)
{
  static textPosition_t just = PA_LEFT;
  static uint8_t i = 0;
  static uint8_t j = 0;

  if (P.displayAnimate()) // animates and returns true when an animation is completed
  {
    // rotate the justification if needed
    if (i == ARRAY_SIZE(catalog))
    {
      j++;
      if (j == 3) j = 0;

      switch (j)
      {
      case 0: just = PA_LEFT;    break;
      case 1: just = PA_CENTER;  break;
      case 2: just = PA_RIGHT;   break;
      }

      i = 0;  // reset loop index
    }

    // set up new animation
    P.displayText(catalog[i].psz, just, catalog[i].speed, catalog[i].pause, catalog[i].effect, catalog[i].effect);

    delay(catalog[i].pause);  // wait a while to show the text ...
    i++;                      // ... then set up for next text effect
  }
}

Lista de animaciones que quiero agregar con posibilidad de agregar más:

const uint8_t F_PMAN1 = 6;
const uint8_t W_PMAN1 = 8;
const uint8_t PROGMEM pacman1[F_PMAN1 * W_PMAN1] =  // gobbling pacman animation
{
  0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c,
};

const uint8_t F_PMAN2 = 6;
const uint8_t W_PMAN2 = 18;
const uint8_t PROGMEM pacman2[F_PMAN2 * W_PMAN2] =  // ghost pursued by a pacman
{
  0x00, 0x81, 0xc3, 0xe7, 0xff, 0x7e, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x3c, 0x7e, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x24, 0x66, 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
  0x00, 0x42, 0xe7, 0xe7, 0xff, 0xff, 0x7e, 0x3c, 0x00, 0x00, 0x00, 0xfe, 0x7b, 0xf3, 0x7f, 0xfb, 0x73, 0xfe,
};

const uint8_t F_ROLL1 = 4;
const uint8_t W_ROLL1 = 8;
const uint8_t PROGMEM roll1[F_ROLL1 * W_ROLL1] =  // rolling square
{
  0xff, 0x8f, 0x8f, 0x8f, 0x81, 0x81, 0x81, 0xff,
  0xff, 0xf1, 0xf1, 0xf1, 0x81, 0x81, 0x81, 0xff,
  0xff, 0x81, 0x81, 0x81, 0xf1, 0xf1, 0xf1, 0xff,
  0xff, 0x81, 0x81, 0x81, 0x8f, 0x8f, 0x8f, 0xff,
};

const uint8_t F_ROLL2 = 4;
const uint8_t W_ROLL2 = 8;
const uint8_t PROGMEM roll2[F_ROLL2 * W_ROLL2] =  // rolling octagon
{
  0x3c, 0x4e, 0x8f, 0x8f, 0x81, 0x81, 0x42, 0x3c,
  0x3c, 0x72, 0xf1, 0xf1, 0x81, 0x81, 0x42, 0x3c,
  0x3c, 0x42, 0x81, 0x81, 0xf1, 0xf1, 0x72, 0x3c,
  0x3c, 0x42, 0x81, 0x81, 0x8f, 0x8f, 0x4e, 0x3c,
};

const uint8_t F_LINES = 3;
const uint8_t W_LINES = 8;
const uint8_t PROGMEM lines[F_LINES * W_LINES] =  // spaced lines
{
  0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00,
  0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00,
  0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff,
};

const uint8_t F_ARROW1 = 3;
const uint8_t W_ARROW1 = 10;
const uint8_t PROGMEM arrow1[F_ARROW1 * W_ARROW1] =  // arrow fading to center
{
  0x18, 0x3c, 0x7e, 0xff, 0x7e, 0x00, 0x00, 0x3c, 0x00, 0x00,
  0x18, 0x3c, 0x7e, 0xff, 0x00, 0x7e, 0x00, 0x00, 0x18, 0x00,
  0x18, 0x3c, 0x7e, 0xff, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x18,
};

const uint8_t F_ARROW2 = 3;
const uint8_t W_ARROW2 = 9;
const uint8_t PROGMEM arrow2[F_ARROW2 * W_ARROW2] =  // arrow fading to outside
{
  0x18, 0x3c, 0x7e, 0xe7, 0x00, 0x00, 0xc3, 0x00, 0x00,
  0x18, 0x3c, 0x7e, 0xe7, 0xe7, 0x00, 0x00, 0x81, 0x00,
  0x18, 0x3c, 0x7e, 0xe7, 0x00, 0xc3, 0x00, 0x00, 0x81,
};

const uint8_t F_SAILBOAT = 1;
const uint8_t W_SAILBOAT = 11;
const uint8_t PROGMEM sailboat[F_SAILBOAT * W_SAILBOAT] =  // sail boat
{
  0x10, 0x30, 0x58, 0x94, 0x92, 0x9f, 0x92, 0x94, 0x98, 0x50, 0x30,
};

const uint8_t F_STEAMBOAT = 2;
const uint8_t W_STEAMBOAT = 11;
const uint8_t PROGMEM steamboat[F_STEAMBOAT * W_STEAMBOAT] =  // steam boat
{
  0x10, 0x30, 0x50, 0x9c, 0x9e, 0x90, 0x91, 0x9c, 0x9d, 0x90, 0x71,
  0x10, 0x30, 0x50, 0x9c, 0x9c, 0x91, 0x90, 0x9d, 0x9e, 0x91, 0x70,
};

const uint8_t F_HEART = 5;
const uint8_t W_HEART = 9;
const uint8_t PROGMEM heart[F_HEART * W_HEART] =  // beating heart
{
  0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
  0x0e, 0x1f, 0x33, 0x66, 0xcc, 0x66, 0x33, 0x1f, 0x0e,
  0x0e, 0x1f, 0x3f, 0x7e, 0xfc, 0x7e, 0x3f, 0x1f, 0x0e,
  0x0e, 0x1f, 0x33, 0x66, 0xcc, 0x66, 0x33, 0x1f, 0x0e,
  0x0e, 0x11, 0x21, 0x42, 0x84, 0x42, 0x21, 0x11, 0x0e,
};

Soy novato en programar Arduino y lo poco que voy aprendiendo lo hago empíricamente.

Gracias por la ayuda.

2

Buenos días,

Veo que estás haciendo una animación del comecocos. Yo tambien estoy en ello, por si te sirve de ayuda te pongo una de las que tengo, luego la analizas y la modificas con lo que necesites.

Yo soy aficionado y puede que no sea la mejor manera de programar pero funciona y queda muy chula:

Las bibliotecas que he usado:

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>

Max72xxPanel_library_download
En los ejemplos de la biblioteca Max72xxPanel vienen maneras de definir los paneles de led. En este caso 4x1.

Definiciones:

byte PACMANOPENL[8] = { 0x3C, 0x7E, 0x3F, 0x1F, 0x1F, 0x3F, 0x7E, 0x3C };
byte PACMANCLOSED[8] = { 0x3C,0x7E,0xFF,0xFF,0xFF,0xFF,0x7E,0x3C };
byte DOT[8] = { 0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00 };

Max72xxPanel matrix = Max72xxPanel(pinCS, 4, 4);
//Pin al Cs (leer documentación de la biblioteca, en mi caso es el pin 10)
const int delayanimation = 100; // En milisegundos
//Retraso entre un frame y otro de la animación (cambia la velocidad de la animación)

En el setup:

void setup()
...
	matrix.setIntensity(15); // Ajustar el brillo entre 0 y 15

	// Ajustar segun las necesidades
	matrix.setPosition(0, 0, 0); // El primer display esta en <0, 0>
	matrix.setPosition(1, 1, 0); // El segundo display esta en <1, 0>
	matrix.setPosition(2, 2, 0); // El tercer display esta en <2, 0>
	matrix.setPosition(3, 3, 0); // El cuarto display esta en <3, 0>

	matrix.setRotation(0, 1); // Posición del display
	matrix.setRotation(1, 1); // Posición del display
	matrix.setRotation(2, 1); // Posición del display
	matrix.setRotation(3, 1); // Posición del display

	matrix.fillScreen(LOW); //Borra todo el display
	matrix.write(); //Después de borrar no es necesario, pero está puesto porque a veces quedaba un punto o puntos en el display. No se por lo que era, pero esto lo solución.
...

Y la función de la animación:

//Pacman come puntos: Enviando un 0 Lo hace de Izda-decha y un 1 Decha-izda
void pacman_eat_dots(byte dir = 0) {
	bool endanimation = false;
	int pacmanpos = 32; //Posición inicial del pacman. Un pilxel fuera de la matriz. Por la derecha
	if (dir == 1) pacmanpos = -8; //Posición inicial del pacman. Un pilxel fuera de la matriz. Por la izquierda
	bool frame = true; //frame true = Pacman abierto o false=Pacman cerrado
	do {
		matrix.fillScreen(LOW); //Borra toda la matiz
//Dibuja los puntos donde corresponde según el estado de la animación, si ha pasado el pacmanpor ese posición ya no lo dibuja.
		if (pacmanpos > 24 && dir == 0) matrix.drawBitmap(24, 0, DOT, 8, 8, 1);
		if (pacmanpos < 24 && dir == 1) matrix.drawBitmap(24, 0, DOT, 8, 8, 1);
		if (pacmanpos > 16 && dir == 0) matrix.drawBitmap(16, 0, DOT, 8, 8, 1);
		if (pacmanpos < 16 && dir == 1) matrix.drawBitmap(16, 0, DOT, 8, 8, 1);
		if (pacmanpos > 8 && dir == 0) matrix.drawBitmap(8, 0, DOT, 8, 8, 1);
		if (pacmanpos < 8 && dir == 1) matrix.drawBitmap(8, 0, DOT, 8, 8, 1);
		if (pacmanpos > 0 && dir == 0) matrix.drawBitmap(0, 0, DOT, 8, 8, 1);
		if (pacmanpos < 0 && dir == 1) matrix.drawBitmap(0, 0, DOT, 8, 8, 1);

//Dibuja el pacman en la posición correspondiente. Abierto o cerraro
		if (dir == 0 && frame == true) matrix.drawBitmap(pacmanpos, 0, PACMANOPENL, 8, 8, 1);
		if (dir == 1 && frame == true) matrix.drawBitmap(pacmanpos, 0, PACMANOPENR, 8, 8, 1);
		if (frame == false) matrix.drawBitmap(pacmanpos, 0, PACMANCLOSED, 8, 8, 1);

		frame = !frame; //Hay que cambiar de frame (Pacman abierto o cerrado)
		dir == 0 ? pacmanpos-- : pacmanpos++; //Incrementa o decrementa una posición del pacman
		if (dir == 0 && pacmanpos == -9) endanimation = true; //Si va hacia la izquierda y sale de la matriz, termina la animación
		if (dir == 1 && pacmanpos == 33) endanimation = true; //Si va hacia la derecha y sale de la matriz , termina la animación
		if (wait(delayanimation)) return; //Si durante la espera ha llegado algo por le Seial, sale de la animación
		matrix.write(); //Dibuja todo en la matriz (IMPRESCINDIBLE)

	} while (endanimation == false); //Lo hace todo de nuevo hasta que termine la animación
}



bool wait(unsigned long ms) {
	//espera x msec y si hay algo en el serial sale e interrumpe la animación
	unsigned long end = millis() + ms;
	do {
		if (Serial.available()) return true;
	} while (millis() < end);
	return false;
}

Llamando pacman_eat_dots(0) hace la animación de izquierda a derecha y con un 1 de derecha a izquierda.

La función wait hace un retardo entre frames pero si le llega algo por el serial sale de la animación. Ahí puedes poner cualquier condición que se cumpla para salir de ella.

Acabo de comentar el código sobre la marcha, espero que esté todo correcto.

Espero que te sirva.

Un saludo

3

Saludos pepepotero, muchas gracias por tu apoyo.

Estube revisando el código que publicaste pero aún llego al mismo problema.

Mi objetivo es que en la matriz MAX7219 me muestre el desplazamiento de una oración, luego que salga un corazón animado depués otra oración y seguidamente otra animación (un barco), y así repetidamente con distintas animaciones.

No tengo problemas con el desplazamiento de las oraciones pero sí para colocar una animación distinta después de cada oración.

Espero hacerme entender.

4

Hola Felidos,

Vale, ahora entiendo lo que querías hacer. Cierto es que no se me ocurre como hacer que inmediatamente salga un icono/grafico/animación después del texto. Sí que he podido hacerlo de manera que salga todo el texto, y una vez haya salido por la izquierda, empiece la animación, y una vez terminada salga el siguiente texto. Eso se consigue llamando a la función de scroll del texto, luego a la animación/icono/gráfico y luego al siguiente texto...

Si no te importa que las letras vayan saliendo "enteras" puedes probar esto:

//Animacion del personaje y el nombre de algunos textos
void animate_icon_name() {

 randomSeed(analogRead(A3)); //Selecciona una semilla para random leyendo el pin A3 que no tiene nada conectado

 byte character = random(5);//Elige un personaje de los 5 definidos (entre el 0 y el 4)

 bool endanimation = false; //Activa la bandera que indica si hay que salir de la animación

 int pacmanpos = 32; //Posición inicial del personaje delante del texto (fuera de la matriz por la derecha)

 int ghostpos = 45; //Posición inicial del texto (fuera de la matriz por la derecha)

 bool frame = true; //Frame true = frame1 o false=frame2

 byte pacman0[8]; //Define un buffer para recibir una copia del frame 1 del personaje elegido
 byte pacman1[8]; //Define un buffer para recibir una copia del frame 2 del personaje elegido

        //Define los textos que se pueden elegir
 String name[] = { F("TEXTO1"),F("TEXTO2"),F("TEXTO3"),F("TEXTO4"),F("TEXTO5") };

        //Hace una copia de los frames del personaje seleccionado al buffer 
 if (character == 0) memmove(pacman0, PERSONAJE10, 8);
 if (character == 0) memmove(pacman1, PERSONAJE11, 8);
 if (character == 1) memmove(pacman0, PERSONAJE20, 8);
 if (character == 1) memmove(pacman1, PERSONAJE21, 8);
 if (character == 2) memmove(pacman0, PERSONAJE30, 8);
 if (character == 2) memmove(pacman1, PERSONAJE31, 8);
 if (character == 3) memmove(pacman0, PERSONAJE41, 8);
 if (character == 3) memmove(pacman1, PERSONAJE51, 8);
 if (character == 4) memmove(pacman0, PERSONAJE60, 8);
 if (character == 4) memmove(pacman1, PERSONAJE61, 8);
        //PERSONAJExf es el personaje x frame f definidos con byte PERSONAJExf[8] = {...} 
 do {
 matrix.fillScreen(LOW); //borra la pantalla

                //Dibuja el personaje seleccionado y frame correcto delante  y detrás del texto
 if (frame) matrix.drawBitmap(pacmanpos, 0, pacman0, 8, 8, 1);
 if (!frame) matrix.drawBitmap(pacmanpos, 0, pacman1, 8, 8, 1);
 if (frame) matrix.drawBitmap(pacmanpos+name[character].length()*8, 0, pacman0, 8, 8, 1);
 if (!frame) matrix.drawBitmap(pacmanpos + name[character].length() * 8, 0, pacman1, 8, 8, 1);

 matrix.setCursor(ghostpos, 0); //Coloca el cursor detras del personaje 
 matrix.print(name[character]); //Imprime el texto seleccionado

 frame = !frame; // Cambia de frame

 pacmanpos--; ghostpos--; //decrementa la posición del personaje y del texto

 if (pacmanpos == -name[character].length()*8 - 22) endanimation = true; //Comprueba si el personaje detrás del texto se ha ido por la izquierda para terminar la animación
 if (wait(80)) return; //Si le llega algo por el Serial termina la animación (ver post anterior)

 matrix.write(); //Dibuja la pantalla
 } while (endanimation == false); //Hazlo todo hasta que la bandera de fin esté en false

}

Inconvenientes de esta función y problemas que me he encontrado:
-Las letras salen una a una, no un texto "escroleado" suave.
-Supone que todas las letras tienen el mismo ancho, por lo que si el texto lleva una/s "l", un/os "1" y demás caracteres "delgados" hacen que el personaje de atrás se separe del texto.

Ni que decir tiene que uno de los personajes es el pacman del post anterior :slight_smile:

Pongo la función tal y como la tengo a día de hoy. Como verás las variables son del "reciclado" una de las animaciones del pacman. Después cambiaré los nombres de las variables ya que la tengo sin tocar desde hace unos días por falta de tiempo y tal vez podamos sacar algo en claro porque también me interesa mejorarla también.

Como habrás podido ver el la animación se basa en la Persistencia de la visión en el ojo humano de manera que lo que se hace es activar los pixeles de un frame durante unos milisegundos, borrar la matriz, activar los pixeles del siguiente frame, borrar la matrix... y así durante toda la animación. Para una animación suave al menos tiene que haber 25 frames por segundo, lo que quiere decir que entre frame y frame tiene que haber unos 40ms. No he controlado los tiempos ya que, por prueba, entre 80 y 100 ms de espera entre frames consigo una animación con 2 frames bastate aceptable para lo que pretendo.
Se puede mejorar la suavidad, poniendo más frames para cada personaje (por ejemplo pacman abierto, pacman a medio abrir, pacman casi cerrado y pacman cerrado) y controlando los tiempos de encendido y pausa, pero, reitero, no es lo que pretendo.
En cuanto tenga un rato, volveré a analizar la función de scroll del texto que adapté de uno de los ejemplos y ver como meter ahí los gráfico. A lo mejor es una perugrullada, pero no he dado con ella.

Creo que es otro pasito más.

Un saludo

5

Buen día pepepotero.
Actualmente me encuentro en un viaje de trabajo el cual se está prolongando bastante. Espero que en un par de semanas más pueda retomar el Arduino para poder aplicar tus pautas de ayuda y hacer un sketch que sea funcional.

Saludos