Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

Atelier apprentissage des boucles

temps

Bonjour,
dans le cadre des ateliers du libre pour les enfants ( 10ans à 12 ans), un nouveau support est né.
Le public visé est les enfants de 10 à 12 ans.
Les lieux d'interventions, les bibliothèques, les lieux d'interventions du libre, les écoles.
Les intervenants, les associations du libre ou les entreprises du libre.
Le protocole ouvrir l'attention en créant des instruments de musique personnalisé en manipulant des boucles.
Le support un fichier manipulable composé de boucles (while, for, goto, switch ...) et un fichier manipulable avec dans les 10 valeurs pour chaque note
Le lien de téléchargement du support http://www.letime.net/vocale/lmfab1.tar.gz
La documentation sur le site ubuntu est là http://doc.ubuntu-fr.org/lmfab
Support de cours http://www.letime.net/vocale/U_E_D.html
Manipulations de sons expliqués http://www.letime.net/vocale/lmfab100.tar.gz
Le tutoriel de base des boucles en C et C++ avec avantages et inconvénients est en attente que nous soyons tombé d'accord mais chacun peut réaliser le sien.
Le fichier des boucles se nomme adnforme.cpp, et le fichier des valeurs manipulées par les boucles se nomme fronts.cpp, le tout se compile aves un make en terminal
dépendance qt et sox à installer avant de faire le make
Le principe :
Nous associons nos idées en fonction du langage que nous utilisons. Le langage utilisé actuellement est trop pauvre, nous devons puiser dans nos traditions avant la latinisation pour profiter pleinement de la puissance de l'outil . Le concept de lmfab reprend le concept gaulois raconté sous le chêne qui fait promener un voyageur en différents paysages. Les déplacements du voyageur se manipulent avec le fichier Adnforme.cpp et les 26 paysages (un par note) se créent avec fronts.cpp .

Pour reprendre le conceptualisation gauloise, dans Adnforme.cpp nous pouvons imbriquer les boucles de différentes manière, ou encore créer des suites de boucles pour reproduire des suites de mouvements différents.
Comme pour des paysages qui sont toujours prédéterminés, dans fronts.cpp nous allons manipuler des phénomènes physiques qui sont aussi prédéterminés. Ne possédant pas les termes pour l'exprimer, j'exprime en simplifiant grandement pour dire qu'avec fronts.cpp, on éclaire que ce que l'on veut voire. Tout est présent en permanence, mais nous plaçons le paysage pour que l'objet nous apparaît à l'endroit que nous désirons. En exemple sur la lumière, l'ampoule électrique éclaire la pièce, mais nous ne voyons pas les rayons lumineux, c'est seulement quand il rencontre un objet comme un meuble ou un mur que le phénomène lumière apparaît. De même dans fronts.cpp c'est seulement comment nous plaçons les états d'équilibre que nous allons obtenir les effets désirés.
Il n'y a pas d'algèbre ici, pas de fréquence ici, pas de géométrie ici, juste une gestion de mouvement avec des boucles du for, et une gestion des paysages avec des valeurs numériques représentant les équilibres.

La perception s'ouvre dès les premières manipulations de l'outil.
En Premier dans la perception des effets des boucles :
Changement d'états d'équilibre implique des notions de portes, ensuite rapidement nous nous apercevons que même dans un système à deux valeurs (a et b ) nous n'avons pas 4 cas (ab, aa, bb, ba) mais qu'il peut naître un phénomène de l'association qui va amplifier et accélérer le phénomène qui l'a fait naitre, en d'autres mots, nous pouvons faire apparaître des effets issus de phénomènes « masqués » ou non comptabilisé dans les deux valeurs, ainsi de (a et b) nous avons dans la réalité une multitude de cas possibles et non pas 4 cas, ainsi avec 16 octets nous pouvons créer la Bibliothèque Acoustique Universelle contenant un nombre astronomique de sons. En reprenant les concepts gaulois, en démonstration dans lmfab.

Cordialement

temps

