J'aimerais réussir à récupérer le signal d'un grand jack femelle sur un Arduino pour lancer une loop
( une boucle sonore ) sur un autre gros jack femelle pour le mettre sur une enceinte de studio 192hz
donc il aurais une entres le micro ( la guitare ) et une sorti enceinte (enceinte de studio 192hz )
Attention, les arduino SIMULENT une sortie analogique à partir d'une sortie numérique en PWM, dont la fréquence de base est en général entre 500 et 1000 Hz selon l'arduino utilisé
Les sorties sont donc UNIQUEMENT BINAIRES soit à 0 (0 = état bas = 0V ) soit à 1 (1= état haut = 3V ou 5V selon la carte arduino utilisée) , la simulation de la valeur analogique en sortie est faite en sortant un signal carré dont le rapport entre les états hauts et les états bas est directement proportionnel à la valeur analogique désirée qui sera simulée en sortie via la PWM
PS : c'est bien, 192 KILO Hertz ton enceinte en sortie ? ... because un bon vieux téléphone fixe du centenaire dernier c'était déjà 3,2 KILO Hertz, donc déjà 16 fois mieux que 192 Hz 
Au pire, essaye avec un sketch basique de ce style MAIS fais très attention au niveau des impédances et du voltage/courant min/max que tu peux avoir en entrée/sortie car tu risques de cramer direct ton arduino si tu lui demandes bien trop de courant en sortie par exemple
(pour le micro en entrée => pas de problème ça devrait être qqchose de l'ordre du volt, par contre concernant la sortie, c'est limité à quelques dizaines de mA max en sortie sur un arduino , certainement pas des ampères donc il faudra amplifier le signal entre l'arduino et l'enceinte si elle ne fait pas l'amplification elle-même ...)
int microPin = A0; // pin A0 reliée au micro en entrée
int speakerPin = A3; // pin A3 reliée au speaker en sortie
int value = 0;
void setup()
{
pinMode(microPin, INPUT); // pin A0 en entrée (micro)
pinMode(speakerPin, OUTPUT); // pin A3 en sortie (speaker)
}
void loop()
{
value = analogRead(microPin); // read the input pin, cf. the micro
analogWrite(speakerPin, value); // write to the outputPin, cf. the speaker
}Mais avant de commencer à brancher quoi que soit sur ton arduino
=> quelle est l'impédance du micro et l'impédance de l'enceinte de studio afin d'éviter de cramer ton arduino dès son branchement ?
PS : il faudra bien sûr y ajouter ensuite la gestion d'un bouton poussoir afin de pouvoir sélectionner le segment du son provenant du micro que tu veux enregistrer + y gérer un tableau permettant de stocker le signal numérisé en entrée que tu voudras répéter en boucle en sortie
PS2 : je viens de trouver sur le Net que la fréquence max d'acquisition sur un arduino est de l'ordre de 15 Khz, donc bien inférieure au 192 Khz dont tu sembles avoir besoin 
(192 Khz ton enceinte pro à mon avis, pas 192 Hz qui est vraiment une fréquence "ridiculement" bien trop faible pour faire de l'audio, cf. ça va d'un peu moins de 5 Khz pour du super bas de gamme à 192 Khz pour du super haut de gamme en passant par du 44.1 Khz pour un CD par exemples)
PS3 : tu viens de titiller ma curiosité, je ferais quelques tests d'ici la semaine prochaine et te tiens au courant
(perso, ce sera sur un ESP32 donc un "super arduino-like" relativement rapide, cf. tout de même largement plus de 10x plus rapide qu'un classique arduino Uno par exemple => avec un peu/beaucoup/énormément de chance, ça pourrait peut-être fonctionner sur un ESP32 à 192 Khz MAIS sur un Arduino classique style Uno, ce sera facile 10x trop lent, cf. plutôt 19.2 Khz "en descente + le vent dans le dos = optimisé à fond" que les 192 Khz voulus ...)
[ 32 bits @ 240 Mhz pour l' ESP32 vs 8 bits @ 16 Mhz pour le UNO => y'a pas photo niveau vitesse / puissance de calcul, cf. rapport de l'ordre de 15x entre les deux ... ]
Le but serait de créer une sorte d'enregistrement d'un jack entré femelle et un jack sortir vers un enceinte pour réussir à faire une boucle de 1 instrument
Pour commencer, si tu branches directement le micro sur l'enceinte, ça marche ?
Si oui, ton enceinte est amplifiée, cf. est donc obligatoirement relié au secteur
=> là c'est cool, ça devrait marcher sans problème, micro -> arduino -> enceinte
Si non, ton enceinte n'est pas amplifiée (et/ou problème d'impédance)
=> là il faudra donc obligatoirement passer par un amplificateur de puissance sono entre la sortie de l'arduino et l'entrée de l'enceinte, cf. micro -> arduino -> amplificateur -> enceinte
Oui le micro et détecter par le l'enceinte
Mais du coup comment ont peut faire pour enregistrer un micro et le mettre en boucle avec une Arduino c'est faisable ou pas
Tu peux donc essayer de rajouter l'arduino entre le micro et l'enceinte avec le sketch ultra-basique que j'ai donné
(pas mis d'attente ni rien d'autre hormis l'acquisition/restitution du signal dans le loop() : tu verras de suite de quoi est capable, ou pas, ton arduino car il va mouliner à fond, cf. tout le temp dans le loop() )
=> je te préviens, le son sera vraiment crado sur un arduino classique qui ne sait gérer les acquisitions analogique -> numérique que de l'ordre de 15 Khz + avec une précision de 8 bits pour les plus vieux et 16 bits pour les plus récents
(il faut du 96 ou 192 Khz sur 24 bits pour faire de l'acquisition sonore en qualité pro => c'est à des années lumières de ce que les convertisseurs analogique -> numérique = CAN et numérique -> analogique = CNA d'un arduino basique qui sont limités à 8 bits @ 15 Khz, soit 15 fois moins performant en vitesse et d'au moins des centaines de fois en précision ...)
=> si ça marche, il faudra ensuite rajouter un bouton poussoir sur lequel tu poussera le temps d'enregistrer + utilisation d'un tableau pour mémoriser les valeurs acquises durant l'appui sur le bouton poussoir, tableau qui sera ensuite relu cycliquement pour avoir ton effet de boucle
Mais une chose après l'autre, quelle est la qualité du son lorsque tu rajoutes l'arduino entre ton micro et ton enceinte ?
Actuellement il y a des convertisseurs de 15 Hz en 192 hz pense tu que ça marche ou pas
Comment je fais pour relier le gro jack femelle vers le l'arduino
Et quelle sera les commende a utilisé sur l'arduino pour faire qu'il enregistre et qu'on puis le le remettre en boucle
T'arrêtes avec tes Hz ???
=> ce sont des Khz (milliers de vibration par seconde) et non pas de Hz (nombre de vibration par seconde), soit 1 Khz = 1000 Hz, la sensibilité de l'oreille humaine se situe en général entre 20 Hz et 20 Khz
Effectivement la voie parlée va de 75 Hz à 250 Hz selon que l'on soit un homme ou une femme MAIS pour échantillonner correctement le signal , il faut prendre des échantillons bien plus fréquemment, cf. plusieurs acquisitions durant cette période afin de pouvoir au moins distinguer les hauts des bas du signal sinusoïdale durant cette période = théorème de Nyquist, d'au moins plusieurs Khz pour le bas de gamme à presque 200 Khz pour le super haut de gamme
En 24 bits @ 192 Khz, ça fait tout de même 3 octets x 192 000 échantillons par seconde = un peu plus de 512 Ko d'échantillons par seconde, et ce en se limitant en mono => ton arduino risque très vite de se trouver court en mémoire de stockage ...
En 8 bit @ 8 Khz pas de problème par contre, cf. seulement 8 kilo-octets par seconde et donc parfaitement dans les cordes de n'importe quel arduino un tant soit peu digne de ce nom même si très vieux ou hyper bas de gamme
(en gros les Khz par rapport au Hz en acquisition sonore, c'est la même chose qu'entre une voie digitale super hyper méga métallique et un vrai son humain parlé/chanté, cf. avec un timbre qui est différent pour chaque être humain ...)
=> "Par exemple, la gamme de fréquences de l'audition humaine se situe entre 20 Hz et 20 kHz, soit 20 kHz de bande passante. C'est pourquoi la norme du CD est 44,1 kHz (20 kHz × 2 + 10 % d'erreur)." ...
Et si tu veux une explication un peu plus poussée concernant l'importance de la fréquence d'echantillonnage par rapport à celle étudié, je te conseille de lire ce lien
(un peu beaucoup passionnément poussée même l'explication quand on rentre dans les détails MAIS l'adage "une image vaut souvent bien mieux qu'un discours" est ici poussée à son paroxisme avec l'image présentée ...)
Sans avoir une idée du niveau de sortie du micro de la guitare, il va être difficile de dire quoi que ce soit.
Si le niveau de sortie est faible, il faudra amplifier pour que le convertisseur analogique numérique (ADC) de l'ARDUINO puisse travailler dans une plage de mesure correcte, sinon, la précision sera nulle, la distorsion et le bruit seront maximaux.
Pour l'entrée du micro, pas de problème, ce n'est qu'un signal de l'ordre du volt, donc aucun risque
Par contre, pour la sortie, il faudra qu'elle soit obligatoirement amplifiée si tu veux sortir sur une enceinte qui ne fait pas l'amplication par elle-même
(si tu entend direct sur l'enceinte ce que tu dis dans le micro quand tu le branches en direct sur l'enceinte => aucun doute possible, ton enceinte fait bien l'amplification elle-même et ça devrait passer sans problème par ton arduino car signaux en entrée/sortie de seulement l'ordre du volt et d'un chouïa de mA)
"Comment je fais pour relier le gro jack femelle vers le l'arduino ?"
=> bein, tu coupe le câble avant la prise jack, tu dénude les fils et tu en met un sur la masse et l'autre à la patte A0 de l'arduino
Mieux, tu coupes un câble/rallonge avec une prise mâle d'un côté et femelle de l'autre : tu pourras alors brancher sa partie femelle dans la prise mâle de ton micro et relier/souder les fils que tu aura dénudés à l'arduino => ça permet de garder la prise de ton micro intacte afin que tu puisse l'utiliser comme normalement sur un autre appareil quand ça te chante
(par contre, quel fil faut-il relier à la masse et lequel autre brancher à la patte A0 de l'arduino : ça dépend du sens du vent => si tu as un fil noir et un fil rouge = fil noir à la masse de l'arduino et le fil rouge sur sa patte A0 ... sinon essaye avec l'un et si ça ne marche pas avec l'autre = 50% de chance de tomber sur le bon du premier coup vs seulement 50% de chance que ce soit sur l'autre )
Et vice-versa en sortie pour le côté arduino -> enceinte, cf. patte A3 de l'arduino -> prise mâle -> prise femelle de ton enceinte
En schématisant, prise mâle du micro -> côté prise femelle de la rallonge coupée en 2 --> patte A0 de l'arduino puis patte A3 de l'arduino -> côté prise mâle de la rallonge coupée en 2 --> prise femelle de ton enceinte
(ça te permet de pouvoir débrancher/rebrancher à ta guise ton arduino entre le micro et l'enceinte sans rien n'avoir à modifier ni du côté micro, ni du côté enceinte => c'est donc "plus mieux" que de faire du travail de patachon en ayant à toucher en dur au micro ou à l'enceinte ...)
"Et quelle sera les commende a utilisé sur l'arduino pour faire qu'il enregistre et qu'on puis le le remettre en boucle ?"
=> d'abord, le fil vert sur le bouton vert et le fil rouge sur le bouton rouge et on verra ça après
==> m'enfin bon, vu que tu sembles vouloir mettre le chariot avant les boeufs , ça devrait ressembler à quelque chose comme ça ...
(pas testé le code mais l'idée du lecteur/consommateur et la gestion du dépassement de tampon y sont)
int microPin = A0; // pin A0 reliée au micro en entrée
int speakerPin = A3; // pin A3 reliée au speaker en sortie
int buttonPin = A2; // pon A2 relié au boutton (en série avec une résistance de 10K ohms par exemple)
int value = 0;
#define MAX_VALUES 16384
int LoopValues[MAX_VALUES];
int reader = 0;
int writer = 0;
void setup()
{
pinMode(microPin, INPUT); // pin A0 en entrée (micro)
pinMode(speakerPin, OUTPUT); // pin A3 en sortie (speaker)
pinMode(buttonPin, INPUT); // pin A3 en sortie (speaker)
}
void loop()
{
val = analogRead(microPin); // read the input pin, cf. the micro
if ( digitalRead( buttonPin ) == HIGH ) // test si le boutton d'enregistrement est appuyé
{
LoopValues[writer] = value; // enregistre l'échantillon
analogWrite(speakerPin, value); // le ressort sur l'enceinte
if ( writer < MAX_VALUES ) // permet de ne pas dépasser le nombre d'échantillons maximal admis
{
writer++; // un échantillon enregistré de plus
}
else
{
writer = 0; // on réinitialie le pointeur d'enregistrement au début du tableau d'enregistrement
}
}
else
{
analogWrite(speakerPin, LoopValues[reader]; // on ressort un échantillon sur l'enceinte
if ( reader < writer ) // permet de ne lire que les échantillons réellement enregistrés
{
reader++;
}
else
{
reader = 0;
}
}===> pas trop mal comme solution pour à peine 52 lignes de code, je trouve 
(ça n'est pas optimisé du tout car il vaudrait mieux passer par une interruption pour gérer les appuis sur le boutton poussoir afin de minimiser le temp passé par le digitalRead(buttonPin) en boucle ou compresser/compacter les données stockées dans le tableau de mémorisation LoopValues[] afin de minimiser au max la mémoire utilisée pour efficacement gérer ça du côté occupation mémoire et/ou hacker la méthode d'acquisition utilisée par le analogRead(microPin) pour ça puisse aller à bien plus de 15 Khz par exemples => m'enfin bon, là on passe direct à un niveau bien plus "high-level" et ce n'est plus du tout, mais alors plus du tout du tout, la même histoire concernant la simplicité du code et le temps nécessaire à implémenter ça de façon hyper efficace/optimisée ...)
[si, pour l'histoire de la taille du tableau LoopValues[], utiliser des bytes à la place de ints si on travail en 8 bits ou des mots de 16 bits à la place de ints si on travail en 16 bits => les int, c'est pour prémacher le travail au cas où tu voudrais vraiement passer en 24 bits @ 96 ou 192 Khz avec des Convertisseurs Analogique->Numérique et Numériques->Analogique carrément haut de gamme qui te couterons un prix bien supérieur à celui d'un vulgaire arduino => dans ce cas, le MAX_VALUES passerais alors plutôt de 16 384 à qqchose comme 768 000 si tu veux enregistrer ne serait-ce que 2 petites secondes, et là ce n'est plus du tout le même monde, cf. là on parle carrément de DSP haut de gamme et non plus de "vulgaires" arduino fussent-ils méga-boostés à la ESP32 ou autres "arduino-like survitaminés" ...]
Tu déclares un tableau de 16K, or un ARDUINO n'a que 2K de RAM.
Ici, val (non déclarée au passage) peut récupérer une valeur de 0 à 1023.
Et ici tu demandes au µcontrôleur de générer un signal PWM sur le haut-parleur, value peut prendre une valeur entre 0 et 255.
RAPPEL : l'ARDUINO n'a pas de DAC, seulement un ADC.
Ici il manque la parenthèse fermante.
Et il manque également l'accolade de fin de loop().
Compile ton code avant de le publier, c'est un minimum.
"Tu déclares un tableau de 16K, or un ARDUINO n'a que 2K de RAM."
=> c'est bien pour ça que je lui ai dit et répéter de nombreuses fois que perso je passerais plutôt directement via un ESP32 qu'avec un arduino anti-daté hyper basique
"Et ici tu demandes au µcontrôleur de générer un signal PWM sur le haut-parleur, value peut prendre une valeur entre 0 et 255.
RAPPEL : l'ARDUINO n'a pas de DAC, seulement un ADC."
=> donc ESP32 plutôt qu'un arduino une fois de plus ...
"Ici il manque la parenthèse fermante.
Et il manque également l'accolade de fin de loop().
Compile ton code avant de le publier, c'est un minimum."
=> J'AI BIEN SIGNALE AVANT QUE JE N'AVAIS PAS COMPILE LE CODE ET QUE C'ETAIT JUSTE POUR LUI DONNER DES PISTES, cf. les pinaillages ne m'intéresse pas ...
J'espère que tu seras plus en forme pour la suite ... car marikodzo m'a l'air d'être débutant extrême. Donc, sans ce que tu appelles pinaillage (et que moi j'appelle compilation), il ne s'en sortira pas.
Pas de problème pour le côté débutant
=> @marikodzo, quel résultat te donne ce code ?
(il ne fait que ressortir le signal d'entrée du micro relié à la patte A0 de l'arduino sur la patte A3 de l'arduino reliée à ton enceinte, de façon la plus simple/"rapide" possible)
[même pas besoin de faire les branchements, juste me dire si ça se compile bien]
int microPin = A0; // pin A0 reliée au micro en entrée
int speakerPin = A3; // pin A3 reliée au speaker en sortie
int value = 0;
void setup()
{
pinMode(microPin, INPUT); // pin A0 en entrée (micro)
pinMode(speakerPin, OUTPUT); // pin A3 en sortie (speaker)
}
void loop()
{
value = analogRead(microPin); // read the input pin, cf. the micro
analogWrite(speakerPin, value); // write to the outputPin, cf. the speaker
}Encore une fois tu te plantes. AnalogWrite() permet de générer un signal PWM, quelle que soit la plateforme (l'interface ARDUINO doit être respectée quel que soit le CORE utilisé).
Par contre, sur ESP32, dacWrite() fait le job que tu souhaites.