Séquence euclidienne simple

Bonjour !

Alors voilà, depuis quelques jours je suis confronté a un petit soucis qui n'est pas du tout facilité par mes lacunes en maths =(

Je souhaiterais faire un petit module simple de séquence euclidienne, je m'explique :

  • 4 sorties (jack 3.5mm qui sort du +5V pendant leur activation),
  • 1 potentiomètres pour la longueur de la séquence (de 1 à 8 pas),
  • 1 potentiomètre par sortie (sélection du nombre de "hits" par séquence).
  • 1 switch d'activation pour une fonction "evolve" qui, à chaque début de nouvelle séquence, randomise le nombre de "hits" par sortie
  • 1 potentiomètre de sélection du nombre de séquences avant activation de la fonction "evolve".

Voilà pour ce qui est du principe du module, grosso modo.
Pour ce qui est code de la Chose ça ne me pose pas de soucis, là ou je bloque c'est sur le principe de la division euclidienne en elle-même...

Ma question :

  • Avez-vous un truc, une explication simple pour que je puisse configurer une division euclidienne par voie ? Il ne me resterais plus qu'à en faire autant que de sorties disponibles.

Merci d'avance, je rame grave...

Peut-être que c'est moi qui suis bouché ( ce qui est fort possible ) mais je n'ai absolument rien compris.

J'ai vérifié le terme "division euclidiene" et wikipédia me donne :

En mathématiques, et plus précisément en arithmétique, la division euclidienne ou division entière est une opération qui, à deux entiers naturels appelés dividende et diviseur, associe deux autres entiers appelés quotient et reste.

Donc 35 div 4 donne : quotient = 8 et reste = 3 parce que 35 = 8*4 + 3
Cerise sur le gâteau ton texte est truffé d'anglicismes que je connais mais je ne suis absolument pas certain qu'on leur donne la même signification.
Actuellement je ne vois que des "initiés" qui peuvent être en mesure de te répondre .
Mais peut être que si tu expliques clairement ce que tes modules doivent faire .................

Hum, oui pardon... j'avoue qu'en me relisant je n'ai rien compris non plus, ahem...

En essayant de faire plus clair, ce que j'essaye de faire c'est un "générateur de rythme euclidien" de 4 voix au même titre que, par exemple, ça :
http://www.axelrigaud.com/euclide/

Mais depuis tout à l'heure ou j'ai ouvert ce sujet j'ai avancé, mais ce qui me frustre c'est de ne pas trop comprendre ce que je fais.
En attendant, voici mon code (de gros lourdeau, ahem...) tel qu'il est pour le moment :

#define trig1 2
#define trig2 3
#define trig3 4

int compteur = 0;
int offset = 0;
int longueur = 4;

int hitsOut1;
int hitsOut2;
int hitsOut3;

int euclidOut1;
int euclidOut2;
int euclidOut3;

void setup()
{
  pinMode(trig1, OUTPUT);
  pinMode(trig2, OUTPUT);
  pinMode(trig3, OUTPUT);
}

void loop()
{
  longueur = analogRead(3) / 128;
  offset = analogRead(2) / 250;
  hitsOut1 = analogRead(0) / 250;
  hitsOut2 = analogRead(5) / 250;
  hitsOut3 = (hitsOut1 + hitsOut2) / 2;

  compteur = compteur + 1;

  //-------------------------------------------------------- mon calcul euclidien, 1 par voix :
  euclidOut1 = compteur + offset * hitsOut1 % longueur;
  euclidOut2 = compteur + offset * hitsOut2 % longueur;
  euclidOut3 = compteur + offset * hitsOut3 % longueur;
  
//-------------------------------------------------------- l'application sur les sorties :
  if(euclidOut1 > hitsOut1)
  {
    ledBlink(trig2);
  }
  
  if(euclidOut2 > hitsOut2)
  {
    ledBlink(trig3);
  }
  if(euclidOut3 > hitsOut3)
  {
    ledBlink(trig1);
  }
  
  ledBlink(trig1);
  delay(500);
  
  if (compteur == 4)
  {
    compteur = 0;
  }
}
//---------------------------------------------------------------------------
void ledBlink(int pin)
{
  digitalWrite(pin, HIGH);
  delay(50);
  digitalWrite(pin, LOW);
}