Bonjour,
Forme de l'attelier présenté par Montpel'libre.
Premier niveau.
Le premier niveau apprend les différentes formes de boucle, écriture, application directe... le but est d'obtenir la même chose en l'écrivant du plus grand nombre possible dans un temps limité.
Deuxième niveau.
Le deuxième niveau apprend la manipulation des structures conditionnelles dans les boucles.
En exemple, 'a' -'a' pour avoir l'adresse 0 dans un tableau ou avec while, ou encore l'utilisation du goto pour manipuler les portes acoustiques dans les notes.

Au début de l'attelier chacun indique quel instrument il veut, le formateur l'oriente et laisse l'enfant jouer son role de luthier. A la fin de l'attelier chacun peut repartir avec l'instrument de musique qu'il a créé (son code).

Brunod

temps a écritBonjour,
Forme de l'attelier présenté par Montpel'libre.
Premier niveau.
Le premier niveau apprend les différentes formes de boucle, écriture, application directe... le but est d'obtenir la même chose en l'écrivant du plus grand nombre possible dans un temps limité.
Deuxième niveau.
Le deuxième niveau apprend la manipulation des structures conditionnelles dans les boucles.
En exemple, 'a' -'a' pour avoir l'adresse 0 dans un tableau ou avec while, ou encore l'utilisation du goto pour manipuler les portes acoustiques dans les notes.

Au début de l'attelier chacun indique quel instrument il veut, le formateur l'oriente et laisse l'enfant jouer son role de luthier. A la fin de l'attelier chacun peut repartir avec l'instrument de musique qu'il a créé (son code).

Rem :
1) attelier s'écrit avec 1 t. D'habitude je ne dis rien, mais là, si c'est pour des enfants, le mieux est d'écrire correctement.
2) tu n'as pas un peu mélangé tes notes (de musique) avec l'informatique des fois ? Ou c'est pour le Bolera de Ravel : création de boucles musicales itératives ?

temps

Bonjour,
Merci pour la réponse, mais désolé je ne la comprends pas.
Ici l'objectif est de mettre au point un outil pour les asso et les entreprise du libre.
Cet outil utilise une application ludique (un synthé) pour apprendre à manipuler les boucles, un truc très simple pour les enfants de 10 à 12 ans.
Pas d'autographe ou truc de croyants, juste un peu de fun pour donner envie.
Objectif du fil :
1- Dire que ça existe.
2- Peut-être jeter les bases d'un wiki sur l'approche des boucles en C adaptées à l'application

(limite) 3- éviter tous conflits avec les croyants sous tel ou tel forme d'analyse imposée.

Cordialement

Brunod

En fait, c'est moi qui n'avais pas compris que ton atelier liait boucle informatique et musique. Je pensais que le dernier paragraphe n'avait aucun rapport avec ce qui précédait.

Korak

Bonjour,

temps a écritl'utilisation du goto

N'oublie pas que la commande goto est bannie depuis des années.

temps

Bonjour,
La musique n'est qu'un moyen détourné pour attirer l'attention.
C'est l'intervenant du libre qui dirige le groupe qui va faire ses choix. Le but avoué et recherché est vraiment l'apprentissage des boucles aux enfants.
Effet papillon, l'application est réservé au libre, et par la même fait la promotion du libre et de ses intervenants. Chaque intervenant étant bien sure entièrement libre de diriger ses interventions comme il l'entend. Celle-ci pouvant être ouverte ou rémunérées, l'application en elle-même n'est qu'un outil brut sans inteligence.
Cordialement

temps

Bonjour,
Au sujet du goto, c'est à l'intervenant de faire son choix. Il est fort probable que je ne dirige pas d'activité (raison de dispo) mais si j'en dirigeai, je l'indiquerai pour ceraines formes si demande car sans autre solution à ma connaissance. De plus c'est une fonction utilisée automatiquement, je crois bien dans la gestion des erreurs (je suis pas sure, mais il me semble avoir vu ça en gratant des codes de bases il y a longtemps).

Je pense que même si c'est raisonnable de dire de ne pas l'utiliser, c'est pas raisonnable de ne pas le citer.
Cordialement

Korak

Il y a longtemps (même très longtemps) la commande goto était nécessaire.

Mais elle a été bannie il y a plus ou moins environ 20 ans si pas plus.

Plus besoin de la commande goto, fais appel à une fonction ou à une procédure.

temps

