SHARE
TWEET

surprise

a guest Mar 26th, 2020 58 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.   ///////////////////////////////////////////////////////////////////
  3.   ///////////////   ARDUINO-SURPRISE-SURPRISE ///////////////////////
  4.   ///////////////////////////////////////////////////////////////////
  5.   // Un programme pédagogique des petits débrouillards ?=+ pour découvrir Arduino et les composants électroniques
  6.   // mars 2020 CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
  7.   ////////////////////////////////////////
  8.   //
  9.   Il te faut
  10.   - un Arduino:
  11.   - Brancher un bouton poussoir en D2 (+résistance de 10kΩ) , un HP ou buzzer en D3 et un servo moteur en D5 (facultatif)
  12.   - Brancher sur les 5 entrées analogiques (RIEN SUR A0) A1, A2, A3, A4, A5 des potentiomètres, photorésistance,....
  13.   - Brancher sur les broches digitales 6, 7, 8, 9, 10, 11, 12, 13, des leds, moteurs DC 5V, relai,....
  14.     avec les résistances nécessaires (220Ω ou plus pour les LED)
  15.   //
  16.   Puis
  17.   - Téléverser le programme
  18.   - Appuyer sur le bouton poussoir pour changer de programme
  19.    ////////////////////////////////////////
  20.   À toi de jouer :
  21.       - avec les entrées analogiques et observer ce qu'il se passe !!!
  22.       - en écrivant de nouveaux programme !!!
  23.   ////////////////////////////////////////
  24. */
  25.  
  26. #include <Servo.h>  // Création de l'objet servo issu du moule Servo qui sera attaché en 5
  27. Servo servo;
  28. int pos = 0;        // Pour la position du servomoteur
  29.  
  30. // Tableau listant les 5 entrées analogiques potar, photorésistance,....
  31. const int AnalIn[5] = {A1, A2, A3, A4, A5}; // Rien sur A0 pour obtenir une graine aléatoire en lisant la broche analogique non connectée.
  32.  
  33. const int ledPin[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Tableau listant les sorties digitales : LED, DC motor,...
  34. const int buzzer = 3;    // Branchement du buzzer
  35.  
  36. const int Bouton = 2;   // Bouton poussoir en 2 pour lancer un des programmes en aléatoire
  37. int EtatBouton = 0;     // Pour l'état du bouton
  38.  
  39. long randNumber;        // Variable aléatoire pour lancer tel ou tel programme
  40.  
  41. void setup() {
  42.  
  43.   // Les entrées analogiques
  44.   for (int i = 0; i < 5; i++)
  45.   {
  46.     pinMode(AnalIn[i], INPUT);
  47.   }
  48.  
  49.   // Les sorties digitales
  50.   for (int i = 0; i < 8; i++)
  51.   {
  52.     pinMode(ledPin[i], OUTPUT);
  53.     digitalWrite(ledPin[i], LOW);
  54.   }
  55.  
  56.   pinMode(buzzer, OUTPUT);   // Le Buzzer est une sortie
  57.  
  58.   servo.attach(5);   // le servomoteur est branché à la broche 5
  59.   servo.write(0);   // Positionne au démarrage le servo en position 0
  60.  
  61.   pinMode(Bouton, INPUT_PULLUP);  // Annonce que la variable bouton connectée sur la PIN 2 est une entrée avec la résistance de PULLUP activée.
  62.  
  63.   Serial.begin(9600);       // Pour communiquer avec l'ordinateur
  64.   Serial.println("start");  // On envoie le message "start" sur le moniteur série
  65.  
  66.   randomSeed(analogRead(A0));     // Initialise le générateur de nombre aléatoire
  67. }
  68.  
  69. void loop() {
  70.   unsigned int val1, val2, val3, val4, val5;   // Déclaration des variables pour chaque potentiomètre
  71.   programmeinit(val1, val2, val3, val4, val5);
  72. }
  73.  
  74. //Programme init
  75. void programmeinit(int val1, int val2, int val3, int val4, int val5) {
  76.  
  77.   EtatBouton = digitalRead(Bouton);   // On lit l'état du bouton poussoir
  78.   if (EtatBouton == HIGH) {
  79.     Serial.println("APPUI");
  80.     randNumber = random(0, 4); // intervalle à changer en fonction du nombre de case/programme disponible
  81.     Serial.println(randNumber);
  82.  
  83.     switch (randNumber) {     // Des programmes différents en fonction du résultat obtenu
  84.       case 0: // Lancement du programme 0
  85.         Serial.println("programme0");
  86.         programme0(val1, val2, val3, val4, val5);
  87.         break;
  88.       case 1: // Lancement du programme 1
  89.         Serial.println("programme1");
  90.         programme1(val1, val2, val3, val4, val5);
  91.         break;
  92.       case 2: // Lancement du programme 2
  93.         Serial.println("programme2");
  94.         programme2(val1, val2, val3, val4, val5);
  95.         break;
  96.       case 3: // Lancement du programme 3
  97.         Serial.println("programme3");
  98.         programme3(val1, val2, val3, val4, val5);
  99.         break;
  100.       case 4: // Lancement du programme 4
  101.         Serial.println("programme4");
  102.         programme4(val1, val2, val3, val4, val5);
  103.         break;
  104.       default: // Cas par défaut
  105.         Serial.println("c'est pas normal");
  106.     }
  107.     delay(1000);
  108.   }
  109. }
  110.  
  111. /////////////////////////////////////////////////////////////
  112. //Programme 0 - Arpaggio
  113. /////////////////////////////////////////////////////////////
  114. void programme0(int val1, int val2, int val3, int val4, int val5) {
  115.  
  116.   // on lit les valeurs des entrées analogqiues
  117.   val1 = analogRead(A1);  // note son avec A2
  118.   val2 = analogRead(A2);  // note son avec A1
  119.   val3 = analogRead(A3);  // pause son avec A4 et A5
  120.   val4 = analogRead(A4);  // pause son avec A3 et A5
  121.   val5 = analogRead(A5);  // pause son avec A3 et A4
  122.  
  123.   int son_val = map (val1 + val2, 0, 1023, 0, 255);
  124.   Serial.println("son_val :");
  125.   Serial.print(son_val);
  126.   int attendre = (val3 + val4 + val5) / 3;
  127.   Serial.print("\t attendre :");
  128.   Serial.println(attendre);
  129.  
  130.   tone(3, son_val);
  131.   digitalWrite(6, HIGH);
  132.   digitalWrite(13, HIGH);
  133.   for (pos = 0; pos <= 180; pos += 1) { // Mouvement du servomoteur de 0 à 180,pas par pas
  134.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  135.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  136.   }
  137.   delay(attendre);
  138.   tone(3, son_val * 2);
  139.   digitalWrite(6, LOW);
  140.   digitalWrite(13, LOW);
  141.   digitalWrite(7, HIGH);
  142.   digitalWrite(12, HIGH);
  143.   for (pos = 180; pos >= 0; pos -= 1) { // Mouvement du servomoteur de 180 à 0, pas par pas
  144.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  145.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  146.   }
  147.   delay(attendre);
  148.   tone(3, son_val * 3);
  149.   digitalWrite(7, LOW);
  150.   digitalWrite(12, LOW);
  151.   digitalWrite(8, HIGH);
  152.   digitalWrite(11, HIGH);
  153.   for (pos = 0; pos <= 180; pos += 1) { // Mouvement du servomoteur de 0 à 180°,pas par pas
  154.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  155.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  156.   }
  157.   delay(attendre);
  158.   tone(3, son_val * 4);
  159.   digitalWrite(8, LOW);
  160.   digitalWrite(11, LOW);
  161.   digitalWrite(9, HIGH);
  162.   digitalWrite(10, HIGH);
  163.   for (pos = 180; pos >= 0; pos -= 1) { // Mouvement du servomoteur de 180 à 0, pas par pas
  164.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  165.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  166.   }
  167.   delay(attendre);
  168.   tone(3, son_val * 5);
  169.   digitalWrite(9, LOW);
  170.   digitalWrite(10, LOW);
  171.   digitalWrite(6, HIGH);
  172.   digitalWrite(7, HIGH);
  173.   digitalWrite(8, HIGH);
  174.   digitalWrite(9, HIGH);
  175.   for (pos = 0; pos <= 180; pos += 1) { // Mouvement du servomoteur de 0 à 180°,pas par pas
  176.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  177.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  178.   }
  179.   delay(attendre);
  180.   tone(3, son_val * 6);
  181.   digitalWrite(6, LOW);
  182.   digitalWrite(7, LOW);
  183.   digitalWrite(8, LOW);
  184.   digitalWrite(9, LOW);
  185.   digitalWrite(10, HIGH);
  186.   digitalWrite(11, HIGH);
  187.   digitalWrite(12, HIGH);
  188.   digitalWrite(13, HIGH);
  189.   for (pos = 180; pos >= 0; pos -= 1) { // Mouvement du servomoteur de 180 à 0, pas par pas
  190.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  191.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  192.   }
  193.   delay(attendre);
  194.   digitalWrite(10, LOW);
  195.   digitalWrite(11, LOW);
  196.   digitalWrite(12, LOW);
  197.   digitalWrite(13, LOW);
  198.   for (pos = 0; pos <= 180; pos += 1) { // Mouvement du servomoteur de 0 à 180°,pas par pas
  199.     servo.write(pos);                     // Aller à la position stocké dans 'pos'
  200.     delay(15);                            // Attendre 15ms que le servomoteur se rende à 'pos'
  201.   }
  202.  
  203.   EtatBouton = digitalRead(Bouton);   // On relis la valeur du bouton poussoir
  204.   if (EtatBouton == HIGH) {           // Si appui, on retourne au programme init
  205.     Serial.println("GO TO PROGRAMME INIT");
  206.     noTone(3);                        // On coupe le son du buzzer, HP connecté en broche 3
  207.     programmeinit(val1, val2, val3, val4, val5);
  208.   }
  209.   else {      // Sinon, on reste sur le programme 0
  210.     Serial.println("programme0");
  211.     programme0(val1, val2, val3, val4, val5);
  212.   }
  213.  
  214. }
  215.  
  216. /////////////////////////////////////////////////////////////
  217. //Programme 1 = Chenillard
  218. /////////////////////////////////////////////////////////////
  219. void programme1(int val1, int val2, int val3, int val4, int val5) {
  220.  
  221.   int ledPin[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Tableau listant les pins
  222.  
  223.   // on lit les valeurs des entrées analogqiues
  224.   val1 = analogRead(A1); // sens chenillard
  225.   val2 = analogRead(A2); // note son
  226.   val3 = analogRead(A3);
  227.   val4 = analogRead(A4); // tempo chenillard
  228.   val5 = analogRead(A5);
  229.  
  230.   int senschenillard = val1;
  231.   Serial.print("senschenillard :");
  232.   Serial.print(senschenillard);
  233.   int tempochenillard = map (val4, 0, 1024, 0, 1000);
  234.   Serial.print("\t tempo :");
  235.   Serial.println(tempochenillard);
  236.  
  237.   int son_val = map (val2, 0, 1023, 100, 440);
  238.   Serial.println("son_val :");
  239.   Serial.print(son_val);
  240.  
  241.   // Boucle pour faire flasher les DEL dans un sens si la valeur reçue en A1 est entre 300 et 500
  242.   if (senschenillard <= 500) {
  243.     for (byte i = 6 ; i <= 13 ; i++) {
  244.       digitalWrite (i, HIGH) ; // allume la DEL sur broche i
  245.       tone(3, son_val);
  246.       delay (tempochenillard) ; // durée du flash
  247.       noTone(3);
  248.       digitalWrite (i, LOW) ; // éteint la DEL
  249.     }
  250.   }
  251.  
  252.   // Boucle pour faire flasher les DEL dans un autre sens si la valeur reçue en A1 > 650
  253.   if (senschenillard > 500) {
  254.     for (byte i = 13 ; i >= 6 ; i--) {
  255.       digitalWrite (i, HIGH) ; // allume la DEL sur broche i
  256.       tone(3, son_val);
  257.       delay (tempochenillard) ; // durée du flash 50 millisecondes
  258.       noTone(3);
  259.       digitalWrite (i, LOW) ; // éteint la DEL
  260.     }
  261.   }
  262.   delay (500) ;   // Pause de 500 millisecondes
  263.  
  264.   EtatBouton = digitalRead(Bouton);     // On relis la valeur du bouton poussoir
  265.   if (EtatBouton == HIGH) {           // Si appui, on retourne au programme init
  266.     Serial.println("GO TO PROGRAMME INIT");
  267.     noTone(3);            // On coupe le son du buzzer, HP connecté en broche 3
  268.     programmeinit(val1, val2, val3, val4, val5);
  269.   }
  270.   else {          // Sinon, on reste sur le programme 1
  271.     Serial.println("programme1");
  272.     programme1(val1, val2, val3, val4, val5);
  273.   }
  274. }
  275.  
  276. /////////////////////////////////////////////////////////////
  277. //Programme 2 Tableau booléen
  278. /////////////////////////////////////////////////////////////
  279. void programme2(int val1, int val2, int val3, int val4, int val5) {
  280.  
  281.   int ledPin[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Tableau listant les pins
  282.   boolean affichage[15][8] = {      // Tableau à double entrée listant l’état (booléen 1 allumé, 0 éteint) des LED à chaque séquence
  283.     {1, 1, 0, 0, 1, 1, 0, 0},
  284.     {0, 1, 0, 0, 0, 0 , 1 , 0},
  285.     {0, 0, 1, 0, 0, 1, 0, 0},
  286.     {0, 0, 0, 1, 1, 0, 0, 0},
  287.     {0, 1, 1, 0, 0, 1, 1, 0},
  288.     {0, 0, 1, 1, 1, 1, 0, 0},
  289.     {0, 1, 1, 0, 0, 1, 1, 0},
  290.     {1, 1, 0, 0, 0, 0, 1, 1},
  291.     {1, 1, 0, 1, 1, 0, 1, 1},
  292.     {0, 1, 1, 1, 1, 1, 1, 0},
  293.     {1, 1, 1, 1, 0, 0, 0, 0},
  294.     {0, 0, 0, 0, 1, 1, 1, 1},
  295.     {1, 0, 1, 0, 1, 0, 0, 1},
  296.     {0, 1, 0, 1, 0, 1, 0, 1},
  297.     {1, 1, 1, 1, 1, 1, 1, 1},
  298.   };
  299.  
  300.   // on lit les valeurs des entrées analogqiues
  301.   val1 = analogRead(A1); //
  302.   val2 = analogRead(A2); // tempo
  303.   val3 = analogRead(A3); // sens tableau
  304.   val4 = analogRead(A4); //
  305.   val5 = analogRead(A5); // note son
  306.  
  307.   int senstableau = val3;
  308.   Serial.print("senstableau :");
  309.   Serial.print(senstableau);
  310.   int tempo = map (val2, 0, 1024, 0, 1000);
  311.   Serial.print("\t tempo :");
  312.   Serial.println(tempo);
  313.  
  314.   int son_val = map (val5, 0, 1023, 100, 440);
  315.   Serial.println("son_val :");
  316.   Serial.print(son_val);
  317.  
  318.  
  319.   // Boucle pour flasher toutes les DEL selon le tableau si la valeur reçue en A1<300 ou si A1>700
  320.   if ((senstableau< 300) | (senstableau > 700)) {
  321.     for (int i = 0; i < 15; i++) // boucle de séquence d'affichage
  322.     {
  323.       for (int p = 0; p < 8; p++) // boucle pour chaque pin
  324.       {
  325.         boolean etat = affichage[i][p]; // on va chercher l'état pour le pin
  326.         digitalWrite(ledPin[p], etat); // on met le pin concerné à l'état
  327.         tone(3, son_val);
  328.         delay(tempo);
  329.       }
  330.       noTone(3);
  331.       //tous les pins sont dans l'état de la séquence en cours
  332.     }
  333.   }
  334.  
  335.   // Boucle pour faire flasher les DEL dans un sens si la valeur reçue en A1 est entre 300 et 500
  336.   if ((senstableau >= 300) && (senstableau <= 500) | (senstableau > 500) && (senstableau <= 700)) {
  337.     for (int i = 15; i > 0; i--) // boucle de séquence d'affichage
  338.     {
  339.       for (int p = 8; p > 0; p--) // boucle pour chaque pin
  340.       {
  341.         boolean etat = affichage[i][p]; // on va chercher l'état pour le pin
  342.         digitalWrite(ledPin[p], etat); // on met le pin concerné à l'état
  343.         tone(3, son_val);
  344.         delay(tempo);
  345.       }
  346.       noTone(3);
  347.       //tous les pins sont dans l'état de la séquence en cours
  348.     }
  349.   }
  350.  
  351.   delay (500) ;   // Pause de 500 millisecondes
  352.  
  353.  
  354.   //Ligne ci-dessous pour ne pas rester dans ce programme
  355.   EtatBouton = digitalRead(Bouton);   // On relis la valeur du bouton poussoir
  356.   if (EtatBouton == HIGH) {           // Si appui, on retourne au programme init
  357.     Serial.println("GO TO PROGRAMME INIT");
  358.     noTone(3);                        // On coupe le son du buzzer, HP connecté en broche 3
  359.     programmeinit(val1, val2, val3, val4, val5);
  360.   }
  361.   else {      // Sinon, on reste sur le programme 0
  362.     Serial.println("programme2");
  363.     programme2(val1, val2, val3, val4, val5);
  364.   }
  365. }
  366.  
  367. /////////////////////////////////////////////////////////////
  368. //Programme 3 Chenillard + Tableau booléen
  369. /////////////////////////////////////////////////////////////
  370. void programme3(int val1, int val2, int val3, int val4, int val5) {
  371.  
  372.   int ledPin[8] = {6, 7, 8, 9, 10, 11, 12, 13}; // Tableau listant les pins
  373.   boolean affichage[15][8] = {      // Tableau à double entrée listant l’état (booléen 1 allumé, 0 éteint) des LED à chaque séquence
  374.     {1, 1, 0, 0, 1, 1, 0, 0},
  375.     {0, 1, 0, 0, 0, 0 , 1 , 0},
  376.     {0, 0, 1, 0, 0, 1, 0, 0},
  377.     {0, 0, 0, 1, 1, 0, 0, 0},
  378.     {0, 1, 1, 0, 0, 1, 1, 0},
  379.     {0, 0, 1, 1, 1, 1, 0, 0},
  380.     {0, 1, 1, 0, 0, 1, 1, 0},
  381.     {1, 1, 0, 0, 0, 0, 1, 1},
  382.     {1, 1, 0, 1, 1, 0, 1, 1},
  383.     {0, 1, 1, 1, 1, 1, 1, 0},
  384.     {1, 1, 1, 1, 0, 0, 0, 0},
  385.     {0, 0, 0, 0, 1, 1, 1, 1},
  386.     {1, 0, 1, 0, 1, 0, 0, 1},
  387.     {0, 1, 0, 1, 0, 1, 0, 1},
  388.     {1, 1, 1, 1, 1, 1, 1, 1},
  389.   };
  390.  
  391.   // on lit les valeurs des entrées analogqiues
  392.   val1 = analogRead(A1); // sens chenillard
  393.   val2 = analogRead(A2); // note son
  394.   val3 = analogRead(A3);
  395.   val4 = analogRead(A4); // tempo chenillard
  396.   val5 = analogRead(A5);
  397.  
  398.   int senschenillard = val1;
  399.   Serial.print("senschenillard :");
  400.   Serial.print(senschenillard);
  401.   int tempochenillard = map (val4, 0, 1024, 0, 1000);
  402.   Serial.print("\t tempo :");
  403.   Serial.println(tempochenillard);
  404.  
  405.   int son_val = map (val2, 0, 1023, 100, 440);
  406.   Serial.println("son_val :");
  407.   Serial.print(son_val);
  408.  
  409.  
  410.   // Boucle pour flasher toutes les DEL selon le tableau si la valeur reçue en A1<300 ou si A1>700
  411.   if ((senschenillard < 300) | (senschenillard > 700)) {
  412.     for (int i = 0; i < 15; i++) // boucle de séquence d'affichage
  413.     {
  414.       for (int p = 0; p < 8; p++) // boucle pour chaque pin
  415.       {
  416.         boolean etat = affichage[i][p]; // on va chercher l'état pour le pin
  417.         digitalWrite(ledPin[p], etat); // on met le pin concerné à l'état
  418.         tone(3, son_val);
  419.       }
  420.       noTone(3);
  421.       //tous les pins sont dans l'état de la séquence en cours
  422.       delay(500); //petite pause d'affichage en fonction de la valeur lue sur A2
  423.     }
  424.   }
  425.  
  426.   // Boucle pour faire flasher les DEL dans un sens si la valeur reçue en A1 est entre 300 et 500
  427.   if ((senschenillard >= 300) && (senschenillard <= 500)) {
  428.     for (byte i = 6 ; i <= 13 ; i++) {
  429.       digitalWrite (i, HIGH) ; // allume la DEL sur broche i
  430.       tone(3, son_val);
  431.       delay (tempochenillard) ; // durée du flash
  432.       noTone(3);
  433.       digitalWrite (i, LOW) ; // éteint la DEL
  434.     }
  435.   }
  436.  
  437.   // Boucle pour faire flasher les DEL dans un autre sens si la valeur reçue en A1 > 650
  438.   if ((senschenillard > 500) && (senschenillard <= 700)) {
  439.     for (byte i = 13 ; i >= 6 ; i--) {
  440.       digitalWrite (i, HIGH) ; // allume la DEL sur broche i
  441.       tone(3, son_val);
  442.       delay (tempochenillard) ; // durée du flash 50 millisecondes
  443.       noTone(3);
  444.       digitalWrite (i, LOW) ; // éteint la DEL
  445.     }
  446.   }
  447.   delay (500) ;   // Pause de 500 millisecondes
  448.  
  449.   //Ligne ci-dessous pour ne pas rester dans ce programme
  450.   EtatBouton = digitalRead(Bouton);   // On relis la valeur du bouton poussoir
  451.   if (EtatBouton == HIGH) {           // Si appui, on retourne au programme init
  452.     Serial.println("GO TO PROGRAMME INIT");
  453.     noTone(3);                        // On coupe le son du buzzer, HP connecté en broche 3
  454.     programmeinit(val1, val2, val3, val4, val5);
  455.   }
  456.   else {      // Sinon, on reste sur le programme 0
  457.     Serial.println("programme3");
  458.     programme3(val1, val2, val3, val4, val5);
  459.   }
  460. }
  461.  
  462. /////////////////////////////////////////////////////////////
  463. //Programme 4
  464. /////////////////////////////////////////////////////////////
  465. void programme4(int val1, int val2, int val3, int val4, int val5) {
  466.   // ICI, je mets mon nouveau programme
  467.  
  468.   //Ligne ci-dessous pour ne pas rester dans ce programme
  469.   EtatBouton = digitalRead(Bouton);   // On relis la valeur du bouton poussoir
  470.   if (EtatBouton == HIGH) {           // Si appui, on retourne au programme init
  471.     Serial.println("GO TO PROGRAMME INIT");
  472.     noTone(3);                        // On coupe le son du buzzer, HP connecté en broche 3
  473.     programmeinit(val1, val2, val3, val4, val5);
  474.   }
  475.   else {      // Sinon, on reste sur le programme 0
  476.     Serial.println("programme3");
  477.     programme3(val1, val2, val3, val4, val5);
  478.   }
  479. }
RAW Paste Data
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
Top