API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 29th, 2020
126
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 91.67 KB | None | 0 0
raw download clone embed print report
  1. //**************************************************************************************************************************************************************************
  2. //************************************ Vu-Mètre Entrées Audio Stéréo / Entrée Audio Microphone V2.0 64x32 RGB Matrix - Carte Mega (com15) **********************************
  3. //**************************************************************************************************************************************************************************
  4. #include <Adafruit_GFX.h> // Librairie pour la Gestion Graphique
  5. #include <RGBmatrixPanel.h> // Librairie pour la Gestion Graphique Spécifique à la Matrice Led RGB 64x32
  6.  
  7. #define audioInLeft A6 // Broche entrée audio casque gauche
  8. #define audioInRight A7 // Broche entrée audio casque doite
  9. #define BrocheBPMode 5 // Broche du bouton poussoir Mode
  10. #define BrochePotarNiveau A8 // Broche du curseur du potentiomètre niveau
  11. #define BrocheMicrophone A9 // Broche de l'entrée micophone
  12. #define BrocheBuzzer 4 // Broche du Buzzer 5v
  13. #define BrocheLedVerteModeMicrophone 6 // Broche de la led verte du mode microphone
  14. #define BrocheBPModeMicro 7 // Broche du bouton poussoir pour le Mode microphone ou entrée audio
  15.  
  16. const int OE = 9; // Broches de la Matrice Led RGB 64x32
  17. const int LAT = 10;
  18. const int CLK = 11;
  19. const int A = A0;
  20. const int B = A1;
  21. const int C = A2;
  22. const int D = A3;
  23.  
  24. int val = 0; // Valeur lue sur les entrées audio casque en mode entrées audio
  25. int valEntreeMax = 0; // Valeur étalonnée de la lecture du potentiomètre niveau en mode entrées audio (0 à 255)
  26. int LastvalEntreeMax = -1; // Dernière valeur étalonnée de la lecture du potentiomètre niveau (-1, 0 à 255)
  27. int LastvalEntreeMax1 = -1; // Dernière valeur 1 étalonnée de la lecture du potentiomètre niveau (-1, 0 à 255)
  28. int LastvalEntreeMax2 = -1; // Dernière valeur 2 étalonnée de la lecture du potentiomètre niveau (-1, 0 à 255)
  29. int valEntreeMax1 = 0; // Valeur étalonnée de la lecture du potentiomètre niveau en mode microphone (0 à 255)
  30. int LastvalEntreeMax11 = -1; // Dernière valeur 1 étalonnée de la lecture du potentiomètre niveau (-1, 0 à 255)
  31. int LastvalEntreeMax12 = -1; // Dernière valeur 2 étalonnée de la lecture du potentiomètre niveau (-1, 0 à 255)
  32.  
  33. int ModeCourant = 0; // Variable contenant le mode courant
  34. int lastModeCourant = -1; // Variable contenant le dernier mode courant
  35.  
  36. boolean LastetatBPMode = HIGH; // Dernier état courant de l'entrée du bouton poussoir BPMode
  37. boolean etatBPMode = HIGH; // Etat courant de l'entrée du bouton poussoir BPMode
  38.  
  39. int Amplitude [] = {0, 0}; // Tableau d'amplitudes mesurées sur l'entrée audio right et left
  40. int ylastAmplitude [] = {0, 0}; // Tableau des dernières valeurs du tableau d'amplitudes mesurées sur l'entrée audio right et left
  41. int yAmplitude [] = {0, 0}; // Tableau des ordonnées courantes d'une bande en fonction de l'amplitude
  42. int yPic [] = {0, 0}; // Tableau des ordonnées des Pics de chaque bande
  43. int yHautBande [] = {0, 0}; // Tableau des ordonnées du sommet de chaque bande selon le Mode d'affichage
  44. unsigned long t1tempoBande [] = {0, 0}; // Tableau des temporisations pour le delai avant la descente de la Bande
  45. unsigned long t1tempoPic [] = {0, 0}; // Tableau des temporisations pour le delai avant la descente du Pic
  46.  
  47. int TableauAmp [] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // Tableau des amplitudes de gauche et de droite pour le mode défilement
  48. int TableauAmpLeft [] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // Tableau des amplitudes de gauche pour les modes défilement
  49. int TableauAmpRight [] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // Tableau des amplitudes de droite pour les modes défilement
  50. int hue = 0; // Variable contenant la couleur suivant le mode sélectionné
  51.  
  52. const int sampleWindow = 25; // Sample window width in mS (50 mS = 20Hz)
  53. unsigned int sample;
  54. unsigned int peakToPeak = 0; // peak-to-peak level
  55.  
  56. boolean ModeMicrophone = 0;
  57. boolean etatBPModeMicro = HIGH;
  58. boolean LastetatBPModeMicro = HIGH;
  59.  
  60. RGBmatrixPanel matrix(A, B, C, D, CLK, LAT, OE, false, 64); // Crée l'objet "matrix"
  61.  
  62. void setup()
  63. {
  64. Serial.begin(9600); // Démarre la communication avec la console
  65.  
  66. pinMode(BrocheBuzzer, OUTPUT); // Configure les broches en sorties
  67. pinMode(BrocheLedVerteModeMicrophone, OUTPUT);
  68.  
  69. pinMode(audioInLeft, INPUT); // Configure les broches en entrées
  70. pinMode(audioInRight, INPUT);
  71. pinMode(BrocheBPMode, INPUT_PULLUP);
  72. pinMode(BrocheBPModeMicro, INPUT_PULLUP);
  73.  
  74. matrix.begin(); // Initialise l'objet "matrix"
  75. matrix.setTextWrap(false); // Désactive le saut de ligne de la Matrice Led
  76. matrix.setRotation(0); // Définit l'orientation de la matrice (Origine en bas à gauche)
  77. matrix.setTextSize(1); // Définit la taille du texte
  78. matrix.fillScreen(0); // Efface la Matrice Led
  79.  
  80. Buzzer(20, 0, 1); // Active le buzzer 20ms
  81.  
  82. //**************************************************************************************************************************************************************************
  83. }
  84.  
  85. void loop()
  86. {
  87. //**************************************************************************************************************************************************************************
  88. etatBPModeMicro = digitalRead(BrocheBPModeMicro); // ******************************************** // Lit le bouton poussoir "BPModeMicro"
  89. if (LastetatBPModeMicro != etatBPModeMicro) // ************************************************** // Si l'état du bouton poussoir "BPModeMicro" a changé
  90. {
  91. if (etatBPModeMicro == LOW && LastetatBPModeMicro == HIGH) // +++++++++++++++++++++++++++++++++ // Si front montant sur le bouton poussoir "BPModeMicro"
  92. {
  93. Buzzer(20, 0, 1); // Active le buzzer 20ms
  94. ModeMicrophone = !ModeMicrophone; // Change le Mode Entrées Audio Stéréo <=> Entrée Microphone
  95. if (ModeMicrophone) {digitalWrite(BrocheLedVerteModeMicrophone,HIGH);} // Allume la led témoin mode microphone
  96. else {digitalWrite(BrocheLedVerteModeMicrophone,LOW);}
  97. LastetatBPModeMicro = etatBPModeMicro; // Mémorise le dernier état de "etatBPModeMicro;"
  98. }
  99. else {LastetatBPModeMicro = HIGH;} // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si front descendant sur le bouton poussoir "BPModeMicro"
  100. }
  101.  
  102. //**************************************************************************************************************************************************************************
  103. if (ModeMicrophone == true) // ****************************************************************** // Si le mode microphone est activé
  104. {
  105. unsigned long startMillis = millis(); // Temporisation de lecture de la sortie microphone
  106. unsigned int signalMax = 0;
  107. unsigned int signalMin = 1024;
  108.  
  109. while (millis() - startMillis < sampleWindow) // ********************************************** // Lecture de la sortie microphone toutes les 50ms
  110. {
  111. sample = analogRead(BrocheMicrophone); // Lit l'entrée du micophone
  112. if (sample < 1024) // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Filtre les données erronées
  113. {
  114. if (sample > signalMax) // ---------------------------------------------------------------- // Mémorise le niveau haut
  115. {
  116. signalMax = sample;
  117. }
  118. else if (sample < signalMin) // ----------------------------------------------------------- // Mémorise le niveau bas
  119. {
  120. signalMin = sample;
  121. }
  122. }
  123. }
  124. peakToPeak = signalMax - signalMin; // Effectue max - min = crête à crête amplitude
  125. //double volts = (peakToPeak * 5.0) / 1024; // Convertit en volts
  126. //Serial.println(peakToPeak); // Débug
  127.  
  128. int NiveauEntree = analogRead(BrochePotarNiveau); // ****************************************** // Lit le potentiomètre de niveau d'entrées
  129. //Serial.println(NiveauEntree);
  130. valEntreeMax1 = map(NiveauEntree, 0, 1023, 1000, 0); // Convertit la valeur lue sur le potentiomètre (0 à 1023) en une variable "valEntreeMax" (0 à 255)
  131.  
  132. // Emet un bip au passage du potentiomètre à 0 (à gauche) et à 255 (à droite) et à 150 (par défaut)
  133. if (valEntreeMax1 == 0 && LastvalEntreeMax11 != valEntreeMax1) {Buzzer(5, 0, 1); LastvalEntreeMax11 = valEntreeMax1;}
  134. else if (valEntreeMax1 > 5) {LastvalEntreeMax11 = -1;}
  135.  
  136. if (valEntreeMax1 == 1000 && LastvalEntreeMax12 != valEntreeMax1) {Buzzer(5, 0, 1); LastvalEntreeMax12 = valEntreeMax1;}
  137. else if (valEntreeMax1 < 995) {LastvalEntreeMax12 = -1;}
  138.  
  139. if (valEntreeMax1 == 500 && LastvalEntreeMax1 != valEntreeMax1) {Buzzer(5, 0, 1); LastvalEntreeMax1 = valEntreeMax1;}
  140. else if (valEntreeMax1 < 495 || valEntreeMax1 > 505) {LastvalEntreeMax1 = -1;}
  141.  
  142. //Serial.print(LastvalEntreeMax1); Serial.print(' '); Serial.println(valEntreeMax1); // Débug
  143. }
  144.  
  145. //**************************************************************************************************************************************************************************
  146. else if (ModeMicrophone == false) // ************************************************************ // Si le mode entrées audio stéréo est activé
  147. {
  148. int NiveauEntree = analogRead(BrochePotarNiveau); // ++++++++++++++++++++++++++++++++++++++++++ // Lit le potentiomètre de niveau d'entrées
  149. //Serial.println(NiveauEntree);
  150. valEntreeMax = map(NiveauEntree, 0, 1023, 255, 0); // Convertit la valeur lue sur le potentiomètre (0 à 1023) en une variable "valEntreeMax" (0 à 255)
  151.  
  152. // Emet un bip au passage du potentiomètre à 0 (à gauche) et à 255 (à droite) et à 150 (par défaut)
  153. if (valEntreeMax == 0 && LastvalEntreeMax1 != valEntreeMax) {Buzzer(5, 0, 1); LastvalEntreeMax1 = valEntreeMax;}
  154. else if (valEntreeMax > 5) {LastvalEntreeMax1 = -1;}
  155.  
  156. if (valEntreeMax == 255 && LastvalEntreeMax2 != valEntreeMax) {Buzzer(5, 0, 1); LastvalEntreeMax2 = valEntreeMax;}
  157. else if (valEntreeMax < 254) {LastvalEntreeMax2 = -1;}
  158.  
  159. if (valEntreeMax == 150 && LastvalEntreeMax != valEntreeMax) {Buzzer(5, 0, 1); LastvalEntreeMax = valEntreeMax;}
  160. else if (valEntreeMax < 149 || valEntreeMax > 151) {LastvalEntreeMax = -1;}
  161.  
  162. //Serial.print(LastvalEntreeMax); Serial.print(' '); Serial.println(valEntreeMax); // Débug
  163. }
  164.  
  165. //**************************************************************************************************************************************************************************
  166. etatBPMode = digitalRead(BrocheBPMode); // Lit l'état de BPMode
  167. if (etatBPMode != LastetatBPMode) // ************************************************************ // Si l'état de "BPMode" a changé
  168. {
  169. if (etatBPMode == LOW && LastetatBPMode == HIGH) // +++++++++++++++++++++++++++++++++++++++++++ // Si pression sur BPMode
  170. {
  171. ModeCourant++; // Change de mode
  172. if (ModeCourant > 14) {ModeCourant = 0;} // Borne le mode
  173. LastetatBPMode = etatBPMode; // Mémorise le dernier mode
  174. }
  175. else {LastetatBPMode = HIGH;} // Mémorise le dernier état du bouton poussoir "BPMode"
  176. }
  177.  
  178. //**************************************************************************************************************************************************************************
  179. if (ModeCourant == 0) // ************************************************************************ // Mode 0 sélectionné
  180. {
  181. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  182. {
  183. matrix.fillScreen(0); // Efface la matrice led
  184. FonctionAfficheFond();
  185. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  186. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  187. }
  188. FonctionMode0(); // Appelle la fonction d'affichage du mode 0
  189. }
  190. else if (ModeCourant == 1) // ******************************************************************* // Mode 1 sélectionné
  191. {
  192. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  193. {
  194. matrix.fillScreen(0); // Efface la matrice led
  195. FonctionAfficheFond();
  196. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  197. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  198. }
  199. FonctionMode1(); // Appelle la fonction d'affichage du mode 1
  200. }
  201. else if (ModeCourant == 2) // ******************************************************************* // Mode 2 sélectionné
  202. {
  203. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  204. {
  205. matrix.fillScreen(0); // Efface la matrice led
  206. FonctionAfficheFond();
  207. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  208. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  209. }
  210. FonctionMode2(); // Appelle la fonction d'affichage du mode 2
  211. }
  212. else if (ModeCourant == 3) // ******************************************************************* // Mode 3 sélectionné
  213. {
  214. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  215. {
  216. matrix.fillScreen(0); // Efface la matrice led
  217. FonctionAfficheFond();
  218. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  219. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  220. }
  221. FonctionMode3(); // Appelle la fonction d'affichage du mode 3
  222. }
  223. else if (ModeCourant == 4) // ******************************************************************* // Mode 4 sélectionné
  224. {
  225. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  226. {
  227. matrix.fillScreen(0); // Efface la matrice led
  228. FonctionAfficheFond();
  229. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  230. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  231. }
  232. FonctionMode4(); // Appelle la fonction d'affichage du mode 4
  233. }
  234. else if (ModeCourant == 5) // ******************************************************************* // Mode 5 sélectionné
  235. {
  236. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  237. {
  238. matrix.fillScreen(0); // Efface la matrice led
  239. FonctionAfficheFond();
  240. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  241. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  242. }
  243. FonctionMode5(); // Appelle la fonction d'affichage du mode 5
  244. }
  245. else if (ModeCourant == 6) // ******************************************************************* // Mode 6 sélectionné
  246. {
  247. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  248. {
  249. matrix.fillScreen(0); // Efface la matrice led
  250. FonctionAfficheFond();
  251. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  252. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  253.  
  254. for (int y = 0; y <= 48; y++) // Affiche le fond vert, jaune et rouge des bandes
  255. {
  256. if (y <= 24)
  257. {
  258. matrix.drawFastVLine(y, 8, 4, matrix.Color333(0, 7, 0));
  259. matrix.drawFastVLine(y, 21, 4, matrix.Color333(0, 7, 0));
  260. }
  261. else if (y <= 38)
  262. {
  263. matrix.drawFastVLine(y, 8, 4, matrix.Color333(7, 7, 0));
  264. matrix.drawFastVLine(y, 21, 4, matrix.Color333(7, 7, 0));
  265. }
  266. else
  267. {
  268. matrix.drawFastVLine(y, 8, 4, matrix.Color333(7, 0, 0));
  269. matrix.drawFastVLine(y, 21, 4, matrix.Color333(7, 0, 0));
  270. }
  271. }
  272. }
  273. FonctionMode6(); // Appelle la fonction d'affichage du mode 6
  274. }
  275. else if (ModeCourant == 7) // ******************************************************************* // Mode 7 sélectionné
  276. {
  277. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  278. {
  279. matrix.fillScreen(0); // Efface la matrice led
  280. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  281. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  282. }
  283. FonctionMode7(); // Appelle la fonction d'affichage du mode 7
  284. }
  285. else if (ModeCourant == 8) // ******************************************************************* // Mode 8 sélectionné
  286. {
  287. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  288. {
  289. matrix.fillScreen(0); // Efface la matrice led
  290. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  291. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  292. }
  293. FonctionMode8(); // Appelle la fonction d'affichage du mode 8
  294. }
  295. else if (ModeCourant == 9) // ******************************************************************* // Mode 9 sélectionné
  296. {
  297. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  298. {
  299. matrix.fillScreen(0); // Efface la matrice led
  300. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  301. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  302. }
  303. FonctionMode9(); // Appelle la fonction d'affichage du mode 9
  304. }
  305. else if (ModeCourant == 10) // ****************************************************************** // Mode 10 sélectionné
  306. {
  307. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  308. {
  309. matrix.fillScreen(0); // Efface la matrice led
  310. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  311. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  312. }
  313. FonctionMode10(); // Appelle la fonction d'affichage du mode 10
  314. }
  315. else if (ModeCourant == 11) // ****************************************************************** // Mode 11 sélectionné
  316. {
  317. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  318. {
  319. matrix.fillScreen(0); // Efface la matrice led
  320. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  321. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  322. }
  323. FonctionMode11(); // Appelle la fonction d'affichage du mode 11
  324. }
  325. else if (ModeCourant == 12) // ****************************************************************** // Mode 12 sélectionné
  326. {
  327. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  328. {
  329. matrix.fillScreen(0); // Efface la matrice led
  330. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  331. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  332. }
  333. FonctionMode12(); // Appelle la fonction d'affichage du mode 12
  334. }
  335. else if (ModeCourant == 13) // ****************************************************************** // Mode 13 sélectionné
  336. {
  337. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  338. {
  339. matrix.fillScreen(0); // Efface la matrice led
  340. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  341. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  342. }
  343. FonctionMode13(); // Appelle la fonction d'affichage du mode 13
  344. }
  345. else if (ModeCourant == 14) // ****************************************************************** // Mode 14 sélectionné
  346. {
  347. if (lastModeCourant != ModeCourant) // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Si le mode courant à changé
  348. {
  349. matrix.fillScreen(0); // Efface la matrice led
  350. FonctionInitVariables(); // Appelle la fonction d'initialisation des variables
  351. lastModeCourant = ModeCourant; // Mémorise le dernier mode courant
  352. }
  353. FonctionMode14(); // Appelle la fonction d'affichage du mode 14
  354. }
  355.  
  356. //**************************************************************************************************************************************************************************
  357. }
  358.  
  359. //**************************************************************************************************************************************************************************
  360. //*** Fonction affichage mode 0 - Bandes violettes 2 pixels de largeur *****************************************************************************************************
  361. //**************************************************************************************************************************************************************************
  362. void FonctionMode0 ()
  363. {
  364. if (ModeMicrophone == false)
  365. {
  366. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  367. //Serial.println(val); // Débug
  368. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  369.  
  370. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  371. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  372. }
  373. else
  374. {
  375. val = peakToPeak;
  376. //Serial.println(val); // Débug
  377. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  378. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  379. }
  380.  
  381. for (int col = 0; col <= 1; col++)
  382. {
  383. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  384.  
  385. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé de la Bande ************
  386. {
  387. matrix.drawPixel(yPic[col], (8+col*13)+1, 0); matrix.drawPixel(yPic[col], (8+col*13)+2, 0); // Efface la led la plus haute de la bande
  388. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  389. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  390. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  391. }
  392.  
  393. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes **********************************************
  394. {
  395. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en violet à partir de la dernière position
  396. {
  397. matrix.drawPixel(y, (8+col*13)+1, matrix.Color333(7, 0, 7)); matrix.drawPixel(y, (8+col*13)+2, matrix.Color333(7, 0, 7));
  398. }
  399.  
  400. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  401. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  402. }
  403. }
  404. }
  405.  
  406. //**************************************************************************************************************************************************************************
  407. //*** Fonction affichage mode 1 - Bandes vertes jaunes rouge 4 pixels de largeur *******************************************************************************************
  408. //**************************************************************************************************************************************************************************
  409. void FonctionMode1 ()
  410. {
  411. if (ModeMicrophone == false)
  412. {
  413. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  414. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  415.  
  416. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  417. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  418. }
  419. else
  420. {
  421. val = peakToPeak;
  422. //Serial.println(val); // Débug
  423. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  424. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  425. }
  426.  
  427. for (int col = 0; col <= 1; col++)
  428. {
  429. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  430.  
  431. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé des Bandes *************
  432. {
  433. matrix.drawPixel(yPic[col], (8+col*13)+1, 0); matrix.drawPixel(yPic[col], (8+col*13)+2, 0); // Efface les led les plus hautes de la bande
  434. matrix.drawPixel(yPic[col], (8+col*13), 0); matrix.drawPixel(yPic[col], (8+col*13)+3, 0); // Efface les led les plus hautes de la bande
  435. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  436. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  437. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  438. }
  439.  
  440. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes **********************************************
  441. {
  442. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en vert, jaune et rouge à partir de la dernière position
  443. {
  444. if (y <= 24)
  445. {
  446. matrix.drawFastVLine(y, (8+col*13), 4, matrix.Color333(0, 7, 0));
  447. }
  448. else if (y <= 38)
  449. {
  450. matrix.drawFastVLine(y, (8+col*13), 4, matrix.Color333(7, 7, 0));
  451. }
  452. else
  453. {
  454. matrix.drawFastVLine(y, (8+col*13), 4, matrix.Color333(7, 0, 0));
  455. }
  456. }
  457.  
  458. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  459. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  460. }
  461. }
  462. }
  463.  
  464. //**************************************************************************************************************************************************************************
  465. //*** Fonction affichage mode 2 - Bandes oranges 2 pixels de largeur *******************************************************************************************************
  466. //**************************************************************************************************************************************************************************
  467. void FonctionMode2 ()
  468. {
  469. if (ModeMicrophone == false)
  470. {
  471. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  472. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  473.  
  474. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  475. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  476. }
  477. else
  478. {
  479. val = peakToPeak;
  480. //Serial.println(val); // Débug
  481. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  482. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  483. }
  484.  
  485. for (int col = 0; col <= 1; col++)
  486. {
  487. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  488.  
  489. if (yAmplitude[col] > ylastAmplitude[col]) // Gestion de l'affichage montant de la Bande *******************************************************************************
  490. {
  491. if (ylastAmplitude[col] < 0) {ylastAmplitude[col] = 0;} // Réinitialise l'ordonnée du Pic de la bande courante
  492. for (int y = ylastAmplitude[col]; y <= yAmplitude[col]; y++) // Affiche la bande en orange
  493. {
  494. matrix.drawFastVLine(y, (8+col*13)+1, 2, matrix.ColorHSV(203, 255, 200, true));
  495. }
  496. ylastAmplitude[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  497. }
  498.  
  499. if (yAmplitude[col] < ylastAmplitude[col]) // Gestion de l'affichage descendant de la Bande ****************************************************************************
  500. {
  501. for (int y = ylastAmplitude[col]; y > yAmplitude[col]; y--) // Efface la bande
  502. {
  503. matrix.drawFastVLine(y, (8+col*13)+1, 2, 0);
  504. }
  505. ylastAmplitude[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  506. }
  507. }
  508. }
  509.  
  510. //**************************************************************************************************************************************************************************
  511. //*** Fonction affichage mode 3 - Bandes double traits verts et rouges 4 pixels de largeur *********************************************************************************
  512. //**************************************************************************************************************************************************************************
  513. void FonctionMode3 ()
  514. {
  515. if (ModeMicrophone == false)
  516. {
  517. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  518. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  519.  
  520. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  521. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  522. }
  523. else
  524. {
  525. val = peakToPeak;
  526. //Serial.println(val); // Débug
  527. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  528. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  529. }
  530.  
  531. for (int col = 0; col <= 1; col++)
  532. {
  533. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  534.  
  535. if (yAmplitude[col] < yPic[col] && millis() - t1tempoBande[col] > 30 && t1tempoBande[col] > 0) // Gestion de d'affichage descendant temporisé du Point *****************
  536. {
  537. matrix.drawFastVLine(yPic[col], (8+col*13), 4, 0); // Efface le dernier point
  538. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée du dernier point
  539. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0; matrix.drawFastVLine(0, (8+col*13), 4, matrix.Color333(0, 0, 0));} // Réinitialise l'ordonnée du point et la temporisation
  540. else // Affiche le point courant et redémarre la temporisation
  541. {
  542. if (yPic[col] <= 24)
  543. {
  544. matrix.drawFastVLine(yPic[col], (8+col*13), 4, matrix.Color333(0, 7, 0));
  545. }
  546. else if (yPic[col] <= 38)
  547. {
  548. matrix.drawFastVLine(yPic[col], (8+col*13), 4, matrix.Color333(7, 7, 0));
  549. //matrix.drawFastVLine(yPic[col], 21, 4, matrix.Color333(7, 7, 0));
  550. }
  551. else
  552. {
  553. matrix.drawFastVLine(yPic[col], (8+col*13), 4, matrix.Color333(7, 0, 0));
  554. }
  555. t1tempoBande[col] = millis();
  556. }
  557. }
  558.  
  559. if (yAmplitude[col] > yPic[col]) // Gestion de l'affichage montant du Point ********************************************************************************************
  560. {
  561. matrix.drawFastVLine(yPic[col], (8+col*13), 4, 0); // Efface le dernier point // Affiche le point courant
  562. matrix.drawFastVLine(yAmplitude[col], (8+col*13), 4, matrix.Color333(7, 0, 0));
  563. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du point courant
  564. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente du point
  565. }
  566. }
  567. }
  568.  
  569. //**************************************************************************************************************************************************************************
  570. //*** Fonction affichage mode 4 - Bandes vertes 2 pixels de largeur + pic en rouge *****************************************************************************************
  571. //**************************************************************************************************************************************************************************
  572. void FonctionMode4 ()
  573. {
  574. if (ModeMicrophone == false)
  575. {
  576. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  577. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  578.  
  579. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  580. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  581. }
  582. else
  583. {
  584. val = peakToPeak;
  585. //Serial.println(val); // Débug
  586. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  587. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  588. }
  589.  
  590. for (int col = 0; col <= 1; col++)
  591. {
  592. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  593.  
  594. if (millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Temporisation de la descente de la Bande ************************************************************
  595. {
  596. matrix.drawPixel(yHautBande[col], (8+col*13)+1, 0); // Efface la led la plus haute de la bande
  597. matrix.drawPixel(yHautBande[col], (8+col*13)+2, 0); // Efface la led la plus haute de la bande
  598. yHautBande[col] = yHautBande[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  599. if (yHautBande[col] < 0) {yHautBande[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  600. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  601. }
  602.  
  603. if (millis() - t1tempoPic[col] > 250 && t1tempoPic[col] > 0) // Temporisation avant l'affichage de la descente du Pic **************************************************
  604. {
  605. matrix.drawPixel(yPic[col], (8+col*13)+1, 0); // Efface l'ancienne position du Pic
  606. matrix.drawPixel(yPic[col], (8+col*13)+2, 0); // Efface l'ancienne position du Pic
  607. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée du Pic
  608. if (yPic[col] <= 0) {yPic[col] = 0; t1tempoPic[col] = 0;} // Désactive la gestion d'affichage du Pic
  609. else // Affiche la descente du Pic en rouge
  610. {
  611. if (yPic[col] > yHautBande[col])
  612. {
  613. matrix.drawPixel(yPic[col], (8+col*13)+1, matrix.Color333(7, 0, 0));
  614. matrix.drawPixel(yPic[col], (8+col*13)+2, matrix.Color333(7, 0, 0));
  615. delay(25);
  616. }
  617. else {t1tempoPic[col] = 0;}
  618. }
  619. }
  620.  
  621. if (yAmplitude[col] > yHautBande[col]) // Gestion de l'affichage montant de la Bande ***********************************************************************************
  622. {
  623. if (yAmplitude[col] < yPic[col]) // Affiche la bande uniquement
  624. {
  625. for (int y = yHautBande[col]; y < yAmplitude[col]; y++) // Affiche la bande en vert
  626. {
  627. matrix.drawPixel(y, (8+col*13)+1, matrix.Color333(0, 7, 0));
  628. matrix.drawPixel(y, (8+col*13)+2, matrix.Color333(0, 7, 0));
  629. }
  630. yHautBande[col] = yAmplitude[col] - 1; // Sauvegarde l'ordonnée de la bande courante
  631. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  632. }
  633. else // Affiche la bande et le Pic rouge
  634. {
  635. for (int y = yHautBande[col]; y < yAmplitude[col]; y++) // Affiche la bande en vert
  636. {
  637. matrix.drawPixel(y, (8+col*13)+1, matrix.Color333(0, 7, 0));
  638. matrix.drawPixel(y, (8+col*13)+2, matrix.Color333(0, 7, 0));
  639. }
  640. matrix.drawPixel(yAmplitude[col], (8+col*13)+1, matrix.Color333(7, 0, 0)); // Affiche le Pic en rouge
  641. matrix.drawPixel(yAmplitude[col], (8+col*13)+2, matrix.Color333(7, 0, 0));
  642.  
  643. yHautBande[col] = yAmplitude[col] - 1; // Sauvegarde l'ordonnée de la bande courante
  644. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  645. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  646. t1tempoPic[col] = millis(); // Démarre la temporisation de la descente du Pic
  647. }
  648. }
  649. }
  650. }
  651.  
  652. //**************************************************************************************************************************************************************************
  653. //*** Fonction affichage mode 5 - Bandes blanches 4 pixels de largeur + pic en rouge ***************************************************************************************
  654. //**************************************************************************************************************************************************************************
  655. void FonctionMode5 ()
  656. {
  657. if (ModeMicrophone == false)
  658. {
  659. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  660. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  661.  
  662. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  663. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  664. }
  665. else
  666. {
  667. val = peakToPeak;
  668. //Serial.println(val); // Débug
  669. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  670. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  671. }
  672.  
  673. for (int col = 0; col <= 1; col++)
  674. {
  675. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  676.  
  677. if (millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Temporisation de la descente de la Bande ************************************************************
  678. {
  679. matrix.drawPixel(yHautBande[col], (8+col*13), 0); // Efface la led la plus haute de la bande
  680. matrix.drawPixel(yHautBande[col], (8+col*13)+1, 0); // Efface la led la plus haute de la bande
  681. matrix.drawPixel(yHautBande[col], (8+col*13)+2, 0); // Efface la led la plus haute de la bande
  682. matrix.drawPixel(yHautBande[col], (8+col*13)+3, 0); // Efface la led la plus haute de la bande
  683. yHautBande[col] = yHautBande[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  684. if (yHautBande[col] < 0) {yHautBande[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  685. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  686. }
  687.  
  688. if (millis() - t1tempoPic[col] > 250 && t1tempoPic[col] > 0) // Temporisation avant l'affichage de la descente du Pic **************************************************
  689. {
  690. matrix.drawPixel(yPic[col], (8+col*13), 0); // Efface l'ancienne position du Pic
  691. matrix.drawPixel(yPic[col], (8+col*13)+1, 0); // Efface l'ancienne position du Pic
  692. matrix.drawPixel(yPic[col], (8+col*13)+2, 0); // Efface l'ancienne position du Pic
  693. matrix.drawPixel(yPic[col], (8+col*13)+3, 0); // Efface l'ancienne position du Pic
  694. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée du Pic
  695. if (yPic[col] <= 0) {yPic[col] = 0; t1tempoPic[col] = 0;} // Désactive la gestion d'affichage du Pic
  696. else // Affiche la descente du Pic en rouge
  697. {
  698. if (yPic[col] > yHautBande[col])
  699. {
  700. matrix.drawPixel(yPic[col], (8+col*13), matrix.Color333(7, 0, 0));
  701. matrix.drawPixel(yPic[col], (8+col*13)+1, matrix.Color333(7, 0, 0));
  702. matrix.drawPixel(yPic[col], (8+col*13)+2, matrix.Color333(7, 0, 0));
  703. matrix.drawPixel(yPic[col], (8+col*13)+3, matrix.Color333(7, 0, 0));
  704. delay(30);
  705. }
  706. else {t1tempoPic[col] = 0;}
  707. }
  708. }
  709.  
  710. if (yAmplitude[col] > yHautBande[col]) // Gestion de l'affichage montant de la Bande ***********************************************************************************
  711. {
  712. if (yAmplitude[col] < yPic[col]) // Affiche la bande uniquement
  713. {
  714. for (int y = yHautBande[col]; y < yAmplitude[col]; y++) // Affiche la bande en vert
  715. {
  716. matrix.drawPixel(y, (8+col*13), matrix.Color333(7, 7, 7));
  717. matrix.drawPixel(y, (8+col*13)+1, matrix.Color333(7, 7, 7));
  718. matrix.drawPixel(y, (8+col*13)+2, matrix.Color333(7, 7, 7));
  719. matrix.drawPixel(y, (8+col*13)+3, matrix.Color333(7, 7, 7));
  720. }
  721. yHautBande[col] = yAmplitude[col] - 1; // Sauvegarde l'ordonnée de la bande courante
  722. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  723. }
  724. else // Affiche la bande et le Pic rouge
  725. {
  726. for (int y = yHautBande[col]; y < yAmplitude[col]; y++) // Affiche la bande en vert
  727. {
  728. matrix.drawPixel(y, (8+col*13), matrix.Color333(7, 7, 7));
  729. matrix.drawPixel(y, (8+col*13)+1, matrix.Color333(7, 7, 7));
  730. matrix.drawPixel(y, (8+col*13)+2, matrix.Color333(7, 7, 7));
  731. matrix.drawPixel(y, (8+col*13)+3, matrix.Color333(7, 7, 7));
  732. }
  733. matrix.drawPixel(yAmplitude[col], (8+col*13), matrix.Color333(7, 0, 0)); // Affiche le Pic en rouge
  734. matrix.drawPixel(yAmplitude[col], (8+col*13)+1, matrix.Color333(7, 0, 0));
  735. matrix.drawPixel(yAmplitude[col], (8+col*13)+2, matrix.Color333(7, 0, 0));
  736. matrix.drawPixel(yAmplitude[col], (8+col*13)+3, matrix.Color333(7, 0, 0));
  737.  
  738. yHautBande[col] = yAmplitude[col] - 1; // Sauvegarde l'ordonnée de la bande courante
  739. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  740. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  741. t1tempoPic[col] = millis(); // Démarre la temporisation de la descente du Pic
  742. }
  743. }
  744. }
  745. }
  746.  
  747. //**************************************************************************************************************************************************************************
  748. //*** Fonction affichage mode 6 - Bandes noires 4 pixels de largeur sur fond vert jaune et rouge **************************************************************************
  749. //**************************************************************************************************************************************************************************
  750. void FonctionMode6 ()
  751. {
  752. if (ModeMicrophone == false)
  753. {
  754. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  755. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  756.  
  757. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  758. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  759. }
  760. else
  761. {
  762. val = peakToPeak;
  763. //Serial.println(val); // Débug
  764. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  765. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  766. }
  767.  
  768. for (int col = 0; col <= 1; col++)
  769. {
  770. if (yAmplitude[col] > 48) {yAmplitude[col] = 48;} // Borne l'abscisse verticale sur la matrice led
  771.  
  772. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé des Bandes **************
  773. {
  774. if (yPic[col] <= 24)
  775. {
  776. matrix.drawFastVLine(yPic[col], (8+col*13), 4, matrix.Color333(0, 7, 0));
  777. }
  778. else if (yPic[col] <= 38)
  779. {
  780. matrix.drawFastVLine(yPic[col], (8+col*13), 4, matrix.Color333(7, 7, 0));
  781. }
  782. else
  783. {
  784. matrix.drawFastVLine(yPic[col], (8+col*13), 4, matrix.Color333(7, 0, 0));
  785. }
  786. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  787. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  788. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  789. }
  790.  
  791. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes ***********************************************
  792. {
  793. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en noir à partir de la dernière position
  794. {
  795. matrix.drawFastVLine(y, (8+col*13), 4, matrix.Color333(0, 0, 0));
  796. }
  797.  
  798. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  799. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  800. }
  801. }
  802. }
  803.  
  804. //**************************************************************************************************************************************************************************
  805. //*** Fonction affichage mode 7 - Bandes multicolores 1 pixels de largeur + défilement à gauche ****************************************************************************
  806. //**************************************************************************************************************************************************************************
  807. void FonctionMode7 ()
  808. {
  809. if (ModeMicrophone == false)
  810. {
  811. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  812. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  813. }
  814. else
  815. {
  816. val = peakToPeak;
  817. //Serial.println(val); // Débug
  818. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  819. //yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  820. }
  821.  
  822. if (yAmplitude[0] > 48) {yAmplitude[0] = 48;} // Borne l'abscisse verticale sur la matrice led
  823.  
  824. for (int col = 15; col >= 1; col--) {TableauAmpLeft[col] = TableauAmpLeft[col-1];} // Décale les amplitudes de gauche dans le tableau "TableauAmpRight[]"
  825. TableauAmpLeft[0] = yAmplitude[0]; // Mémorise l'amplitude courante de droite dans la première case du tableau "TableauAmpRight[]"
  826.  
  827. matrix.drawFastHLine(0, 31, 48, 0);
  828. matrix.drawFastHLine(0, 31, TableauAmpLeft[0], matrix.ColorHSV(hue, 255, 255, true));
  829.  
  830. hue += 7;
  831. if(hue >= 1536) hue -= 1536;
  832. matrix.drawFastHLine(0, 29, 48, 0);
  833. matrix.drawFastHLine(0, 29, TableauAmpLeft[1], matrix.ColorHSV(hue, 255, 255, true));
  834.  
  835. hue += 7;
  836. if(hue >= 1536) hue -= 1536;
  837. matrix.drawFastHLine(0, 27, 48, 0);
  838. matrix.drawFastHLine(0, 27, TableauAmpLeft[2], matrix.ColorHSV(hue, 255, 255, true));
  839.  
  840. hue += 7;
  841. if(hue >= 1536) hue -= 1536;
  842. matrix.drawFastHLine(0, 25, 48, 0);
  843. matrix.drawFastHLine(0, 25, TableauAmpLeft[3], matrix.ColorHSV(hue, 255, 255, true));
  844.  
  845. hue += 7;
  846. if(hue >= 1536) hue -= 1536;
  847. matrix.drawFastHLine(0, 23, 48, 0);
  848. matrix.drawFastHLine(0, 23, TableauAmpLeft[4], matrix.ColorHSV(hue, 255, 255, true));
  849.  
  850. hue += 7;
  851. if(hue >= 1536) hue -= 1536;
  852. matrix.drawFastHLine(0, 21, 48, 0);
  853. matrix.drawFastHLine(0, 21, TableauAmpLeft[5], matrix.ColorHSV(hue, 255, 255, true));
  854.  
  855. hue += 7;
  856. if(hue >= 1536) hue -= 1536;
  857. matrix.drawFastHLine(0, 19, 48, 0);
  858. matrix.drawFastHLine(0, 19, TableauAmpLeft[6], matrix.ColorHSV(hue, 255, 255, true));
  859.  
  860. hue += 7;
  861. if(hue >= 1536) hue -= 1536;
  862. matrix.drawFastHLine(0, 17, 48, 0);
  863. matrix.drawFastHLine(0, 17, TableauAmpLeft[7], matrix.ColorHSV(hue, 255, 255, true));
  864.  
  865. hue += 7;
  866. if(hue >= 1536) hue -= 1536;
  867. matrix.drawFastHLine(0, 15, 48, 0);
  868. matrix.drawFastHLine(0, 15, TableauAmpLeft[8], matrix.ColorHSV(hue, 255, 255, true));
  869.  
  870. hue += 7;
  871. if(hue >= 1536) hue -= 1536;
  872. matrix.drawFastHLine(0, 13, 48, 0);
  873. matrix.drawFastHLine(0, 13, TableauAmpLeft[9], matrix.ColorHSV(hue, 255, 255, true));
  874.  
  875. hue += 7;
  876. if(hue >= 1536) hue -= 1536;
  877. matrix.drawFastHLine(0, 11, 48, 0);
  878. matrix.drawFastHLine(0, 11, TableauAmpLeft[10], matrix.ColorHSV(hue, 255, 255, true));
  879.  
  880. hue += 7;
  881. if(hue >= 1536) hue -= 1536;
  882. matrix.drawFastHLine(0, 9, 48, 0);
  883. matrix.drawFastHLine(0, 9, TableauAmpLeft[11], matrix.ColorHSV(hue, 255, 255, true));
  884.  
  885. hue += 7;
  886. if(hue >= 1536) hue -= 1536;
  887. matrix.drawFastHLine(0, 7, 48, 0);
  888. matrix.drawFastHLine(0, 7, TableauAmpLeft[12], matrix.ColorHSV(hue, 255, 255, true));
  889.  
  890. hue += 7;
  891. if(hue >= 1536) hue -= 1536;
  892. matrix.drawFastHLine(0, 5, 48, 0);
  893. matrix.drawFastHLine(0, 5, TableauAmpLeft[13], matrix.ColorHSV(hue, 255, 255, true));
  894.  
  895. hue += 7;
  896. if(hue >= 1536) hue -= 1536;
  897. matrix.drawFastHLine(0, 3, 48, 0);
  898. matrix.drawFastHLine(0, 3, TableauAmpLeft[14], matrix.ColorHSV(hue, 255, 255, true));
  899.  
  900. hue += 7;
  901. if(hue >= 1536) hue -= 1536;
  902. matrix.drawFastHLine(0, 1, 48, 0);
  903. matrix.drawFastHLine(0, 1, TableauAmpLeft[15], matrix.ColorHSV(hue, 255, 255, true));
  904. }
  905.  
  906. //**************************************************************************************************************************************************************************
  907. //*** Fonction affichage mode 8 - Bandes multicolores 1 pixels de largeur + défilement à droite ****************************************************************************
  908. //**************************************************************************************************************************************************************************
  909. void FonctionMode8 ()
  910. {
  911. if (ModeMicrophone == false)
  912. {
  913. val = analogRead(audioInRight); // Lit l'entrée audio (Sortie casque ampli)
  914. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  915. }
  916. else
  917. {
  918. val = peakToPeak;
  919. //Serial.println(val); // Débug
  920. //yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  921. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  922. }
  923.  
  924. if (yAmplitude[1] > 48) {yAmplitude[1] = 48;} // Borne l'abscisse verticale sur la matrice led
  925.  
  926. for (int col = 15; col >= 1; col--) {TableauAmpRight[col] = TableauAmpRight[col-1];} // Décale les amplitudes de droite dans le tableau "TableauAmpRight[]"
  927. TableauAmpRight[0] = yAmplitude[1]; // Mémorise l'amplitude courante de droite dans la première case du tableau "TableauAmpRight[]"
  928.  
  929. matrix.drawFastHLine(0, 1, 48, 0);
  930. matrix.drawFastHLine(0, 1, TableauAmpRight[0], matrix.ColorHSV(hue, 255, 255, true));
  931.  
  932. hue += 7;
  933. if(hue >= 1536) hue -= 1536;
  934. matrix.drawFastHLine(0, 3, 48, 0);
  935. matrix.drawFastHLine(0, 3, TableauAmpRight[1], matrix.ColorHSV(hue, 255, 255, true));
  936.  
  937. hue += 7;
  938. if(hue >= 1536) hue -= 1536;
  939. matrix.drawFastHLine(0, 5, 48, 0);
  940. matrix.drawFastHLine(0, 5, TableauAmpRight[2], matrix.ColorHSV(hue, 255, 255, true));
  941.  
  942. hue += 7;
  943. if(hue >= 1536) hue -= 1536;
  944. matrix.drawFastHLine(0, 7, 48, 0);
  945. matrix.drawFastHLine(0, 7, TableauAmpRight[3], matrix.ColorHSV(hue, 255, 255, true));
  946.  
  947. hue += 7;
  948. if(hue >= 1536) hue -= 1536;
  949. matrix.drawFastHLine(0, 9, 48, 0);
  950. matrix.drawFastHLine(0, 9, TableauAmpRight[4], matrix.ColorHSV(hue, 255, 255, true));
  951.  
  952. hue += 7;
  953. if(hue >= 1536) hue -= 1536;
  954. matrix.drawFastHLine(0, 11, 48, 0);
  955. matrix.drawFastHLine(0, 11, TableauAmpRight[5], matrix.ColorHSV(hue, 255, 255, true));
  956.  
  957. hue += 7;
  958. if(hue >= 1536) hue -= 1536;
  959. matrix.drawFastHLine(0, 13, 48, 0);
  960. matrix.drawFastHLine(0, 13, TableauAmpRight[6], matrix.ColorHSV(hue, 255, 255, true));
  961.  
  962. hue += 7;
  963. if(hue >= 1536) hue -= 1536;
  964. matrix.drawFastHLine(0, 15, 48, 0);
  965. matrix.drawFastHLine(0, 15, TableauAmpRight[7], matrix.ColorHSV(hue, 255, 255, true));
  966.  
  967. hue += 7;
  968. if(hue >= 1536) hue -= 1536;
  969. matrix.drawFastHLine(0, 17, 48, 0);
  970. matrix.drawFastHLine(0, 17, TableauAmpRight[8], matrix.ColorHSV(hue, 255, 255, true));
  971.  
  972. hue += 7;
  973. if(hue >= 1536) hue -= 1536;
  974. matrix.drawFastHLine(0, 19, 48, 0);
  975. matrix.drawFastHLine(0, 19, TableauAmpRight[9], matrix.ColorHSV(hue, 255, 255, true));
  976.  
  977. hue += 7;
  978. if(hue >= 1536) hue -= 1536;
  979. matrix.drawFastHLine(0, 21, 48, 0);
  980. matrix.drawFastHLine(0, 21, TableauAmpRight[10], matrix.ColorHSV(hue, 255, 255, true));
  981.  
  982. hue += 7;
  983. if(hue >= 1536) hue -= 1536;
  984. matrix.drawFastHLine(0, 23, 48, 0);
  985. matrix.drawFastHLine(0, 23, TableauAmpRight[11], matrix.ColorHSV(hue, 255, 255, true));
  986.  
  987. hue += 7;
  988. if(hue >= 1536) hue -= 1536;
  989. matrix.drawFastHLine(0, 25, 48, 0);
  990. matrix.drawFastHLine(0, 25, TableauAmpRight[12], matrix.ColorHSV(hue, 255, 255, true));
  991.  
  992. hue += 7;
  993. if(hue >= 1536) hue -= 1536;
  994. matrix.drawFastHLine(0, 27, 48, 0);
  995. matrix.drawFastHLine(0, 27, TableauAmpRight[13], matrix.ColorHSV(hue, 255, 255, true));
  996.  
  997. hue += 7;
  998. if(hue >= 1536) hue -= 1536;
  999. matrix.drawFastHLine(0, 29, 48, 0);
  1000. matrix.drawFastHLine(0, 29, TableauAmpRight[14], matrix.ColorHSV(hue, 255, 255, true));
  1001.  
  1002. hue += 7;
  1003. if(hue >= 1536) hue -= 1536;
  1004. matrix.drawFastHLine(0, 31, 48, 0);
  1005. matrix.drawFastHLine(0, 31, TableauAmpRight[15], matrix.ColorHSV(hue, 255, 255, true));
  1006. }
  1007.  
  1008. //**************************************************************************************************************************************************************************
  1009. //*** Fonction affichage mode 9 - Bandes multicolores 1 pixels de largeur + défilement à gauche et à droite ****************************************************************
  1010. //**************************************************************************************************************************************************************************
  1011. void FonctionMode9 ()
  1012. {
  1013. if (ModeMicrophone == false)
  1014. {
  1015. val = analogRead(audioInRight); // Lit l'entrée audio (Sortie casque ampli)
  1016. yAmplitude[1] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1017.  
  1018. val = analogRead(audioInLeft); // Lit l'entrée audio (Sortie casque ampli)
  1019. yAmplitude[0] = map(val,0, valEntreeMax, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1020. }
  1021. else
  1022. {
  1023. val = peakToPeak;
  1024. //Serial.println(val); // Débug
  1025. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1026. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1027. }
  1028.  
  1029. if (yAmplitude[1] > 48) {yAmplitude[1] = 48;} // Borne l'abscisse verticale sur la matrice led
  1030. if (yAmplitude[0] > 48) {yAmplitude[0] = 48;} // Borne l'abscisse verticale sur la matrice led
  1031.  
  1032. for (int col = 15; col >= 8; col--) {TableauAmp[col] = TableauAmp[col-1];}
  1033. TableauAmp[8] = yAmplitude[1];
  1034. for (int col = 8; col >= 1; col--) {TableauAmp[col] = TableauAmp[col-1];}
  1035. TableauAmp[0] = yAmplitude[0];
  1036.  
  1037. matrix.drawFastHLine(0, 16, 48, 0);
  1038. matrix.drawFastHLine(0, 16, TableauAmp[8], matrix.ColorHSV(hue, 255, 255, true));
  1039. matrix.drawFastHLine(0, 15, 48, 0);
  1040. matrix.drawFastHLine(0, 15, TableauAmp[0], matrix.ColorHSV(hue, 255, 255, true));
  1041.  
  1042. hue += 7;
  1043. if(hue >= 1536) hue -= 1536;
  1044. matrix.drawFastHLine(0, 18, 48, 0);
  1045. matrix.drawFastHLine(0, 18, TableauAmp[9], matrix.ColorHSV(hue, 255, 255, true));
  1046. matrix.drawFastHLine(0, 13, 48, 0);
  1047. matrix.drawFastHLine(0, 13, TableauAmp[1], matrix.ColorHSV(hue, 255, 255, true));
  1048.  
  1049. hue += 7;
  1050. if(hue >= 1536) hue -= 1536;
  1051. matrix.drawFastHLine(0, 20, 48, 0);
  1052. matrix.drawFastHLine(0, 20, TableauAmp[10], matrix.ColorHSV(hue, 255, 255, true));
  1053. matrix.drawFastHLine(0, 11, 48, 0);
  1054. matrix.drawFastHLine(0, 11, TableauAmp[2], matrix.ColorHSV(hue, 255, 255, true));
  1055.  
  1056. hue += 7;
  1057. if(hue >= 1536) hue -= 1536;
  1058. matrix.drawFastHLine(0, 22, 48, 0);
  1059. matrix.drawFastHLine(0, 22, TableauAmp[11], matrix.ColorHSV(hue, 255, 255, true));
  1060. matrix.drawFastHLine(0, 9, 48, 0);
  1061. matrix.drawFastHLine(0, 9, TableauAmp[3], matrix.ColorHSV(hue, 255, 255, true));
  1062.  
  1063. hue += 7;
  1064. if(hue >= 1536) hue -= 1536;
  1065. matrix.drawFastHLine(0, 24, 48, 0);
  1066. matrix.drawFastHLine(0, 24, TableauAmp[12], matrix.ColorHSV(hue, 255, 255, true));
  1067. matrix.drawFastHLine(0, 7, 48, 0);
  1068. matrix.drawFastHLine(0, 7, TableauAmp[4], matrix.ColorHSV(hue, 255, 255, true));
  1069.  
  1070. hue += 7;
  1071. if(hue >= 1536) hue -= 1536;
  1072. matrix.drawFastHLine(0, 26, 48, 0);
  1073. matrix.drawFastHLine(0, 26, TableauAmp[13], matrix.ColorHSV(hue, 255, 255, true));
  1074. matrix.drawFastHLine(0, 5, 48, 0);
  1075. matrix.drawFastHLine(0, 5, TableauAmp[5], matrix.ColorHSV(hue, 255, 255, true));
  1076.  
  1077. hue += 7;
  1078. if(hue >= 1536) hue -= 1536;
  1079. matrix.drawFastHLine(0, 28, 48, 0);
  1080. matrix.drawFastHLine(0, 28, TableauAmp[14], matrix.ColorHSV(hue, 255, 255, true));
  1081. matrix.drawFastHLine(0, 3, 48, 0);
  1082. matrix.drawFastHLine(0, 3, TableauAmp[6], matrix.ColorHSV(hue, 255, 255, true));
  1083.  
  1084. hue += 7;
  1085. if(hue >= 1536) hue -= 1536;
  1086. matrix.drawFastHLine(0, 30, 48, 0);
  1087. matrix.drawFastHLine(0, 30, TableauAmp[15], matrix.ColorHSV(hue, 255, 255, true));
  1088. matrix.drawFastHLine(0, 1, 48, 0);
  1089. matrix.drawFastHLine(0, 1, TableauAmp[7], matrix.ColorHSV(hue, 255, 255, true));
  1090. }
  1091.  
  1092. //**************************************************************************************************************************************************************************
  1093. //*** Fonction affichage mode 10 - Bandes multicolores 1 pixels de largeur + défilement à droite en haut et en bas *********************************************************
  1094. //**************************************************************************************************************************************************************************
  1095. void FonctionMode10 ()
  1096. {
  1097. if (ModeMicrophone == false)
  1098. {
  1099. val = analogRead(audioInRight); // Lit l'entrée audio (Sortie casque ampli)
  1100. yAmplitude[1] = map(val,0, valEntreeMax, 0, 30); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1101.  
  1102. val = analogRead(audioInLeft); // Lit l'entrée audio (Sortie casque ampli)
  1103. yAmplitude[0] = map(val,0, valEntreeMax, 0, 30); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1104. }
  1105. else
  1106. {
  1107. val = peakToPeak;
  1108. //Serial.println(val); // Débug
  1109. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1110. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1111. }
  1112.  
  1113. if (yAmplitude[1] > 30) {yAmplitude[1] = 30;} // Borne l'abscisse verticale sur la matrice led
  1114. if (yAmplitude[0] > 30) {yAmplitude[0] = 30;} // Borne l'abscisse verticale sur la matrice led
  1115.  
  1116. for (int col = 15; col >= 1; col--) {TableauAmpRight[col] = TableauAmpRight[col-1];} // Décale les amplitudes de droite dans le tableau "TableauAmpRight[]"
  1117. TableauAmpRight[0] = yAmplitude[1]; // Mémorise l'amplitude courante de droite dans la première case du tableau "TableauAmpRight[]"
  1118. for (int col = 15; col >= 1; col--) {TableauAmpLeft[col] = TableauAmpLeft[col-1];} // Décale les amplitudes de gauche dans le tableau "TableauAmpRight[]"
  1119. TableauAmpLeft[0] = yAmplitude[0]; // Mémorise l'amplitude courante de droite dans la première case du tableau "TableauAmpRight[]"
  1120.  
  1121. matrix.drawFastHLine(32, 1, 30, 0); //matrix.Color333(7, 7, 7)
  1122. matrix.drawFastHLine(32, 1, TableauAmpRight[0], matrix.ColorHSV(hue, 255, 255, true));
  1123. matrix.drawFastHLine(31, 1, -30, 0);
  1124. matrix.drawFastHLine(31, 1, -TableauAmpLeft[0], matrix.ColorHSV(hue, 255, 255, true));
  1125.  
  1126. hue += 7;
  1127. if(hue >= 1536) hue -= 1536;
  1128. matrix.drawFastHLine(32, 3, 30, 0);
  1129. matrix.drawFastHLine(32, 3, TableauAmpRight[1], matrix.ColorHSV(hue, 255, 255, true));
  1130. matrix.drawFastHLine(31, 3, -30, 0);
  1131. matrix.drawFastHLine(31, 3, -TableauAmpLeft[1], matrix.ColorHSV(hue, 255, 255, true));
  1132.  
  1133. hue += 7;
  1134. if(hue >= 1536) hue -= 1536;
  1135. matrix.drawFastHLine(32, 5, 30, 0);
  1136. matrix.drawFastHLine(32, 5, TableauAmpRight[2], matrix.ColorHSV(hue, 255, 255, true));
  1137. matrix.drawFastHLine(31, 5, -30, 0);
  1138. matrix.drawFastHLine(31, 5, -TableauAmpLeft[2], matrix.ColorHSV(hue, 255, 255, true));
  1139.  
  1140. hue += 7;
  1141. if(hue >= 1536) hue -= 1536;
  1142. matrix.drawFastHLine(32, 7, 30, 0);
  1143. matrix.drawFastHLine(32, 7, TableauAmpRight[3], matrix.ColorHSV(hue, 255, 255, true));
  1144. matrix.drawFastHLine(31, 7, -30, 0);
  1145. matrix.drawFastHLine(31, 7, -TableauAmpLeft[3], matrix.ColorHSV(hue, 255, 255, true));
  1146.  
  1147. hue += 7;
  1148. if(hue >= 1536) hue -= 1536;
  1149. matrix.drawFastHLine(32, 9, 30, 0);
  1150. matrix.drawFastHLine(32, 9, TableauAmpRight[4], matrix.ColorHSV(hue, 255, 255, true));
  1151. matrix.drawFastHLine(31, 9, -30, 0);
  1152. matrix.drawFastHLine(31, 9, -TableauAmpLeft[4], matrix.ColorHSV(hue, 255, 255, true));
  1153.  
  1154. hue += 7;
  1155. if(hue >= 1536) hue -= 1536;
  1156. matrix.drawFastHLine(32, 11, 30, 0);
  1157. matrix.drawFastHLine(32, 11, TableauAmpRight[5], matrix.ColorHSV(hue, 255, 255, true));
  1158. matrix.drawFastHLine(31, 11, -30, 0);
  1159. matrix.drawFastHLine(31, 11, -TableauAmpLeft[5], matrix.ColorHSV(hue, 255, 255, true));
  1160.  
  1161. hue += 7;
  1162. if(hue >= 1536) hue -= 1536;
  1163. matrix.drawFastHLine(32, 13, 30, 0);
  1164. matrix.drawFastHLine(32, 13, TableauAmpRight[6], matrix.ColorHSV(hue, 255, 255, true));
  1165. matrix.drawFastHLine(31, 13, -30, 0);
  1166. matrix.drawFastHLine(31, 13, -TableauAmpLeft[6], matrix.ColorHSV(hue, 255, 255, true));
  1167.  
  1168. hue += 7;
  1169. if(hue >= 1536) hue -= 1536;
  1170. matrix.drawFastHLine(32, 15, 30, 0);
  1171. matrix.drawFastHLine(32, 15, TableauAmpRight[7], matrix.ColorHSV(hue, 255, 255, true));
  1172. matrix.drawFastHLine(31, 15, -30, 0);
  1173. matrix.drawFastHLine(31, 15, -TableauAmpLeft[7], matrix.ColorHSV(hue, 255, 255, true));
  1174.  
  1175. hue += 7;
  1176. if(hue >= 1536) hue -= 1536;
  1177. matrix.drawFastHLine(32, 17, 30, 0);
  1178. matrix.drawFastHLine(32, 17, TableauAmpRight[8], matrix.ColorHSV(hue, 255, 255, true));
  1179. matrix.drawFastHLine(31, 17, -30, 0);
  1180. matrix.drawFastHLine(31, 17, -TableauAmpLeft[8], matrix.ColorHSV(hue, 255, 255, true));
  1181.  
  1182. hue += 7;
  1183. if(hue >= 1536) hue -= 1536;
  1184. matrix.drawFastHLine(32, 19, 30, 0);
  1185. matrix.drawFastHLine(32, 19, TableauAmpRight[9], matrix.ColorHSV(hue, 255, 255, true));
  1186. matrix.drawFastHLine(31, 19, -30, 0);
  1187. matrix.drawFastHLine(31, 19, -TableauAmpLeft[9], matrix.ColorHSV(hue, 255, 255, true));
  1188.  
  1189. hue += 7;
  1190. if(hue >= 1536) hue -= 1536;
  1191. matrix.drawFastHLine(32, 21, 30, 0);
  1192. matrix.drawFastHLine(32, 21, TableauAmpRight[10], matrix.ColorHSV(hue, 255, 255, true));
  1193. matrix.drawFastHLine(31, 21, -30, 0);
  1194. matrix.drawFastHLine(31, 21, -TableauAmpLeft[10], matrix.ColorHSV(hue, 255, 255, true));
  1195.  
  1196. hue += 7;
  1197. if(hue >= 1536) hue -= 1536;
  1198. matrix.drawFastHLine(32, 23, 30, 0);
  1199. matrix.drawFastHLine(32, 23, TableauAmpRight[11], matrix.ColorHSV(hue, 255, 255, true));
  1200. matrix.drawFastHLine(31, 23, -30, 0);
  1201. matrix.drawFastHLine(31, 23, -TableauAmpLeft[11], matrix.ColorHSV(hue, 255, 255, true));
  1202.  
  1203. hue += 7;
  1204. if(hue >= 1536) hue -= 1536;
  1205. matrix.drawFastHLine(32, 25, 30, 0);
  1206. matrix.drawFastHLine(32, 25, TableauAmpRight[12], matrix.ColorHSV(hue, 255, 255, true));
  1207. matrix.drawFastHLine(31, 25, -30, 0);
  1208. matrix.drawFastHLine(31, 25, -TableauAmpLeft[12], matrix.ColorHSV(hue, 255, 255, true));
  1209.  
  1210. hue += 7;
  1211. if(hue >= 1536) hue -= 1536;
  1212. matrix.drawFastHLine(32, 27, 30, 0);
  1213. matrix.drawFastHLine(32, 27, TableauAmpRight[13], matrix.ColorHSV(hue, 255, 255, true));
  1214. matrix.drawFastHLine(31, 27, -30, 0);
  1215. matrix.drawFastHLine(31, 27, -TableauAmpLeft[13], matrix.ColorHSV(hue, 255, 255, true));
  1216.  
  1217. hue += 7;
  1218. if(hue >= 1536) hue -= 1536;
  1219. matrix.drawFastHLine(32, 29, 30, 0);
  1220. matrix.drawFastHLine(32, 29, TableauAmpRight[14], matrix.ColorHSV(hue, 255, 255, true));
  1221. matrix.drawFastHLine(31, 29, -30, 0);
  1222. matrix.drawFastHLine(31, 29, -TableauAmpLeft[14], matrix.ColorHSV(hue, 255, 255, true));
  1223.  
  1224. hue += 7;
  1225. if(hue >= 1536) hue -= 1536;
  1226. matrix.drawFastHLine(32, 31, 30, 0);
  1227. matrix.drawFastHLine(32, 31, TableauAmpRight[15], matrix.ColorHSV(hue, 255, 255, true));
  1228. matrix.drawFastHLine(31, 31, -30, 0);
  1229. matrix.drawFastHLine(31, 31, -TableauAmpLeft[15], matrix.ColorHSV(hue, 255, 255, true));
  1230. }
  1231.  
  1232. //**************************************************************************************************************************************************************************
  1233. //*** Fonction affichage mode 11 - Bandes vertes jaunes rouge 8 pixels de largeur ******************************************************************************************
  1234. //**************************************************************************************************************************************************************************
  1235. void FonctionMode11 ()
  1236. {
  1237. if (ModeMicrophone == false)
  1238. {
  1239. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  1240. yAmplitude[0] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1241.  
  1242. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  1243. yAmplitude[1] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1244. }
  1245. else
  1246. {
  1247. val = peakToPeak;
  1248. //Serial.println(val); // Débug
  1249. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1250. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1251. }
  1252.  
  1253. for (int col = 0; col <= 1; col++)
  1254. {
  1255. if (yAmplitude[col] > 58) {yAmplitude[col] = 58;} // Borne l'abscisse verticale sur la matrice led
  1256.  
  1257. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé des Bandes *************
  1258. {
  1259. matrix.drawFastVLine(yPic[col], (5+col*14), 8, 0); // Efface les led les plus hautes de la bande
  1260. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  1261. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  1262. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  1263. }
  1264.  
  1265. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes **********************************************
  1266. {
  1267. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en vert, jaune et rouge à partir de la dernière position
  1268. {
  1269. if (y <= 26)
  1270. {
  1271. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(0, 7, 0));
  1272. }
  1273. else if (y <= 42)
  1274. {
  1275. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(7, 7, 0));
  1276. }
  1277. else
  1278. {
  1279. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(7, 0, 0));
  1280. }
  1281. }
  1282.  
  1283. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  1284. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  1285. }
  1286. }
  1287. }
  1288.  
  1289. //**************************************************************************************************************************************************************************
  1290. //*** Fonction affichage mode 12 - Bandes paires vertes jaunes rouge 8 pixels de largeur ***********************************************************************************
  1291. //**************************************************************************************************************************************************************************
  1292. void FonctionMode12 ()
  1293. {
  1294. if (ModeMicrophone == false)
  1295. {
  1296. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  1297. yAmplitude[0] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1298.  
  1299. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  1300. yAmplitude[1] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1301. }
  1302. else
  1303. {
  1304. val = peakToPeak;
  1305. //Serial.println(val); // Débug
  1306. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1307. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1308. }
  1309.  
  1310. for (int col = 0; col <= 1; col++)
  1311. {
  1312. if (yAmplitude[col] > 58) {yAmplitude[col] = 58;} // Borne l'abscisse verticale sur la matrice led
  1313.  
  1314. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé des Bandes *************
  1315. {
  1316. matrix.drawFastVLine(yPic[col], (5+col*14), 8, 0); // Efface les led les plus hautes de la bande
  1317. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  1318. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  1319. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  1320. }
  1321.  
  1322. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes **********************************************
  1323. {
  1324. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en vert, jaune et rouge à partir de la dernière position
  1325. {
  1326. if (y % 2 == 0) // Si y est un nombre pair
  1327. {
  1328. if (y <= 26)
  1329. {
  1330. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(0, 7, 0));
  1331. }
  1332. else if (y <= 42)
  1333. {
  1334. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(7, 7, 0));
  1335. }
  1336. else
  1337. {
  1338. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(7, 0, 0));
  1339. }
  1340. }
  1341. }
  1342.  
  1343. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  1344. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  1345. }
  1346. }
  1347. }
  1348.  
  1349. //**************************************************************************************************************************************************************************
  1350. //*** Fonction affichage mode 13 - Bandes paires dégradées vertes jaunes rouge 8 pixels de largeur *************************************************************************
  1351. //**************************************************************************************************************************************************************************
  1352. void FonctionMode13 ()
  1353. {
  1354. if (ModeMicrophone == false)
  1355. {
  1356. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  1357. yAmplitude[0] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1358.  
  1359. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  1360. yAmplitude[1] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1361. }
  1362. else
  1363. {
  1364. val = peakToPeak;
  1365. //Serial.println(val); // Débug
  1366. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1367. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1368. }
  1369.  
  1370. for (int col = 0; col <= 1; col++)
  1371. {
  1372. if (yAmplitude[col] > 58) {yAmplitude[col] = 58;} // Borne l'abscisse verticale sur la matrice led
  1373.  
  1374. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé des Bandes *************
  1375. {
  1376. matrix.drawFastVLine(yPic[col], (5+col*14), 8, 0); // Efface les led les plus hautes de la bande
  1377. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  1378. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  1379. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  1380. }
  1381.  
  1382. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes **********************************************
  1383. {
  1384. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en vert, jaune et rouge à partir de la dernière position
  1385. {
  1386. if (y % 2 == 0) // Si y est un nombre pair
  1387. {
  1388. if (y <= 26)
  1389. {
  1390. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(0, 3, 0));
  1391. }
  1392. else if (y <= 42)
  1393. {
  1394. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(5, 5, 0));
  1395. }
  1396. else
  1397. {
  1398. matrix.drawFastVLine(y, (5+col*14), 8, matrix.Color333(7, 0, 0));
  1399. }
  1400. }
  1401. }
  1402.  
  1403. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  1404. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  1405. }
  1406. }
  1407. }
  1408.  
  1409. //**************************************************************************************************************************************************************************
  1410. //*** Fonction affichage mode 14 - Bandes paires dégradées vertes jaunes rouge de 1 à 12 pixels de largeur *****************************************************************
  1411. //**************************************************************************************************************************************************************************
  1412. void FonctionMode14 ()
  1413. {
  1414. if (ModeMicrophone == false)
  1415. {
  1416. val = analogRead(audioInLeft); // Lit l'entrée audio de gauche (Sortie casque ampli)
  1417. yAmplitude[0] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1418.  
  1419. val = analogRead(audioInRight); // Lit l'entrée audio de droite (Sortie casque ampli)
  1420. yAmplitude[1] = map(val,0, valEntreeMax, 0, 58); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1421. }
  1422. else
  1423. {
  1424. val = peakToPeak;
  1425. //Serial.println(val); // Débug
  1426. yAmplitude[0] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1427. yAmplitude[1] = map(val,0, valEntreeMax1, 0, 48); // Convertit la valeur lue sur l'entrée audio en abscisse verticale sur la matrice led
  1428. }
  1429.  
  1430. for (int col = 0; col <= 1; col++)
  1431. {
  1432. if (yAmplitude[col] > 58) {yAmplitude[col] = 58;} // Borne l'abscisse verticale sur la matrice led
  1433.  
  1434. if (yAmplitude[col] <= yPic[col] && millis() - t1tempoBande[col] > 20 && t1tempoBande[col] > 0) // Gestion de l'effacement descendant temporisé des Bandes *************
  1435. {
  1436. matrix.drawFastVLine(yPic[col], (4+col*14), 12, 0); // Efface les led les plus hautes de la bande
  1437. yPic[col] = yPic[col] - 1; // Incrémente l'ordonnée de la led la plus haute de la bande
  1438. if (yPic[col] < 0) {yPic[col] = 0; t1tempoBande[col] = 0;} // Réinitialisation de la temporisation de la descente de la bande
  1439. else {t1tempoBande[col] = millis();} // Redémarre la temporisation de la descente de la bande
  1440. }
  1441.  
  1442. if (yAmplitude[col] > yPic[col] || (yAmplitude[col] == 0 && yPic[col] == 0)) // Gestion de l'affichage montant des Bandes **********************************************
  1443. {
  1444. for (int y = yPic[col]; y <= yAmplitude[col]; y++) // Affiche les bandes en vert, jaune et rouge à partir de la dernière position
  1445. {
  1446. if (y % 2 == 0) // Si y est un nombre pair
  1447. {
  1448. if (y <= 26)
  1449. {
  1450. matrix.drawFastVLine(y, (4+col*14), map(y,0,58,1,12), matrix.Color333(0, 3, 0));
  1451. }
  1452. else if (y <= 42)
  1453. {
  1454. matrix.drawFastVLine(y, (4+col*14), map(y,0,58,1,12), matrix.Color333(5, 5, 0));
  1455. }
  1456. else
  1457. {
  1458. matrix.drawFastVLine(y, (4+col*14), map(y,0,58,1,12), matrix.Color333(7, 0, 0));
  1459. }
  1460. }
  1461. }
  1462.  
  1463. yPic[col] = yAmplitude[col]; // Sauvegarde l'ordonnée du Pic de la bande courante
  1464. t1tempoBande[col] = millis(); // Démarre la temporisation de la descente de la bande
  1465. }
  1466. }
  1467. }
  1468.  
  1469. //**************************************************************************************************************************************************************************
  1470. //*** Fonction affichage du fond en fonction du mode sélectionné ***********************************************************************************************************
  1471. //**************************************************************************************************************************************************************************
  1472. void FonctionAfficheFond ()
  1473. {
  1474. matrix.drawFastHLine(0, 6, 50, matrix.Color333(0, 0, 7)); // Affiche le fond
  1475. matrix.drawFastHLine(0, 7, 25, matrix.Color333(0, 7, 0));
  1476. matrix.drawFastHLine(25, 7, 14, matrix.Color333(7, 7, 0));
  1477. matrix.drawFastHLine(39, 7, 10, matrix.Color333(7, 0, 0));
  1478. matrix.drawFastHLine(0, 12, 25, matrix.Color333(0, 7, 0));
  1479. matrix.drawFastHLine(25, 12, 14, matrix.Color333(7, 7, 0));
  1480. matrix.drawFastHLine(39, 12, 10, matrix.Color333(7, 0, 0));
  1481. matrix.drawFastHLine(0, 13, 50, matrix.Color333(0, 0, 7));
  1482. matrix.drawFastVLine(49, 5, 10, matrix.Color333(0, 0, 7));
  1483. matrix.drawFastVLine(50, 6, 8, matrix.Color333(0, 0, 7));
  1484. matrix.drawFastVLine(51, 7, 6, matrix.Color333(0, 0, 7));
  1485. matrix.drawFastVLine(52, 8, 4, matrix.Color333(0, 0, 7));
  1486. matrix.drawFastVLine(53, 9, 2, matrix.Color333(0, 0, 7));
  1487. matrix.drawPixel(39, 5, matrix.Color333(0, 0, 7));
  1488. matrix.drawPixel(39, 14, matrix.Color333(0, 0, 7));
  1489. matrix.drawPixel(25, 5, matrix.Color333(0, 0, 7));
  1490. matrix.drawPixel(25, 14, matrix.Color333(0, 0, 7));
  1491. matrix.drawPixel(0, 5, matrix.Color333(0, 0, 7));
  1492. matrix.drawPixel(0, 14, matrix.Color333(0, 0, 7));
  1493.  
  1494. matrix.drawFastHLine(0, 19, 50, matrix.Color333(0, 0, 7));
  1495. matrix.drawFastHLine(0, 20, 25, matrix.Color333(0, 7, 0));
  1496. matrix.drawFastHLine(25, 20, 14, matrix.Color333(7, 7, 0));
  1497. matrix.drawFastHLine(39, 20, 10, matrix.Color333(7, 0, 0));
  1498. matrix.drawFastHLine(0, 25, 25, matrix.Color333(0, 7, 0));
  1499. matrix.drawFastHLine(25, 25, 14, matrix.Color333(7, 7, 0));
  1500. matrix.drawFastHLine(39, 25, 10, matrix.Color333(7, 0, 0));
  1501. matrix.drawFastHLine(0, 26, 50, matrix.Color333(0, 0, 7));
  1502. matrix.drawFastVLine(49, 18, 10, matrix.Color333(0, 0, 7));
  1503. matrix.drawFastVLine(50, 19, 8, matrix.Color333(0, 0, 7));
  1504. matrix.drawFastVLine(51, 20, 6, matrix.Color333(0, 0, 7));
  1505. matrix.drawFastVLine(52, 21, 4, matrix.Color333(0, 0, 7));
  1506. matrix.drawFastVLine(53, 22, 2, matrix.Color333(0, 0, 7));
  1507. matrix.drawPixel(39, 18, matrix.Color333(0, 0, 7));
  1508. matrix.drawPixel(39, 27, matrix.Color333(0, 0, 7));
  1509. matrix.drawPixel(25, 18, matrix.Color333(0, 0, 7));
  1510. matrix.drawPixel(25, 27, matrix.Color333(0, 0, 7));
  1511. matrix.drawPixel(0, 18, matrix.Color333(0, 0, 7));
  1512. matrix.drawPixel(0, 27, matrix.Color333(0, 0, 7));
  1513. }
  1514.  
  1515. //**************************************************************************************************************************************************************************
  1516. //*** Fonction réinitialisation des variables entre chaque mode sélectionné ************************************************************************************************
  1517. //**************************************************************************************************************************************************************************
  1518. void FonctionInitVariables ()
  1519. {
  1520. hue = 0;
  1521. for (int i = 0; i <= 1; i++) // Réinitialisation des variables
  1522. {
  1523. yAmplitude[i] = 0;
  1524. ylastAmplitude[i] = 0;
  1525. yPic[i] = 0;
  1526. t1tempoBande[i] = 0;
  1527. t1tempoPic[i] = 0;
  1528. yHautBande[i] = 0;
  1529. }
  1530. for (int i = 0; i <= 15; i++)
  1531. {
  1532. TableauAmp[i] = 0;
  1533. TableauAmpLeft[i] = 0;
  1534. TableauAmpRight[i] = 0;
  1535. }
  1536. }
  1537.  
  1538. //**************************************************************************************************************************************************************************
  1539. //*** Fonction Gestion Buzzer **********************************************************************************************************************************************
  1540. //**************************************************************************************************************************************************************************
  1541. void Buzzer (int TempsH, int TempsL, int nb) // TempsH => délai buzzer ON, TempsL => délai buzzer OFF, nb => nombre de bips
  1542. {
  1543. for (int x = 1; x <= nb; x++) // ************************************************************************************ // Boucle le nombre de fois voulu passé par l'argument "int nb"
  1544. {
  1545. digitalWrite(BrocheBuzzer, HIGH); // Active le buzzer
  1546. delay (TempsH); // Temporisation à l'état haut du buzzer pendant la durée passée par l'argument "int TempsH"
  1547. digitalWrite(BrocheBuzzer, LOW); // Désactive le buzzer
  1548. delay (TempsL); // Temporisation à l'état bas du buzzer pendant la durée passée par l'argument "int TempsL"
  1549. }
  1550. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!