Bonjour,
J'ai ajusté le clavier sur l'azerty de manière à avoir plus de facilité avec les claviers distribués (quoique le bépo m'impressionne).
Utilisation lmfab :

le piano virtuel se compile avec make.
Il est composé de plusieurs fichiers dont trois sont modifiables.

Le fichier clavier.cpp sert à l'affichage, ainsi il est possible de modifier le texte affiché en modifiant les termes entre guillemés dans :

 ("A do oct3", this)

Le fichier fronts.cpp sert à indiquer les valeurs des fronts

et enfin le plus important, celui qui va servir de support de cours, le fichier Adnforme.cpp qui va servir à écrire les différentes formes de boucles

Pour commencer l'explication sur les manipulations de boucles, nous pouvons présenter une forme sans boucle au format abadie.joa, ce qui donne :

          fprintf(fichierjo,  "%c%c",    (char)128, (char)44);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)128, (unsigned char)44);
	
          fprintf(fichierjo,  "%c%c",    (char)125, (char)49);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)125, (unsigned char)49);

la première valeur numérique pour l'amplitude et la deuxième pour la durée ( entre 10 et 240)

Ensuite voici un for et un while pour introduire une première forme de mariage très simple

  int i;

    // Descente laforceb
    for(int laforcehbase = joc.laforceb; laforcehbase > 0; laforcehbase--)
     {
	i = 0;
      while ( i  < 4 )
      {

         if(i%2)
          joc.amplitude[i] += joc.changeamplitude[i];
         else
          joc.amplitude[i] -= joc.changeamplitude[i];

          fprintf(fichierjo,  "%c%c",    (char)joc.amplitude[i], (char)joc.dureefront[i]);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)joc.amplitude[i], (unsigned char)joc.dureefront[i]);

i++;

       }

     }

Il y a encore de nombreuses possibilités d'écriture comme le switch, ou des opérations arithmétique en utilisant les lettres, ... en prévision dans le wiki d'accompagnement qui liste les possibilités connues avec leurs avantages et inconvénients.
Cordialement

temps

Bonjour, en exemple dans l'utilisation des boucles, les limites des forces sur le surf. Dans lmfab39 nous créons deux fois le même son, mais comme nous faisons surfer le premier son su le second, nous n'en entendons qu'un. De plus dans ce piano virtuel, nous réglons la licorne pour que la durée des fronts montant soit supérieur au fronts descendant quand l'amplitude augmente, et l'inverse quand l'amplitude diminue.
Voici la forme de la boucle :

  // génératrice du signal audio

  for(int duree = joc.duree; duree>0; duree--)
   {

    // monte la licorne
    for(int laforcehbase = joc.laforceh; laforcehbase > 0; laforcehbase--)
     {
      for(int i=0; i<4; i++)
       {
        if(i%2)
         joc.amplitude[i] -= joc.changeamplitude[i];
        else
         joc.amplitude[i] += joc.changeamplitude[i];

        if(i%2)
        joc.dureefront[i] -= joc.changedureefront[i];
        else
         joc.dureefront[i] += joc.changedureefront[i];

          fprintf(fichierjo,  "%c%c",    (char)joc.amplitude[i], (char)joc.dureefront[i]);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)joc.amplitude[i], (unsigned char)joc.dureefront[i]);
       }
     }
    // bascule la durer des fronts, les fronts descendant plus courts en monte passe plus long en descente
joc.dureefront[0] -= 11;
joc.dureefront[1] += 11;
joc.dureefront[2] -= 11;
joc.dureefront[3] += 11;

    // Descente laforceh
    for(int laforcehbase = joc.laforceh; laforcehbase > 0; laforcehbase--)
     {
      for(int i=0; i<4; i++)
       {
        if(i%2)
         joc.amplitude[i] += joc.changeamplitude[i];
        else
         joc.amplitude[i] -= joc.changeamplitude[i];

        if(i%2)
        joc.dureefront[i] -= joc.changedureefront[i];
        else
         joc.dureefront[i] += joc.changedureefront[i];

          fprintf(fichierjo,  "%c%c",    (char)joc.amplitude[i], (char)joc.dureefront[i]);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)joc.amplitude[i], (unsigned char)joc.dureefront[i]);

       }
     }
 // retour pour boucle pour quand durer > 1