Bonjour,

Tu as un moyen ultra simple de faire la même chose que sur le site web en lien :

  1. tu fais un tableau à deux dimensions. Une dimension pour le nombre de "lignes", une autre pour N et K (je reprend les termes du site).

  2. dans loop() tu ajoutes un delay() calculé pour donner le bon tempo entre chaque "colonne".
    rappel : tdelay = BPM / 60 * 1000

  3. tu gardes un compteur qui s'incrémente à chaque passage de loop() de 0 à NL-1 (NL = nombre de "lignes"). Quand il atteint NL tu repart à 0 (avant de faire la suite).

  4. à chaque tour de loop(), tu traites chaque "ligne" en fonction de la valeur courante du compteur et de n/k

Rappel :
quotient = a / b (division entière)
reste = a % b (modulo)

Oh ! Ca c’est astucieux ! Merci beaucoup, je vais aller jeter un oeil aux tableaux en 2 dimensions (une matrice il me semble), je n’ai pas encore bossé avec ça…

Sinon grosso modo j’ai réussi à faire un truc qui tiens la route mais je trouve que mon bordel est un peu lourd, le voilà :

/*
#define NOMBRE_DE_VOIX 6
#define boutonRandom 12
#define switchEvolve 11
#define ledBPM 13
#define potarEvolveCycle 0 //analog
#define potarLongueurSequence 1 //analog
#define potarBPM 2 //analog
//---------------------------------------------------------------- déclaration variables et valeurs par défaut
int compteur = 0;
int longueurSequence = 4;
int BPM = 120;
int triggers[NOMBRE_DE_VOIX];
int longueurCycle[NOMBRE_DE_VOIX];
int hitsParCycle[NOMBRE_DE_VOIX];
boolean etatBoutonRandom = true;

//======================================================
//==================== SETUP ===========================
//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

void setup()
{
  for (int i = 0; i < NOMBRE_DE_VOIX; i++)
  {
    triggers[i] = i + 2;
    pinMode(triggers[i], OUTPUT);
  }
  pinMode(ledBPM, OUTPUT);
  pinMode(boutonRandom, INPUT_PULLUP);
  pinMode(switchEvolve, INPUT);
}

//======================================================
//===================== LOOP ===========================
//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

void loop()
{
  
//---------------------------------------------------------------- récupération valeurs  

  longueurSequence = analogRead(potarLongueurSequence) / 32 + 1;
  BPM = analogRead(potarBPM) + 10;
  ledBlink(5); // BPM
  
//---------------------------------------------------------------- application du rythme

  for (int i = 0; i < NOMBRE_DE_VOIX; i++)
  {
    compteur = compteur + 1;
    etatBoutonRandom = digitalRead(boutonRandom);
    if(digitalRead(boutonRandom) == false)
    {
      longueurCycle[i] = random(longueurSequence);
      hitsParCycle[i] = random(longueurSequence);
    }
    vox(triggers[i], longueurCycle[i], hitsParCycle[i]);
    if (compteur == longueurSequence)
    {
      compteur = 0;
    }
  }
  delay(BPM);
}

//======================================================
//================== FONCTIONS =========================
//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV

void vox(int sortie, int longueurCycle, int nombreHits)
{
  int resultat = compteur * nombreHits % longueurSequence;
  if (resultat < nombreHits)
  {
    ledBlink(sortie);
  }
}

void ledBlink(int pin)
{
  digitalWrite(pin, HIGH);
  delay(10);
  digitalWrite(pin, LOW);
}