Recupérer un valeur dans un tableau dans un tableau

ludocraft · October 16, 2022, 9:54pm

bonjour
j'essaye de recuperer une valeur dans un tableau lui méme dans un tableau

j'ai


const byte E[64] = {1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
const byte O[64] = {0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const byte R[64] = {1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
const byte T[64] = {1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const byte U[64] = {1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const byte V[64] = {1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

const byte OUVERT[] = {O,U,V,E,R,T};

par exemple j'essaye d'avoir la 4eme valeur de V depuis le tableau OUVERT
apres un long moment de reflexion je ne sais pas comment procder si quelqun peux me donner de l'aide sa serais avec plaisir

philippe86220 · October 17, 2022, 6:18am

Bonjour @ludocraft,
Un tableau est le regroupement logique de plusieurs variables de même type. Pour désigner un élément dans un tableau vous indiquez son numéro d’indice entre crochets, sachant que le premier élément est situé à l’indice 0.


byte const V[] = {1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
size_t const taille = sizeof V / sizeof * V;
byte var1;

void setup() {
  Serial.begin (115200);
  Serial.print("Taille du tableau : ");  Serial.println(taille);
  Serial.print("4eme valeur de V  : "); Serial.println(V[3]); // 4ème valeur de V ( 0 à 3)
  var1 = V[3];
  Serial.print("valeur de var1  : ");Serial.println(var1);

}

void loop() {
  // put your main code here, to run repeatedly:

}

Notez la manière de déclarer un tableau constant. Si le tableau est constant vous ne pourrez pas le modifier. impossible d'effectuer cette instruction :

V[3] = 0;

Tableau non constant (on peut modifier les valeurs) :


byte  V[] = {1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
size_t const taille = sizeof V / sizeof * V;
byte var1;

void setup() {
  Serial.begin (115200);
  Serial.print("Taille du tableau : ");  Serial.println(taille);
  Serial.print("4eme valeur de V  : "); Serial.println(V[3]); // 4ème valeur de V ( 0 à 3)
  var1 = V[3];
  Serial.print("valeur de var1  : ");Serial.println(var1);
  V[3] = 0;
 Serial.print("4eme valeur de V modifiée  : ");  Serial.println(V[3]);

}

void loop() {
  // put your main code here, to run repeatedly:

}

Vous pouvez déclarer votre tableau avec le nombre d'éléments :

byte  V[63] = {1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

ou :

byte const V[63] = {1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

Bonne journée.

philippe86220 · October 17, 2022, 7:08am

Pardon, J'ai mal lu votre question. Il faut utiliser un tableau de tableau
Par exemple vous reprenez tous vos tableaux O,U,V,E,R,T et vous les agencez comme dans mon code :


byte const V[5][10] = {
  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, 35, 36, 37, 38, 39, 40 ,
  41, 42, 43, 44, 45, 46, 47, 48, 49, 50
};
size_t const taille = sizeof V / sizeof * V;


void setup() {
  Serial.begin (115200);
  Serial.print("Taille du tableau : ");  Serial.println(taille);
  Serial.print("4eme valeur de V  : "); Serial.println(V[4][3]); // 4ème valeur du 5ème tableau
  }

void loop() {}

Dans mon exemple je récupère la 4ème valeur du 5ème tableau. En fait avec V[5][10], je créer un tableau de 5 sous-tableaux qui contiennent eux-mêmes 10 éléments. En mémoire, les cases des 5 sous-tableaux se suivent et forment un bloc contiguë : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11, 12, 13, 14, 15, 16, 17, 18, 19, 20...47, 48, 49, 50.
Bonne journée.

philippe86220 · October 17, 2022, 7:23am

Vous pouvez également créer une structure :

struct tabs {
 byte const E[64] = {1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
 byte const O[64] = {0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 byte const R[64] = {1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};
 byte const T[64] = {1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 byte const U[64] = {1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 byte const V[64] = {1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
};
struct tabs mesTableaux;
 

void setup() {
  Serial.begin(115200);
  Serial.print("4eme valeur de V : "); Serial.print(mesTableaux.V[3]);
}
 
 
void loop() {
  // put your main code here, to run repeatedly:

}

Voilà, c'est pas les moyens qui manquent ...

Une autre façon d'initialiser un tableau de tableaux plus proche de votre demande initiale :

int const V[6][64] = {
  {1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 1, 1, 5, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9}
};
size_t  taille = sizeof V / sizeof * V;


void setup() {
  Serial.begin (115200);
  Serial.print("Taille du tableau : ");  Serial.println(taille);
  Serial.print("4eme valeur de V  : "); Serial.println(V[5][3]); // 4ème valeur du 6ème tableau
  Serial.print("64eme valeur de V  : "); Serial.println(V[5][63]); // 64ème valeur du 6ème tableau
}

void loop() {}

fdufnews · October 17, 2022, 12:18pm

Pourrais-tu nous expliquer la finalité de la chose car J'ai l'impression que tu essayes de résoudre un problème avec une mauvaise solution.

philippe86220 · October 17, 2022, 12:32pm

J'ai l'impression que vous cherchez à gérer un code.

ludocraft · October 17, 2022, 12:55pm

oui suite a afficheur 8*32 ou vous m'avez bien aider (encor merci :))

j'aurais mes lettre

byte const A[64](avec les nombre binaire dans chaque tableau)
byte const B[64]
byte const C[64]
byte const D[64]
.......
byte const Z[64]

puis j'ai une liste de mot
exemple :
ouvert
bonjour
raclette
azert
que je voudrais metre dasqn un tableau

byte const OUVERT[]
byte const BONJOUR[]
byte const RACLETTE[]
byte const AZERTY[]

suite au bandeau led 8*16
j’essaye de faire exemple avec BONJOUR

BONJOUR[4]
donc
BONJOUR[] seras égale a J
soit imagination que J et egale a 1
sois
BONJOUR[4(J)=1]

ou autre exemple par ce que je sais pas tros comment espliquer

je selectionne toujour BONJOUR[]
B => il met les valeur de B puis passe a la prochaine lettre
O=> il met les valeur de O .......

en gros sa afficheras les lettre a la suite

edit ducoup es t'il possible de faire BONJOUR[]{B,O,N,J,O,U,R}; ??

fdufnews · October 17, 2022, 3:26pm

Au final, tu veux écrire des textes prédéfinis sur une (ou des) matrice(s) de LEDs adressables.
Donc il faut créer

un tableau décrivant les 26 lettres.
une liste de mots à afficher

Tu sembles vouloir travailler sur une matrice 8x8 pour l'affichage.
8 octets sont suffisants pour décrire un caractère, tu n'as pas besoin d'avoir 64 octets comme dans ton exemple.
Par exemple pour coder le V
Tu utilises ça:

const byte V[64] = {1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

alors que tu pourrais faire ça qui occupe 8 fois moins de mémoire

const byte V[8] = {0b11110000,
                   0b00111111,
                   0b00001110,
                   0b11100000,
                   0b00000111,
                   0b00011111,
                   0b11111000,
                   0b00000000};

Au lieu de faire un tableau pour chacune des lettres, il est beaucoup plus simple, du point de vue logiciel, de faire un tableau à 2 dimensions décrivant les lettres.

uint8_t lettres[26][8] ={{ , , , , , , , } , // A
{ , , , , , , , } , // B
{ , , , , , , , } , // C
{ , , , , , , , } , // D
{ , , , , , , , } , // E

{ , , , , , , , } , // X
{ , , , , , , , } , // Y
{ , , , , , , , } , // Z

Pour stocker le texte à afficher pourquoi ne pas utiliser tout simplement des chaines de caractères.

Au lieu de faire

const byte OUVERT[] = {O,U,V,E,R,T};

Pourquoi ne pas faire tout simplement ça

const char OUVERT[] = "OUVERT";
const char RACLETTE[] = "RACLETTE";

Mais avant d'aller plus loin, je te suggère d'aller regarder la librairie Adafruit_NeoMatrix qui pourrait faire ça pour toi

ludocraft · October 17, 2022, 4:41pm

non c'est pas des matrice 8*8 autent pour moi jai oublier de dire mon matériel voici le paneau que jutilise et un arduino mega

sens allumage des led
7cjah3ee

fdufnews · October 17, 2022, 5:41pm

Je parlais de la taille des caractères que tu dessines sur la matrice.
Pour ce qui est de la librairie citée dans mon post précédent, elle s'adapte à differentes formes de matrices. On le décrit lorsqu'on crée l'instance Adafruit_NeoMatrix (voir les exemples).

ludocraft · October 22, 2022, 11:25pm

j'ai pas compris sa sa fait quoi ??

et je préfère essayer en limitent les librairie apres je vais tester aussi avec

ludocraft · October 29, 2022, 6:09pm

bonjour j'essaye de faire un truc mes je sais pas si c'est possible

j'ai différent tableau

ATTENDRE
BONJOUR
RACLETTE
.
.
.

actuellement j'ai sa

 if (ATTENDRE[J][I] == 1) {
        pixels.setPixelColor(I + A, pixels.Color(50, 55, 80));
      }

je voudrais savoir si c'est possible cest possible de que la valeur de if (ici ATTENDRE)
sens devoir faire que des if

j'ai essayer avec enum mes sa prend pas en charge les tableau (ou je ne sais pas comment faire)

jpbbricole · October 29, 2022, 7:50pm

Bonsoir ludocraft
Le contenu de l'enum ne sont que des constantes qui peuvent être des indices de tes tableaux, par exemple.

pour pouvoir comprendre, écris ce que tu ne veux pas, pour pouvoir "tourner"
ça différemment.

Cordialement
jpbbricole

fdufnews · October 29, 2022, 8:08pm

C'est pas super clair.
Que des if qui feraient quoi?

ludocraft · October 29, 2022, 11:22pm

je sais pas tros comment expliquer (comme a chaque fois )

en premier j'ai mes tableau

bool ATTENDRE  [][] {
{1,0,0,1,1,0...}
{0,0,1,1,1,0...}
{1,1,1,0,0,0...}
}
bool BONJOUR [][]{
{...}
{...}
{...}
}
bool RACLETTE []{
...
}
.
.
.

ensuite j'ai

if (Y ==0) {
        if (ATTENDRE[J][I] == 1) {
          pixels.setPixelColor(I + A, pixels.Color(50, 55, 80));
        }
      }
      if (Y ==1) {
        if (BONJOUR[J][I] == 1) {
          pixels.setPixelColor(I + A, pixels.Color(50, 55, 80));
        }
      }
      if (Y  == 3) {
        if (RACLETTE[J][I] == 1) {
          pixels.setPixelColor(I + A, pixels.Color(50, 55, 80));
        }
      }
.
.
.

au départ j'avais voulue faire

enum TEXT{
ATTENDRE,
BONJOUR,
RACLETTE,
.
.
.
}

> en gros metre tous met mots qui vienne du tableau ici
> met d’âpres ce que jai compris on peux pas metre des tableau dans enum.

âpres faire en sorte que 

        if (valeur de TEXT[J][I] == 1) {
          pixels.setPixelColor(I + A, pixels.Color(50, 55, 80));
        }

c'est a dire si si je dit quand dans enum je veux le 2eme sois BONJOUR
que a la place de valeur text sa va me chercher le tableau BONJOUR[][] si je change la valeur de TEXT sa va me chercher le tableau équivalent a la position

je pence pas que cest possible
mes savoir si il y a un équivalent

voir méme si c'est possible avoir un tableau de met tableau

exemple


bool ATTENDRE  [][] {
{1,0,0,1,1,0...}
{0,0,1,1,1,0...}
{1,1,1,0,0,0...}
}
bool BONJOUR [][]{
{...}
{...}
{...}
}
bool RACLETTE []{
...
}
 (puis)

byte TEXT [] {
ATTENDRE
BONJOUR
RACLETTE
}
si j'apelle le 2 eme dans TEXT (BONJOUR) et il va me chercher les valeur de BONJOUR dans son tableau

j’espère que vous aver compris par ce que je sais pas comment expliquer autrement

terwal · October 30, 2022, 9:53am

Un Enum, défini une "liste" d'entier nommé
Dans ton cas la constant ATTENDRE est égale à 0, Bonjour est égale à 1 et raclette à 2.

Il faudrait que tu définisse complètement ton programme.
Si je comprends bien, tu reçois un mots sur le port série ou un truc du genre et en fonction de ce mot, tu lance une animation sur une matrice de led, qui écrit le mot.

Le mieux serait que tu décrive ton programme, sans parler de code, mais en français, on pourrait te proposer des façons de faire.
Je dis ça car j'ai l'impression que tu ne maîtrise pas le language C?

fdufnews · October 30, 2022, 10:06am

Dans un autre fil de discussion, je t'avais proposé de faire un tableau de chaines de caractères pour gérer ça.

text[]={"ATTENDRE", "BONJOUR", "RACLETTE"};

J-M-L · October 30, 2022, 10:45am

il semble que ATTENDRE, BONJOUR, RACLETTE sont des tableaux à 2 dimensions et que Y soit utilisé pour choisir une des tableaux. vous pouvez avoir un tableau qui reprend les 3 tableaux

est-ce que les dimensions sont connues et communes aux 3 tableaux ?

à quoi correspondent ces tableaux ? une représentation des lettres d'un mot ??

fdufnews · October 30, 2022, 2:18pm

C'est la suite de ce fil de discussion

J-M-L · October 30, 2022, 6:51pm

pourquoi c'est un nouveau post ,c'est le même problème...

➜ fusion

surtout que la bonne réponse a déjà été donnée, un tableau qui définit les 26 lettres de l'alphabet et ensuite ils suffit de lire le text et d'aller chercher le caractère qui correspond, pas la peine de dupliquer les lettres en mémoire !

Topic		Replies	Views
Variable texte Français	6	6847	May 6, 2021
création fonction avec appel d'un tableau différent à chaque utilisation Français	8	1992	May 6, 2021
probleme de tableaux Français	1	652	May 6, 2021
Comment faire une fonction avec un tableau en paramètre pour horloge POV Français	6	7872	May 6, 2021
les tableaux Français	21	6573	May 6, 2021

Recupérer un valeur dans un tableau dans un tableau

Related topics