joc.dureefront[0] += 11;
joc.dureefront[1] -= 11;
joc.dureefront[2] += 11;
joc.dureefront[3] -= 11;
     }

    // Écriture des zones mémoires
    for(int zonememoire = joc.combiendezonememoire; zonememoire > 0 ; zonememoire--)
     {
      fprintf(fichierjo,  "%c%c", 130, 250);
      fprintf(fichierjoa, "%d %d\n", 130, 250);
      fprintf(fichierjo,  "%c%c", 128, 250);
      fprintf(fichierjoa, "%d %d\n", 128, 250);
   }

avec des valeurs de fronts de ce type

  #include "fronts.h"
#include "jo.h"

jo clavier32[26] = {
   { // a touche1
    2, // duree
    7, // laforceh
    21, // laforceb
    {133, 130, 133, 130}, // amplitude
    {86, 83, 80, 77}, // dureefront
    {12, 12, 6, 6}, // varamplitude
    {2, 0, 2, 0}, // vardureefront
    8 // combiendezonememoire
   },

   { // b touche25
    3, // duree
    7, // laforceh
    21, // laforceb
    {133, 130, 133, 130},
    {23, 19, 23, 19},
    {6, 3, 6, 3}, // varamplitude
    {2, 0, 2, 0}, // vardureefront
    0 // combiendezonememoire
   },

Cordialement

temps

Bonjour,
J'ai ajouté la technique particulière de la Calas en manipulant 3 fronts avec des boucles dans lmfab61.
Je commence une prospection de manière à identifier les asso et les entreprises du libre pouvant proposer cet outil. en même temps je vais commencer aussi une recherche auprès des bibliothèques et écoles

et une hébauche de tuto

  Mode d’emplois de l'application lmfab.

L'application lmfab a été conçu pour initier les plus jeunes enfants au concept de programmation informatique en utilisant l'attirance de pouvoir créer avec la facilité des piano virtuels inédits.

Lmfab est composé de plusieurs fichiers en C++ à compiler de manière à créer l'exécutable créant le piano virtuel. L'apprenant est invité à modifier deux fichiers afin de devenir le luthier de son imagination. 
Le premier de ces fichiers est le plus important pour l'initiation informatique, car il contient la ou les boucles informatiques à modifier pour créer la note jouée par le piano virtuel. Il se nomme Adnforme.cpp
Le deuxième fichier qui peut être modifié se nomme fronts.cpp, il contient les valeurs qui vont intervenir dans la boucle en fonction de la touche du piano virtuels.

Une grande liberté est donné à l'organisateur de l’atelier, en premier dans le choix du support par la variété des versions lmfab donné dans le répertoire téléchargé, ensuite sur le choix de la technique pour créer les boucles.

Installation :
L'application se télécharge à l'adresse internet : 
http://www.letime.net/vocale/lmfab1.tar.gz 
elle est destinée à des systèmes d'exploitation linux, contenant pour les dépendances et compiler , qt, sox, gcc, build-essential, fakeroot, checkinstall 

Après modification des deux fichiers, il faut donner les droits et selon ./make en terminal suffit, sinon il faut faire en terminal ./Makefile pour créer le piano virtuel.

Licence :
Lmfab est une sous application de la BAUL ( Bibliothèque Acoustique Universelle sous Linux) qui utilise le format adn un sous format de abadie.jo . Abadie.jo format audio ( .jo ) n'est autorisé que pour une utilisation sous linux
La BAUL contient 256 puissance 16 sons différents avec chaque son qui s’identifie avec 16 octets, ses deux premiers octets (soit 256 * 256 formes) servent à indiquer quel boucle se trouve dans Adnforme, les autres octets servent à manipuler les états d'équilibres

Boucle for
      for(int i=0; i<4; i++)
       {fait ça;}
boucle while
	 int i ;
      while( i<4)
       	{
	fait ça;
	i++ ;
	}
boucle do while
	 int i ;
     	do
       	{
	fait ça;
	i++ ;
	} while(i<4)
 ;
boucle switch
int i ;
switch i
{
case 0 :
	fait ça;
	i++ ;
break ;
case 1 :
	fait ça;
	i++ ;
break ;
…
case 3 :
	fait ça;
	i = 0;
break ;
}
boucle goto
label1 :
	fait ça du 0;
	fait ça du 1;
	fait ça du 2;
	fait ça du 3;
goto label1 ;

Cordialement

temps

Bonjour,
Le projet avance, nous sommes entrain de standardiser des U.E. (Unité d'enseignement) autour de la BAUL

Dans chaque U.E. il est prévue plusieurs matières comme le piano virtuel créé par l'apprenant, ou le séquenceur créé en terminant toujours la formation par la remise d'une clef USB bootable (http://doc.ubuntu-fr.org/multisystem originale avec logo) contenant les créations des apprenants dans la partie persistante.

Afin d"essayer d'aider les formateurs à créer leurs cours, j'ai envoyé quelques termes que je complète petit à petit selon mes disponibilités. C'est ici http://www.letime.net/vocale/U_E_D.html

Si des asso mènent des actions de formation même ne serait-ce que sur le coding, il suffit qu'elle m'indique leur nom et une adresse à contacter pour que je l'indique sur la page des U.E à customiser.

Cordialement

temps

Bonjour,
J'ai commencé à créer une page de wiki sur le site ubuntu-fr,
c'est ici :
http://doc.ubuntu-fr.org/lmfab

Je suis pas très fort en présentation, si quelqu'un a une idée pour améliorer le wiki est là.
Cordialement

temps

Bonjour,

J'ai un peu avancé dans la description, la forme de la boucle en C est représenté par un gaulois qui se déplace, et les plateaux d'équilibres par des paysages prédéterminé.
La description est ici http://www.letime.net/vocale/lmfab100.html
Le téléchargement est là http://www.letime.net/vocale/lmfab100.tar.gz
et pour écouter les notes jouées à la suite c'est ici https://commons.wikimedia.org/wiki/File:Lmfab100.ogg

Cordialement

temps

Bonjour,
Dans lmfab106, j'explique comment régler la fonction modulo en fonction de la durée totale du son joué.

/******************************fin*partie*fixe************/
// ici commence la zone de travail pour l'apprenant
//Nous allons utiliser les boucles du for en langage c pour produire les différents sons.
//Imaginer un gaulois qui marche, il va rencontrer plusieurs paysages prédéterminés.
//pour les sons, il en est de même, nous allons rencontrer plusieurs plateaux en équilibre 
//selon le chemin emprunté et les valeurs placées dans les plateaux d'équilibre.
//lmfab104 est un chemin de huit fronts qui augmente l'amplitude, fait un plateau modulo 5, puis diminue l'amplitude.


// Etape 1
//Nous indiquons ici combien de fois nous allons augmenter l'amplitude
    for(int laforcehbase = joc.laforceh; laforcehbase > 0; laforcehbase--)
     {
      for(int i=0; i<8; i++)
       {
//ici nous appliquons le changement de la valeur d'amplitude du front tous les 8 fronts
        if(i%2)
         joc.amplitude[i] -= joc.changeamplitude[i];
        else
         joc.amplitude[i] += joc.changeamplitude[i];

//nous diminuons la durée des fronts
//         joc.dureefront[i] -= joc.changedureefront[i];
// création d'une décurité afin que la durée ne soit jamais inférieure à 6
//	if (joc.dureefront[i]<6)
//	joc.dureefront[i] = 6;

//les 2 lignes suivantes écrivent les fichiers audio, le premier en binaire, l'autre en ascii
          fprintf(fichierjo,  "%c%c",    (char)joc.amplitude[i], (char)joc.dureefront[i]);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)joc.amplitude[i], (unsigned char)joc.dureefront[i]);
       }
     }

// Etape 2

// la nous créons un plateau de 8 front sans variation d'amplitude


int basculeDe1 = joc.nbtremolo * 8;
int basculeDe2 = basculeDe1 - 1;
int basculeDe3 = basculeDe1 * 2 - 1;
int basculeDe5 = 0;

    for(int laforcehbase = joc.laforceb; laforcehbase > 0; laforcehbase--)
     {



      for(int i=0; i<8; i++)
       {

//nous créons ici un trémolo de 5, comme c-est sur 8 fronts une bascule à 5*8 = 40
//avec une vinaigrette l'amplitude et la durée varient à l'inverse
if(basculeDe5<basculeDe1)
{
joc.dureefront[i] += joc.changedureefront[i];
joc.amplitude[i] -= joc.changeamplitudep[i];
}

if(basculeDe5>basculeDe2)
{
joc.dureefront[i] -= joc.changedureefront[i];
joc.amplitude[i] += joc.changeamplitudep[i];
}
basculeDe5++;
if(basculeDe5>basculeDe3)
basculeDe5 = 0;


//les 2 lignes suivantes écrivent les fichiers audio, le premier en binaire, l'autre en ascii
          fprintf(fichierjo,  "%c%c",    (char)joc.amplitude[i], (char)joc.dureefront[i]);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)joc.amplitude[i], (unsigned char)joc.dureefront[i]);
       }
     }

