PAPIFAB 2024-2025 : Différence entre versions

De Les Fabriques du Ponant
Aller à : navigation, rechercher
(PAPIFAB 17 octobre 2024 - ESCAPE GAME 1)
(potentiometre lineaire et bandeau de LED sur arduino UNO)
 
(10 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 6 : Ligne 6 :
 
* [https://numeriqueabrest.gogocarto.fr/map#/carte/@48.398,-4.496,14z?cat=all@fg137fd La carte des PAPI ]
 
* [https://numeriqueabrest.gogocarto.fr/map#/carte/@48.398,-4.496,14z?cat=all@fg137fd La carte des PAPI ]
 
* [http://www.a-brest.net/article17209.html Présentation du projet sur a-Brest]
 
* [http://www.a-brest.net/article17209.html Présentation du projet sur a-Brest]
 +
==PAPIFAB 14 novembre 2024 - ESCAPE GAME 2 ==
 +
/!\ les feuillles de présence !
 +
 +
Au programme : fabrication de dispositifs énigmlatiques numériques :
 +
* Fausse Bombe à retardement
 +
* console de potentiomètres linéaires
 +
 +
https://mypads2.framapad.org/p/papifab-2425-bm3f979m5
 +
 +
==codes==
 +
===Afficheur LED 4 digit display avec ESP32===
 +
<syntaxhighlight lang="Arduino" line>
 +
/* compte à rebours pour ESP32 ça marche !
 +
afficher 4 digitledDisplay
 +
source : https://www.instructables.com/Countdown-TimerMinutes-and-Seconds-With-Arduino-an/
 +
 +
*/
 +
#include <TM1637Display.h>
 +
 +
 +
// Countdown Timer
 +
const unsigned long COUNTDOWN_TIME = 300; // 5 minutes in seconds
 +
 +
 +
// Pins for TM1637 display module
 +
#define CLK_PIN 26
 +
#define DIO_PIN 27
 +
 +
 +
TM1637Display display(CLK_PIN, DIO_PIN);
 +
 +
 +
unsigned long startTime;
 +
unsigned long currentTime;
 +
unsigned long elapsedTime;
 +
 +
 +
void setup() {
 +
  display.setBrightness(7); // Set the brightness of the display (0-7)
 +
  display.clear(); // Clear the display
 +
  startTime = millis(); // Record the starting time
 +
}
 +
 +
 +
void loop() {
 +
  currentTime = millis(); // Get the current time
 +
  elapsedTime = (currentTime - startTime) / 1000; // Calculate elapsed time in seconds
 +
 +
 +
  if (elapsedTime <= COUNTDOWN_TIME) {
 +
    unsigned long remainingTime = COUNTDOWN_TIME - elapsedTime;
 +
 +
 +
    // Display remaining time in Minutes:Seconds format
 +
    unsigned int minutes = remainingTime / 60;
 +
    unsigned int seconds = remainingTime % 60;
 +
    display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
 +
 +
 +
    if (remainingTime == 0) {
 +
      // Start blinking when countdown reaches 00:00
 +
      while (true) {
 +
        display.showNumberDecEx(0, 0b01000000, true); // Display "00:00"
 +
        delay(500);
 +
        display.clear(); // Clear the display
 +
        delay(500);
 +
      }
 +
    }
 +
  }
 +
 +
 +
  delay(1000); // Wait for 1 second
 +
}
 +
</syntaxhighlight>
 +
 +
===afficheur LED - 4 digit display avec D1 mini===
 +
<syntaxhighlight lang="Arduino" line>
 +
/*
 +
Lolin (Wemos) D1 mini
 +
                                   
 +
                                _________________
 +
                              /    D1 mini    \
 +
                              |[ ]RST        TX[ ]|
 +
                              |[ ]A0  -GPIO  RX[ ]|
 +
                            - |[X]D0-16    5-D1[X]| SCL
 +
                        SCK - |[ ]D5-14    4-D2[X]| SDA
 +
            CLK_PIN - MISO - |[X]D6-12    0-D3[X]|
 +
            DIO_PIN - MOSI - |[X]D7-13    2-D4[ ]| LED_BUILTIN
 +
                        SS - |[ ]D8-15    GND[X]|
 +
                              |[X]3V3        5V[ ]|
 +
                              |      +---+      |
 +
                              |_______|USB|_______|
 +
 +
 +
 +
  _______________________________________________________
 +
  |(O)    _____      _____      _____      _____    (O)|
 +
  |      |\\___//|  |\\___//|  |\\___//|  |\\___//|      |
 +
  |[ ]CLK| |  | |  | |  | |  | |  | |  | |  | |CLK[X]|- vers D6
 +
  |[ ]DIO|//---\\|  |//---\\| o |//---\\|  |//---\\|DIO[X]|- vers D7
 +
  |[ ]GND|\\---//|  |\\---//| o |\\---//|  |\\---//|GND[X]|- vers GND
 +
  |[ ]5V | |___| |  | |___| |  | |___| |  | |___| | 5V[X]|- vers 3V3
 +
  |      |//___\\|o |//___\\|o  |//___\\|o |//___\\|o    |
 +
  |(O)_________________________________________________(O)|
 +
 +
Matériel :
 +
 +
    ___
 +
  / ___ \
 +
|_|  | |
 +
      /_/
 +
      _  ___  _
 +
    |_| |___|_| |_
 +
          ___|_  _|
 +
        |___| |_|
 +
  Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 +
  Antony Le Goïc-Auffret Août 2024
 +
*/
 +
#include <TM1637Display.h>
 +
// Broches pour le module TM1637 (afficheur 4 chiffre à leds 7 segments)
 +
#define CLK_PIN D6
 +
#define DIO_PIN D7
 +
TM1637Display display(CLK_PIN, DIO_PIN);
 +
 +
const unsigned long COUNTDOWN_TIME = 300; // 5 minutes in seconds
 +
 +
unsigned long startTime;
 +
unsigned long currentTime;
 +
unsigned long elapsedTime;
 +
 +
 +
void setup() {
 +
  // put your setup code here, to run once:
 +
  Serial.begin(9600);
 +
  display.setBrightness(7); // luminosité de l'afficheur (0-7)
 +
  display.clear(); // effacer l'afficheur
 +
  startTime = millis(); // Record the starting time
 +
}
 +
 +
void loop() {
 +
  currentTime = millis(); // Get the current time
 +
  elapsedTime = (currentTime - startTime) / 1000; // Calculate elapsed time in seconds
 +
 +
 +
  if (elapsedTime <= COUNTDOWN_TIME) {
 +
    unsigned long remainingTime = COUNTDOWN_TIME - elapsedTime;
 +
 +
 +
    // Display remaining time in Minutes:Seconds format
 +
    unsigned int minutes = remainingTime / 60;
 +
    unsigned int seconds = remainingTime % 60;
 +
    display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
 +
 +
 +
    if (remainingTime == 0) {
 +
      // Start blinking when countdown reaches 00:00
 +
      while (true) {
 +
        display.showNumberDecEx(0, 0b01000000, true); // Display "00:00"
 +
        delay(500);
 +
        display.clear(); // Clear the display
 +
        delay(500);
 +
      }
 +
    }
 +
  }
 +
 +
 +
  delay(1000); // Wait for 1 second
 +
}
 +
 +
 +
</syntaxhighlight>
 +
 +
===Bombe à retardement avec ESP32===
 +
 +
<syntaxhighlight lang="Arduino" line>
 +
/* compte à rebours
 +
révision 17102024
 +
afficher 4 digitledDisplay
 +
source d'infos : https://www.instructables.com/Countdown-TimerMinutes-and-Seconds-With-Arduino-an/
 +
 +
ESP32 à 30 broches
 +
                    _______________________
 +
                    |(O) ESP32-devKit V1 (O)|
 +
                    |    WIFI-BLUETOOTH    |
 +
                    |      30 broches      |
 +
                    |[ ]EN        23-D23[ ]|
 +
                    |[ ]VP-36      22-D22[ ]|
 +
                    |[ ]VN-39      1-TXo[ ]|
 +
                    |[ ]D34-34      3-RXo[ ]|
 +
                    |[ ]D35-35    21-D21[ ]|
 +
GND-accélération CàR-|[X]D32-32r    19-D19[ ]|
 +
      GND-Désamorce-|[X]D33-33r    18-D18[ ]|
 +
                    -|[ ]D25-25r    r5-D5[ ]|
 +
      Afficheur CLK-|[X]D26-26r    17-TX2[ ]|
 +
      Afficheur DIO-|[X]D27-27r    16-RX2[ ]|
 +
                    |[ ]D14-14r    r4-D4[ ]|
 +
              Piezo-|[X]D12-12r      2-D2[ ]|
 +
GND-Lancement du CàR-|[X]D13-13r  r15-D15[ ]|
 +
                    |[X]GND          GND[ ]|
 +
                    |[ ]VIN          3V3[X]| /!\ Alim Afficheur + piezo
 +
                    |  EN            Boot  |
 +
                    |(O)[o]  +---+  [o](O)|
 +
                    |_________|USB|_________| r pour résistances interne (PULLUP ou PULLDOWN).
 +
 +
      ____
 +
    /  (o) \
 +
    |\______/|
 +
    |  Piezo |
 +
    \______/
 +
      |    |
 +
      +    -
 +
      12  GND
 +
 +
 +
  _______________________________________________________
 +
  |(O)    _____      _____      _____      _____    (O)|
 +
  |      |\\___//|  |\\___//|  |\\___//|  |\\___//|      |
 +
  |[ ]CLK| |  | |  | |  | |  | |  | |  | |  | |CLK[X]|- vers D26
 +
  |[ ]DIO|//---\\|  |//---\\| o |//---\\|  |//---\\|DIO[X]|- vers D27
 +
  |[ ]GND|\\---//|  |\\---//| o |\\---//|  |\\---//|GND[X]|- vers GND
 +
  |[ ]5V | |___| |  | |___| |  | |___| |  | |___| | 5V[X]|- vers 3V3
 +
  |      |//___\\|o |//___\\|o  |//___\\|o |//___\\|o    |
 +
  |(O)_________________________________________________(O)|
 +
 +
Matériel :
 +
 +
    ___
 +
  / ___ \
 +
|_|  | |
 +
      /_/
 +
      _  ___  _
 +
    |_| |___|_| |_
 +
          ___|_  _|
 +
        |___| |_|
 +
  Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 +
  Antony Le Goïc-Auffret Août 2024
 +
*/
 +
#include <TM1637Display.h>
 +
 +
 +
// Compte à rebours
 +
const unsigned long COUNTDOWN_TIME = 600; // 10 minutes en secondes
 +
unsigned long tempsPrecedent = 0;
 +
int vitesse = 1000;
 +
 +
//Fil
 +
int brocheFilAcc = 32; //GPIO32
 +
int brocheFilStop = 33;//GPIO33
 +
bool stop = LOW;
 +
 +
//piezo
 +
int piezo = 12; // GPIO12
 +
unsigned long tempsPrecedentPiezo = 0;
 +
// démarrage
 +
int brocheLancement = 13; // GPIO13
 +
bool demarre = 0;
 +
 +
// Broches pour le module TM1637 (afficheur 4 chiffre à leds 7 segments)
 +
#define CLK_PIN 26
 +
#define DIO_PIN 27
 +
 +
 +
TM1637Display display(CLK_PIN, DIO_PIN);
 +
 +
 +
unsigned long tempsDemarrage;
 +
unsigned long tempsT;
 +
unsigned long tempsEcoule;
 +
 +
 +
void setup() {
 +
  Serial.begin(57600);
 +
  display.setBrightness(3); // luminosité de l'afficheur (0-7)
 +
  display.clear(); // effacer l'afficheur
 +
  tempsDemarrage = millis(); // stocker la valeur du temps au démarrage
 +
 
 +
 +
  pinMode(brocheFilAcc,INPUT_PULLUP);
 +
  pinMode(brocheFilStop,INPUT_PULLUP);
 +
  pinMode(brocheLancement,INPUT_PULLUP);
 +
  pinMode(piezo,OUTPUT);
 +
  demarre = digitalRead(brocheLancement);
 +
}
 +
 +
 +
void loop() {
 +
  if (demarre==0){ // teste si
 +
  Serial.print("état démarre : "); Serial.println(demarre);
 +
  demarre = digitalRead(brocheLancement);
 +
  tempsDemarrage = millis(); // stocker la valeur du temps au démarrage
 +
  }
 +
  else {
 +
  Serial.print("état démarre : "); Serial.println(demarre);
 +
  tempsT = millis(); // récupérer la valuer du temps au temps "t"
 +
  tempsEcoule = (tempsT - tempsDemarrage) / vitesse; // Calculer le temps écoulé en secondes.
 +
 +
  //gestion du bip
 +
  if((tempsT-tempsPrecedentPiezo)>50){
 +
    digitalWrite(piezo,LOW); // éteint le buzzer
 +
    Serial.println("état piezo : éteint"); 
 +
  }
 +
 +
  Serial.println(tempsEcoule);
 +
 
 +
  bool coupeAcc = digitalRead(brocheFilAcc);
 +
  bool coupeStop = digitalRead(brocheFilStop);
 +
  Serial.println(coupeAcc);
 +
  Serial.println(vitesse);
 +
 +
  if (coupeAcc == HIGH) { // contrôle du mauvais fil
 +
    vitesse=100;
 +
    Serial.print(coupeAcc);
 +
    Serial.println(vitesse);
 +
    }
 +
 +
  if (coupeStop == HIGH) { // contrôle du fil qui arrête la bombe
 +
    stop=1;
 +
    Serial.print(coupeStop);
 +
    }
 +
  if (stop == 0){ // le compte à rebours fonctionne normalement tant que le fil n'est pas coupé
 +
  if((tempsT-tempsPrecedent)>=vitesse){
 +
  digitalWrite(piezo,HIGH); // allume le buzzer
 +
  tempsPrecedentPiezo = millis(); tempsPrecedent = millis();
 +
  if (tempsEcoule <= COUNTDOWN_TIME) {
 +
    unsigned long remainingTime = COUNTDOWN_TIME - tempsEcoule;
 +
 +
 +
    // affiche le temps restant en format Minutes:Secondes
 +
    unsigned int minutes = remainingTime / 60;
 +
    unsigned int seconds = remainingTime % 60;
 +
    display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
 +
 +
 +
    if (remainingTime == 0) {
 +
      // clignote lorsque le temps arrive à 00:00
 +
      digitalWrite(piezo,LOW); // éteint le buzzer
 +
      while (true) {
 +
        display.showNumberDecEx(0, 0b01000000, true); // affiche "00:00"
 +
        delay(500);
 +
        display.clear(); // vide l'afficheur
 +
        delay(500);
 +
      }
 +
    }
 +
  }
 +
  }
 +
  }
 +
 +
  if (stop==1){
 +
          // clignote avec la valeur de temps qu'il y a au moment ou le fil est coupé
 +
      digitalWrite(piezo,LOW); // éteint le buzzer
 +
      while (true) {
 +
        unsigned long remainingTime = COUNTDOWN_TIME - tempsEcoule;
 +
        // affiche le temps restant en format Minutes:Secondes
 +
        unsigned int minutes = remainingTime / 60;
 +
        unsigned int seconds = remainingTime % 60;
 +
        display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true); // affiche le temps
 +
        delay(500);
 +
        display.clear(); // vide l'afficheur
 +
        delay(500);
 +
      }
 +
  }
 +
}
 +
}
 +
</syntaxhighlight>
 +
 +
==codes==
 +
===potentiometre lineaire sur esp32===
 +
<syntaxhighlight lang="Arduino" line>
 +
// Déclaration de la broche du potentiomètre
 +
const int potPin = 34; // Utilisation de la broche ADC1 pour ESP32
 +
 +
// Variable pour stocker la valeur lue
 +
int potValue = 0;
 +
 +
void setup() {
 +
  // Initialisation de la communication série pour l'affichage des valeurs
 +
  Serial.begin(115200);
 +
}
 +
 +
void loop() {
 +
  // Lecture de la valeur du potentiomètre
 +
  potValue = analogRead(potPin);
 +
  // Affichage de la valeur lue sur le moniteur série
 +
 +
  Serial.println(potValue);
 +
 
 +
  // Petite pause avant de lire la valeur suivante
 +
  delay(100);
 +
}
 +
</syntaxhighlight>
 +
 +
 +
===potentiometre lineaire et bandeau de LED sur arduino UNO===
 +
<syntaxhighlight lang="Arduino" line>
 +
#include <Adafruit_NeoPixel.h>
 +
 +
#define LED_PIN    6  // Broche à laquelle le ruban LED est connecté
 +
#define NUM_LEDS  48  // Nombre de LEDs dans le ruban
 +
#define POT_PIN    A0  // Broche à laquelle le potentiomètre est connecté
 +
 +
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
 +
 +
void setup() {
 +
  strip.begin();
 +
  strip.show();  // Initialise toutes les LEDs à "off"
 +
  Serial.begin(9600);
 +
}
 +
 +
void loop() {
 +
  int potValue = analogRead(POT_PIN);  // Lecture de la valeur du potentiomètre
 +
  int colorValue = map(potValue, 0, 710, 0, 255);  // Conversion de la valeur en une plage de 0 à 255
 +
 +
  // Détermination de la couleur en fonction de la valeur du potentiomètre
 +
  int red = colorValue;
 +
  int green = 255 - colorValue;
 +
  int blue = (colorValue / 4);
 +
 +
  // Application de la couleur sur toutes les LEDs
 +
  for(int i=0; i<strip.numPixels(); i++) {
 +
    strip.setPixelColor(i, strip.Color(red, green, blue));
 +
  }
 +
  strip.show();  // Mise à jour du ruban LED
 +
 +
  delay(100);  // Petite pause avant la lecture suivante
 +
}
 +
 +
</syntaxhighlight>
 +
 +
----ATTENTION ----
 +
il faut penser a mettre a jour la bibliotheque adafruit , de bien compter le nombre de led et d'alimenter le potentiometre en 3,3V et le ruban de led en 5V
 +
 +
==code==
 +
===potentiometre lineaire et bandeau de LED sur wemos D1 mini===
 +
<syntaxhighlight lang="Arduino" line>
 +
 +
#include <Adafruit_NeoPixel.h>
 +
 +
#define LED_PIN    D5  // Broche à laquelle le ruban LED est connecté
 +
#define NUM_LEDS  15  // Nombre de LEDs dans le ruban
 +
#define POT_PIN    A0  // Broche à laquelle le potentiomètre est connecté
 +
#define BRIGHTNESS 50  // Luminosité (0-255)
 +
 +
// Création de l'objet NeoPixel
 +
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
 +
 +
void setup() {
 +
  strip.begin();
 +
  strip.setBrightness(BRIGHTNESS);  // Ajustement de la luminosité
 +
  strip.show();  // Initialise toutes les LEDs à "off"
 +
  Serial.begin(115200);
 +
}
 +
 +
void loop() {
 +
  int potValue = analogRead(POT_PIN);  // Lecture de la valeur du potentiomètre
 +
  int mappedValue = map(potValue, 0, 1024, 0, 1530);  // Conversion de la valeur en une plage de 0 à 1530
 +
 +
  int red = 0, green = 0, blue = 0;
 +
 +
  if (mappedValue < 510) {
 +
    // Vert à Bleu
 +
    green = 255 - (mappedValue % 510);
 +
    blue = mappedValue % 510;
 +
  } else if (mappedValue < 1020) {
 +
    // Bleu à Rouge
 +
    blue = 255 - (mappedValue % 510);
 +
    red = mappedValue % 510;
 +
  } else {
 +
    // Rouge à Vert
 +
    red = 255 - (mappedValue % 510);
 +
    green = mappedValue % 510;
 +
  }
 +
 +
  // Application de la couleur sur toutes les LEDs
 +
  for (int i = 0; i < strip.numPixels(); i++) {
 +
    strip.setPixelColor(i, strip.Color(red, green, blue));
 +
  }
 +
  strip.show();  // Mise à jour du ruban LED
 +
Serial.println(potValue);
 +
  delay(100);  // Petite pause avant la lecture suivante
 +
}
 +
 +
==codes==
 +
===potentiometre lineaire sur arduino===
 +
<syntaxhighlight lang="Arduino" line>
 +
// Déclaration de la broche du potentiomètre
 +
const int potPin = A0;
 +
 +
// Variable pour stocker la valeur lue
 +
int potValue = 0;
 +
 +
void setup() {
 +
  // Initialisation de la communication série pour l'affichage des valeurs
 +
  Serial.begin(9600);
 +
}
 +
 +
void loop() {
 +
  // Lecture de la valeur du potentiomètre
 +
  potValue = analogRead(potPin);
 +
 
 +
  // Affichage de la valeur lue sur le moniteur série
 +
  Serial.println(potValue);
 +
 
 +
  // Petite pause avant de lire la valeur suivante
 +
  delay(100);
 +
}
 +
 +
</syntaxhighlight>
  
 
==PAPIFAB 17 octobre 2024 - ESCAPE GAME 1==
 
==PAPIFAB 17 octobre 2024 - ESCAPE GAME 1==

Version actuelle datée du 14 novembre 2024 à 11:36

PAPIFAB est un projet de la ville Brest.

Logo Brest metropole ville P blanc.jpg BC2017.png

PAPIFAB 14 novembre 2024 - ESCAPE GAME 2

/!\ les feuillles de présence !

Au programme : fabrication de dispositifs énigmlatiques numériques :

  • Fausse Bombe à retardement
  • console de potentiomètres linéaires

https://mypads2.framapad.org/p/papifab-2425-bm3f979m5

codes

Afficheur LED 4 digit display avec ESP32

 1 /* compte à rebours pour ESP32 ça marche !
 2 afficher 4 digitledDisplay
 3 source : https://www.instructables.com/Countdown-TimerMinutes-and-Seconds-With-Arduino-an/
 4 
 5 */
 6 #include <TM1637Display.h>
 7 
 8 
 9 // Countdown Timer
10 const unsigned long COUNTDOWN_TIME = 300; // 5 minutes in seconds
11 
12 
13 // Pins for TM1637 display module
14 #define CLK_PIN 26
15 #define DIO_PIN 27
16 
17 
18 TM1637Display display(CLK_PIN, DIO_PIN);
19 
20 
21 unsigned long startTime;
22 unsigned long currentTime;
23 unsigned long elapsedTime;
24 
25 
26 void setup() {
27   display.setBrightness(7); // Set the brightness of the display (0-7)
28   display.clear(); // Clear the display
29   startTime = millis(); // Record the starting time
30 }
31 
32 
33 void loop() {
34   currentTime = millis(); // Get the current time
35   elapsedTime = (currentTime - startTime) / 1000; // Calculate elapsed time in seconds
36 
37 
38   if (elapsedTime <= COUNTDOWN_TIME) {
39     unsigned long remainingTime = COUNTDOWN_TIME - elapsedTime;
40 
41 
42     // Display remaining time in Minutes:Seconds format
43     unsigned int minutes = remainingTime / 60;
44     unsigned int seconds = remainingTime % 60;
45     display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
46 
47 
48     if (remainingTime == 0) {
49       // Start blinking when countdown reaches 00:00
50       while (true) {
51         display.showNumberDecEx(0, 0b01000000, true); // Display "00:00"
52         delay(500);
53         display.clear(); // Clear the display
54         delay(500);
55       }
56     }
57   }
58 
59 
60   delay(1000); // Wait for 1 second
61 }

afficheur LED - 4 digit display avec D1 mini

 1 /*
 2 Lolin (Wemos) D1 mini
 3                                      
 4                                 _________________
 5                                /     D1 mini     \
 6                               |[ ]RST        TX[ ]|
 7                               |[ ]A0  -GPIO  RX[ ]|
 8                             - |[X]D0-16    5-D1[X]| SCL
 9                         SCK - |[ ]D5-14    4-D2[X]| SDA
10              CLK_PIN - MISO - |[X]D6-12    0-D3[X]|
11              DIO_PIN - MOSI - |[X]D7-13    2-D4[ ]| LED_BUILTIN
12                          SS - |[ ]D8-15     GND[X]|
13                               |[X]3V3        5V[ ]|
14                               |       +---+       |
15                               |_______|USB|_______|
16 
17 
18 
19    _______________________________________________________
20   |(O)     _____      _____       _____      _____     (O)|
21   |      |\\___//|  |\\___//|   |\\___//|  |\\___//|      |
22   |[ ]CLK| |   | |  | |   | |   | |   | |  | |   | |CLK[X]|- vers D6
23   |[ ]DIO|//---\\|  |//---\\| o |//---\\|  |//---\\|DIO[X]|- vers D7
24   |[ ]GND|\\---//|  |\\---//| o |\\---//|  |\\---//|GND[X]|- vers GND
25   |[ ]5V | |___| |  | |___| |   | |___| |  | |___| | 5V[X]|- vers 3V3 
26   |      |//___\\|o |//___\\|o  |//___\\|o |//___\\|o     |
27   |(O)_________________________________________________(O)| 
28 
29 Matériel :
30 
31     ___
32   / ___ \
33  |_|   | | 
34       /_/
35       _   ___   _
36      |_| |___|_| |_
37           ___|_   _|
38          |___| |_|
39   Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
40   Antony Le Goïc-Auffret Août 2024
41  */
42 #include <TM1637Display.h>
43 // Broches pour le module TM1637 (afficheur 4 chiffre à leds 7 segments)
44 #define CLK_PIN D6
45 #define DIO_PIN D7
46 TM1637Display display(CLK_PIN, DIO_PIN);
47 
48 const unsigned long COUNTDOWN_TIME = 300; // 5 minutes in seconds
49 
50 unsigned long startTime;
51 unsigned long currentTime;
52 unsigned long elapsedTime;
53 
54 
55 void setup() {
56   // put your setup code here, to run once:
57   Serial.begin(9600);
58   display.setBrightness(7); // luminosité de l'afficheur (0-7)
59   display.clear(); // effacer l'afficheur
60   startTime = millis(); // Record the starting time
61 }
62 
63 void loop() {
64   currentTime = millis(); // Get the current time
65   elapsedTime = (currentTime - startTime) / 1000; // Calculate elapsed time in seconds
66 
67 
68   if (elapsedTime <= COUNTDOWN_TIME) {
69     unsigned long remainingTime = COUNTDOWN_TIME - elapsedTime;
70 
71 
72     // Display remaining time in Minutes:Seconds format
73     unsigned int minutes = remainingTime / 60;
74     unsigned int seconds = remainingTime % 60;
75     display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
76 
77 
78     if (remainingTime == 0) {
79       // Start blinking when countdown reaches 00:00
80       while (true) {
81         display.showNumberDecEx(0, 0b01000000, true); // Display "00:00"
82         delay(500);
83         display.clear(); // Clear the display
84         delay(500);
85       }
86     }
87   }
88 
89 
90   delay(1000); // Wait for 1 second
91 }

Bombe à retardement avec ESP32

  1 /* compte à rebours 
  2 révision 17102024
  3 afficher 4 digitledDisplay
  4 source d'infos : https://www.instructables.com/Countdown-TimerMinutes-and-Seconds-With-Arduino-an/
  5 
  6 ESP32 à 30 broches
  7                     _______________________
  8                      |(O) ESP32-devKit V1 (O)|
  9                      |     WIFI-BLUETOOTH    |
 10                      |       30 broches      |
 11                      |[ ]EN         23-D23[ ]|
 12                      |[ ]VP-36      22-D22[ ]|
 13                      |[ ]VN-39       1-TXo[ ]|
 14                      |[ ]D34-34      3-RXo[ ]|
 15                      |[ ]D35-35     21-D21[ ]|
 16 GND-accélération CàR-|[X]D32-32r    19-D19[ ]|
 17        GND-Désamorce-|[X]D33-33r    18-D18[ ]|
 18                     -|[ ]D25-25r     r5-D5[ ]|
 19        Afficheur CLK-|[X]D26-26r    17-TX2[ ]|
 20        Afficheur DIO-|[X]D27-27r    16-RX2[ ]|
 21                      |[ ]D14-14r     r4-D4[ ]|
 22                Piezo-|[X]D12-12r      2-D2[ ]|
 23 GND-Lancement du CàR-|[X]D13-13r   r15-D15[ ]|
 24                      |[X]GND           GND[ ]|
 25                      |[ ]VIN           3V3[X]| /!\ Alim Afficheur + piezo
 26                      |   EN            Boot  |
 27                      |(O)[o]   +---+   [o](O)|
 28                      |_________|USB|_________| r pour résistances interne (PULLUP ou PULLDOWN).
 29 
 30        ____
 31      /  (o) \
 32     |\______/|
 33     |  Piezo |
 34      \______/
 35       |    |
 36       +    -
 37       12  GND
 38 
 39 
 40    _______________________________________________________
 41   |(O)     _____      _____       _____      _____     (O)|
 42   |      |\\___//|  |\\___//|   |\\___//|  |\\___//|      |
 43   |[ ]CLK| |   | |  | |   | |   | |   | |  | |   | |CLK[X]|- vers D26
 44   |[ ]DIO|//---\\|  |//---\\| o |//---\\|  |//---\\|DIO[X]|- vers D27
 45   |[ ]GND|\\---//|  |\\---//| o |\\---//|  |\\---//|GND[X]|- vers GND
 46   |[ ]5V | |___| |  | |___| |   | |___| |  | |___| | 5V[X]|- vers 3V3 
 47   |      |//___\\|o |//___\\|o  |//___\\|o |//___\\|o     |
 48   |(O)_________________________________________________(O)| 
 49 
 50 Matériel :
 51 
 52     ___
 53   / ___ \
 54  |_|   | | 
 55       /_/
 56       _   ___   _
 57      |_| |___|_| |_
 58           ___|_   _|
 59          |___| |_|
 60   Les petits Débrouillards - CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 61   Antony Le Goïc-Auffret Août 2024
 62  */
 63 #include <TM1637Display.h>
 64 
 65 
 66 // Compte à rebours
 67 const unsigned long COUNTDOWN_TIME = 600; // 10 minutes en secondes
 68 unsigned long tempsPrecedent = 0;
 69 int vitesse = 1000;
 70 
 71 //Fil
 72 int brocheFilAcc = 32; //GPIO32 
 73 int brocheFilStop = 33;//GPIO33 
 74 bool stop = LOW;
 75 
 76 //piezo
 77 int piezo = 12; // GPIO12
 78 unsigned long tempsPrecedentPiezo = 0;
 79 // démarrage
 80 int brocheLancement = 13; // GPIO13
 81 bool demarre = 0;
 82 
 83 // Broches pour le module TM1637 (afficheur 4 chiffre à leds 7 segments)
 84 #define CLK_PIN 26
 85 #define DIO_PIN 27
 86 
 87 
 88 TM1637Display display(CLK_PIN, DIO_PIN);
 89 
 90 
 91 unsigned long tempsDemarrage;
 92 unsigned long tempsT;
 93 unsigned long tempsEcoule;
 94 
 95 
 96 void setup() {
 97   Serial.begin(57600);
 98   display.setBrightness(3); // luminosité de l'afficheur (0-7)
 99   display.clear(); // effacer l'afficheur
100   tempsDemarrage = millis(); // stocker la valeur du temps au démarrage
101    
102 
103   pinMode(brocheFilAcc,INPUT_PULLUP);
104   pinMode(brocheFilStop,INPUT_PULLUP);
105   pinMode(brocheLancement,INPUT_PULLUP);
106   pinMode(piezo,OUTPUT);
107   demarre = digitalRead(brocheLancement);
108 }
109 
110 
111 void loop() {
112   if (demarre==0){ // teste si 
113   Serial.print("état démarre : "); Serial.println(demarre); 
114   demarre = digitalRead(brocheLancement);
115   tempsDemarrage = millis(); // stocker la valeur du temps au démarrage
116   }
117   else {
118   Serial.print("état démarre : "); Serial.println(demarre); 
119   tempsT = millis(); // récupérer la valuer du temps au temps "t"
120   tempsEcoule = (tempsT - tempsDemarrage) / vitesse; // Calculer le temps écoulé en secondes.
121 
122   //gestion du bip
123   if((tempsT-tempsPrecedentPiezo)>50){
124     digitalWrite(piezo,LOW); // éteint le buzzer
125     Serial.println("état piezo : éteint");   
126   }
127 
128   Serial.println(tempsEcoule);
129   
130   bool coupeAcc = digitalRead(brocheFilAcc);
131   bool coupeStop = digitalRead(brocheFilStop);
132   Serial.println(coupeAcc);
133   Serial.println(vitesse);
134 
135   if (coupeAcc == HIGH) { // contrôle du mauvais fil
136     vitesse=100;
137     Serial.print(coupeAcc);
138     Serial.println(vitesse);
139     }
140 
141   if (coupeStop == HIGH) { // contrôle du fil qui arrête la bombe
142     stop=1;
143     Serial.print(coupeStop);
144     }
145   if (stop == 0){ // le compte à rebours fonctionne normalement tant que le fil n'est pas coupé
146   if((tempsT-tempsPrecedent)>=vitesse){
147   digitalWrite(piezo,HIGH); // allume le buzzer
148   tempsPrecedentPiezo = millis(); tempsPrecedent = millis();
149   if (tempsEcoule <= COUNTDOWN_TIME) {
150     unsigned long remainingTime = COUNTDOWN_TIME - tempsEcoule;
151 
152 
153     // affiche le temps restant en format Minutes:Secondes 
154     unsigned int minutes = remainingTime / 60;
155     unsigned int seconds = remainingTime % 60;
156     display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true);
157 
158 
159     if (remainingTime == 0) {
160       // clignote lorsque le temps arrive à 00:00
161       digitalWrite(piezo,LOW); // éteint le buzzer
162       while (true) {
163         display.showNumberDecEx(0, 0b01000000, true); // affiche "00:00"
164         delay(500);
165         display.clear(); // vide l'afficheur
166         delay(500);
167       }
168     }
169   }
170   }
171   }
172 
173   if (stop==1){
174           // clignote avec la valeur de temps qu'il y a au moment ou le fil est coupé
175       digitalWrite(piezo,LOW); // éteint le buzzer
176       while (true) {
177         unsigned long remainingTime = COUNTDOWN_TIME - tempsEcoule;
178         // affiche le temps restant en format Minutes:Secondes
179         unsigned int minutes = remainingTime / 60;
180         unsigned int seconds = remainingTime % 60;
181         display.showNumberDecEx(minutes * 100 + seconds, 0b01000000, true); // affiche le temps
182         delay(500);
183         display.clear(); // vide l'afficheur
184         delay(500);
185       }
186   }
187 }
188 }

codes

potentiometre lineaire sur esp32

 1 // Déclaration de la broche du potentiomètre
 2 const int potPin = 34; // Utilisation de la broche ADC1 pour ESP32
 3 
 4 // Variable pour stocker la valeur lue
 5 int potValue = 0;
 6 
 7 void setup() {
 8   // Initialisation de la communication série pour l'affichage des valeurs
 9   Serial.begin(115200);
10 }
11 
12 void loop() {
13   // Lecture de la valeur du potentiomètre
14   potValue = analogRead(potPin);
15    // Affichage de la valeur lue sur le moniteur série
16  
17   Serial.println(potValue);
18   
19   // Petite pause avant de lire la valeur suivante
20   delay(100);
21 }


potentiometre lineaire et bandeau de LED sur arduino UNO

 1 #include <Adafruit_NeoPixel.h>
 2 
 3 #define LED_PIN    6  // Broche à laquelle le ruban LED est connecté
 4 #define NUM_LEDS   48  // Nombre de LEDs dans le ruban
 5 #define POT_PIN    A0  // Broche à laquelle le potentiomètre est connecté
 6 
 7 Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
 8 
 9 void setup() {
10   strip.begin();
11   strip.show();  // Initialise toutes les LEDs à "off"
12   Serial.begin(9600);
13 }
14 
15 void loop() {
16   int potValue = analogRead(POT_PIN);  // Lecture de la valeur du potentiomètre
17   int colorValue = map(potValue, 0, 710, 0, 255);  // Conversion de la valeur en une plage de 0 à 255
18 
19   // Détermination de la couleur en fonction de la valeur du potentiomètre
20   int red = colorValue;
21   int green = 255 - colorValue;
22   int blue = (colorValue / 4);
23 
24   // Application de la couleur sur toutes les LEDs
25   for(int i=0; i<strip.numPixels(); i++) {
26     strip.setPixelColor(i, strip.Color(red, green, blue));
27   }
28   strip.show();  // Mise à jour du ruban LED
29 
30   delay(100);  // Petite pause avant la lecture suivante
31 }

ATTENTION ----

il faut penser a mettre a jour la bibliotheque adafruit , de bien compter le nombre de led et d'alimenter le potentiometre en 3,3V et le ruban de led en 5V

code

potentiometre lineaire et bandeau de LED sur wemos D1 mini

 1 #include <Adafruit_NeoPixel.h>
 2 
 3 #define LED_PIN    D5  // Broche à laquelle le ruban LED est connecté
 4 #define NUM_LEDS   15  // Nombre de LEDs dans le ruban
 5 #define POT_PIN    A0  // Broche à laquelle le potentiomètre est connecté
 6 #define BRIGHTNESS 50  // Luminosité (0-255)
 7 
 8 // Création de l'objet NeoPixel
 9 Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
10 
11 void setup() {
12   strip.begin();
13   strip.setBrightness(BRIGHTNESS);  // Ajustement de la luminosité
14   strip.show();  // Initialise toutes les LEDs à "off"
15   Serial.begin(115200);
16 }
17 
18 void loop() {
19   int potValue = analogRead(POT_PIN);  // Lecture de la valeur du potentiomètre
20   int mappedValue = map(potValue, 0, 1024, 0, 1530);  // Conversion de la valeur en une plage de 0 à 1530
21 
22   int red = 0, green = 0, blue = 0;
23 
24   if (mappedValue < 510) {
25     // Vert à Bleu
26     green = 255 - (mappedValue % 510);
27     blue = mappedValue % 510;
28   } else if (mappedValue < 1020) {
29     // Bleu à Rouge
30     blue = 255 - (mappedValue % 510);
31     red = mappedValue % 510;
32   } else {
33     // Rouge à Vert
34     red = 255 - (mappedValue % 510);
35     green = mappedValue % 510;
36   }
37 
38   // Application de la couleur sur toutes les LEDs
39   for (int i = 0; i < strip.numPixels(); i++) {
40     strip.setPixelColor(i, strip.Color(red, green, blue));
41   }
42   strip.show();  // Mise à jour du ruban LED
43  Serial.println(potValue);
44   delay(100);  // Petite pause avant la lecture suivante
45 }
46 
47 ==codes==
48 ===potentiometre lineaire sur arduino===
49 <syntaxhighlight lang="Arduino" line>
50 // Déclaration de la broche du potentiomètre
51 const int potPin = A0;
52 
53 // Variable pour stocker la valeur lue
54 int potValue = 0;
55 
56 void setup() {
57   // Initialisation de la communication série pour l'affichage des valeurs
58   Serial.begin(9600);
59 }
60 
61 void loop() {
62   // Lecture de la valeur du potentiomètre
63   potValue = analogRead(potPin);
64   
65   // Affichage de la valeur lue sur le moniteur série
66   Serial.println(potValue);
67   
68   // Petite pause avant de lire la valeur suivante
69   delay(100);
70 }

PAPIFAB 17 octobre 2024 - ESCAPE GAME 1

Pour la séance deux :

  • Bombe : Damien, Brendan, Alex, Emmeline, Mathieu
  • Potards : Nadia, Josselin voir avec pro Micro !!

PAPIFAB-escapeGame-171024.JPG

PAPIFAB-escapeGame2-171024.JPG

PAPIFAB-escapeGame3-171024.JPG

Programme des PAPIFAB 2024-2025

  • Septembre : 19 - accueil forum des u-sages ! Spygeon, l'OSS117 de la vidéosurveillance !
  • Octobre : 17 ( car la semaine précédete c'est fête de la sience) - Escape Game 1/2
  • Novembre : 14 - Escape Game 2/2
  • Décembre : 19 - LEd et musique - des paillettes dans la vie !
  • Janvier : 9 - visite du CERV (sous réserve de confirmation)
  • Février : 6 - Expérimentation RV (casque au stang Alar, voir médiathèque).
  • Mars : 6 - IA et éducation.
  • Avril : 3 - Création et hébergement de site web. du html au CMS voir
  • Mai : 15 - fabrication lowtech et numérique - base de lancement à électrovannes
  • Juin : 12 - bilan et perspectives

Evénements dans le contexte

Septembre

  • Mi-septembre Date butoir de l'appel à projet Médiation et Usages du Numérique (AAP MUN) ? (à confirmer). les projets de l'an passé : https://www.a-brest.net/rubrique308.html
  • Mardi 17 septembre : Conférence Bastien Masse IA et éudcation + ateleir dans l'après-midi.
  • samedi 21 et dimanche 22 : journée européenne du patrimoine
  • Vendredi 27 septembre : nuit européenne des chercheuses et des chercheurs
  • La comète Tsuchinshan-ATLAS pourrait être très brillante et visible à l'oeil nu fin septembre et début octobre.

Octobre

  • Mercredi 9 octobre : soirée de lancement Super Brest
  • Jeudi 10 au dimanche 13 octobre : village des sciences au Quartz - Fabuleux laboratoire

Novembre

  • Samedi 9 Novembre : Open Bidouille, journée aux capucins
  • A définir novembre - Plénière de l'AAP MUN.
  • Vendredi 22, samedi 23 et dimanche 24 novembre : Super Brest #10 !

Mars

  • 14 mars éclipse de lune visible en partie

Explorations

Catégories