// Etape 3

    // la nous reprenons la premiere forme en changeant le sens pour revenir aux valeurs de départ

    for(int laforcehbase = joc.laforceh; laforcehbase > 0; laforcehbase--)
     {
      for(int i=0; i<8; i++)
       {
//ici nous appliquons le changement de la valeur d'amplitude du front tous les 8 fronts
        if(i%2)
         joc.amplitude[i] += joc.changeamplitude[i];
        else
         joc.amplitude[i] -= joc.changeamplitude[i];

         joc.dureefront[i] += joc.changedureefront[i];
// création d'une décurité afin que la durée ne soit jamais supérieur à 240
	if (joc.dureefront[i]>240)
	joc.dureefront[i] = 240;

//les 2 lignes suivantes écrivent les fichiers audio, le premier en binaire, l'autre en ascii
          fprintf(fichierjo,  "%c%c",    (char)joc.amplitude[i], (char)joc.dureefront[i]);
          fprintf(fichierjoa, "%d %d\n", (unsigned char)joc.amplitude[i], (unsigned char)joc.dureefront[i]);
       }
     }

// fin de la zone de travail de l'apprenant
/************************************************************************/

Pour augmenter la force du modulo nous pouvons écrire les états d'équilibres sous cette forme dabs fronts.cpp

#include "fronts.h"
#include "jo.h"

jo clavier32[26] = {
   { // a touche1
    7, // laforceh
    21, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {56, 57, 58, 59, 60, 61, 62, 63}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },

   { // b touche25
    7, // laforceh
    68, // laforceb
    3, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {8, 9, 10, 11, 12, 13, 14, 15}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },



   { // c touche23
    7, // laforceh
    65, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {12, 13, 14, 15, 16, 17, 18, 19}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },

   { // d touche13
    7, // laforceh
    44, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {32, 33, 34, 35, 36, 37, 38, 39}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // e touche3
    7, // laforceh
    24, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {52, 53, 54, 55, 56, 57, 58, 59}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront 
   },

   { // f touche14
    7, // laforceh
    48, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {30, 31, 32, 33, 34, 35, 36, 37}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // g touche15
    7, // laforceh
    51, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {28, 29, 30, 31, 32, 33, 34, 35}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // h touche16
    7, // laforceh
    55, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {26, 27, 28, 29, 30, 31, 32, 33}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // i touche8
    7, // laforceh
    33, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {42, 43, 44, 45, 46, 47, 48, 49}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // j touche17
    7, // laforceh
    56, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {24, 25, 26, 27, 28, 29, 30, 31}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // k touche18
    7, // laforceh
    58, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {22, 23, 24, 25, 26, 27, 28, 29}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // l touche19
    7, // laforceh
    59, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {20, 21, 22, 23, 24, 25, 26, 27}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // m touche20
    7, // laforceh
    60, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {18, 19, 20, 21, 22, 23, 24, 25}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },

   { // n touche26
    7, // laforceh
    70, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {6, 7, 8, 9, 10, 11, 12, 13}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },



   { // o touche9
    7, // laforceh
    35, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {40, 41, 42, 43, 44, 45, 46, 47}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },



   { // p touche10
    7, // laforceh
    37, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {38, 39, 40, 41, 42, 43, 44, 45}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // q touche11
    7, // laforceh
    39, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {36, 37, 38, 39, 40, 41, 42, 43}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // r touche4
    7, // laforceh
    26, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {50, 51, 52, 53, 54, 55, 56, 57}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront 
   },

   { // s touche12
    7, // laforceh
    42, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {34, 35, 36, 37, 38, 39, 40, 41}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // t touche5
    7, // laforceh
    28, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {48, 49, 50, 51, 52, 53, 54, 55}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront 
   },


   { // u touche7    
    7, // laforceh
    32, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {44, 45, 46, 47, 48, 49, 50, 51}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // v touche24
    7, // laforceh
    66, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {10, 11, 12, 13, 14, 15, 16, 17}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // w touche21
    7, // laforceh
    62, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {16, 17, 18, 19, 20, 21, 22, 23}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },

   { // x touche22
    7, // laforceh
    63, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {14, 15, 16, 17, 18, 19, 20, 21}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront
   },


   { // y touche6    
    7, // laforceh
    30, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {46, 47, 48, 49, 50, 51, 52, 53}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront 
   },


   { // z touche2   
    7, // laforceh
    22, // laforceb
    5, // nombre de tremolo
    {129, 128, 129, 128, 129, 128, 129, 128}, // amplitude
    {54, 55, 56, 57, 58, 59, 60, 61}, // dureefront
    {16, 16 , 8, 8 , 4, 4, 2, 2}, // varamplitude
    {2, 2 , 4, 4, 8, 8, 16, 16}, // varamplitudeplateau
    {1, 1, 1, 1, 1, 1, 1, 1} // vardureefront 
   }
};

jo *mesjo = clavier32;

Sur ce code il ne reste qu'à ajuster les valeurs de laforceb pour que les notes aient toutes la même durée, j'hésite à faire un code pour que cela s'ajuste automatiquement (simple calcul de la somme des durée des 8 fonts placé proportionnelement entre chaque note), ou laisser l'apprenant créer la durer totale de chaque note comme il l'entend.

Cordialement

[supprimé]

j'ai lu dans la présentation de ton projet, qu'il était à vocation pédagogique, pour des ados d'une dizaine d'années. Je me demande comment des gamins peuvent s'initier au C avec un code pareil ?! Je trouve que le python est plus approprié.

temps

Bonjour,

Mes expériences font que je peux dire qu'avec un bon pédagogue (ref anim de Montpel'libre à la Bibliothèque Emile Zola), on apprends très rapidement le C aux très très jeune enfants (quelques heures). La motivation doit être là, elle fut sur un jeu de plate-formes, en test elle est au moins équivalente en créant des instruments musicaux.

En fait je pense que ce qui compte le plus, c'est le formateur et son contact humain, ainsi si le formateur se sent plus à l'aise avec du python, il doit utiliser du python. (un travail de préparation en plus)
L'objectif est d'apporter un savoir aux plus jeunes afin qu'ils puissent profiter de richesses, le reste ne sont que des moyens et en aucun cas, ils ne doivent devenir plus important que la cause initiale.

En regardant bien la technique préconisé pour les plus jeunes, on s’aperçoit bien que ceux-ci ne manipulent que 2 zones très restreinte, 2 zones ciblées sur les boucles. Une zone dans une structure, très claire, et une zone contenant les formes d'associations de boucles qu'ils imaginent. C'est comme jouer avec une mini moto pour enfant, ils n'ont pas besoin de connaître les forces de frottement, d'attraction, les énergies cinétiques, les réglages des calculateurs embarqués, les principes du moteur à explosion, si l’entraînement à été fabriqué en chine, en amérique ou en europe ... Si une pièce de la mini moto ne plaît pas, libre au formateur de la changer.

Pour résumer mes expériences avec les plus jeunes, je peux dire qu'il ne faut jamais croire avec eux, ou encore pire présenter des solutions absolues, là ça ne passe pas, au mieux on peut les traumatiser et les abrutir de force (en faire des gogols).
Avec les plus jeunes, il faut rester humble et proposer des solutions avec des avantages et des inconvénients que nous pensons pouvoir présenter, en leur ouvrant la porte que peut-être ils peuvent trouver mieux. Il ne faut pas chercher à tout expliquer, il faut juste présenter une technique de manipulation dans une zone déterminée. Ainsi peut importe le support (langage C, python), la curiosité étant un de leurs caractères, le reste se fait tout seul.

Cordialement