POCL : Poke : Différence entre versions

De Les Fabriques du Ponant
Aller à : navigation, rechercher
(Arduino)
 
(47 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 5 : Ligne 5 :
  
 
Il envoie un message à la communauté de ses homomorphes, qui réagissent par une ou des actions perceptibles par leurs possesseurs (signal lumineux, vibration etc...)
 
Il envoie un message à la communauté de ses homomorphes, qui réagissent par une ou des actions perceptibles par leurs possesseurs (signal lumineux, vibration etc...)
 +
 +
[[Fichier:POCL-equipe-poke.JPG|400px]] [[Fichier:POCL-equipe-poke2.JPG|400px]]
  
 
==Prototype réalisés ==
 
==Prototype réalisés ==
Ligne 15 : Ligne 17 :
 
La construction d'un POCL: Poke se fera sur la base du prototype le plus à jour, c'est-à-dire le quatrième.<br>
 
La construction d'un POCL: Poke se fera sur la base du prototype le plus à jour, c'est-à-dire le quatrième.<br>
 
Attention, les photos du montage proviennent des deuxième et troisième prototypes
 
Attention, les photos du montage proviennent des deuxième et troisième prototypes
 +
===Proto===
 +
[[Fichier:POCL-Prototype-poke.JPG|400px]] [[Fichier:POCL-PrototypePoke2.JPG|400px]]
  
 +
Y'a un truc à voir ici : https://www.youtube.com/watch?v=0ZCrEbmvCAQ
 
===Matériel===
 
===Matériel===
 
* 1 D1 Mini
 
* 1 D1 Mini
Ligne 29 : Ligne 34 :
 
===Découpe du bois===
 
===Découpe du bois===
 
Découper le bois à la découpeuse laser
 
Découper le bois à la découpeuse laser
 +
==Schémas==
 +
[[Media:Pock PDFMontage.pdf|Télécharger la notice de montage]]
 +
 +
[[Media:Pock-Elv5-decoupelaser.pdf|Télécharger le fichier pour la découpe laser]]
 +
 +
[[Fichier:Pock-Elv5Imagedecoupelaser.png|800px|link=https://www.wiki.lesfabriquesduponant.net/images/5/56/Pock-Elv5-decoupelaser.pdf]]
 +
 +
[[Fichier:Pock model 0.png|400px]] [[Fichier:Pock model 1.png|400px]]
 +
 +
[[Fichier:Pock model 2.png|400px]] [[Fichier:Pock model 3.png|400px]]
 +
 +
[[Fichier:Pock model 4.png|400px]] [[Fichier:Pock model 5.png|400px]]
 +
 +
[[Fichier:Pock model 6.png|400px]] [[Fichier:Pock model 7.png|400px]]
 +
 +
[[Fichier:Pock model 8.png|400px]]
 +
 
===Découpe papier===
 
===Découpe papier===
 
Découper le papier en une bande large de 6 cm et longue de 28 cm (27.4 cm pour une feuille A4)  
 
Découper le papier en une bande large de 6 cm et longue de 28 cm (27.4 cm pour une feuille A4)  
 
====Prélude====
 
====Prélude====
La boîte est un cylindre dont le matériau laisse passer la lumière de façon diffuse comme le papier.<br>
+
La boîte est un cylindre dont le matériau laisse passer la lumière de façon diffuse comme le papier.
Les extrémités du cylindre sont faites de bois découpé au laser afin de renforcer la structure. Le carton peut le remplacer si besoin.<br>
+
 
Pour une meilleure apparence finale, les gravures des pièces doivent être orientées vers l'extérieur de l'objet.<br>
+
Les extrémités du cylindre sont faites de bois découpé au laser afin de renforcer la structure. Le carton peut le remplacer si besoin.
 +
 
 +
Pour une meilleure apparence finale, les gravures des pièces doivent être orientées vers l'extérieur de l'objet.
 +
 
 
====Étape 1====
 
====Étape 1====
Prendre l'anneau troué, et enfoncer dedans les piliers dédiés, le côté épais orienté vers l'intérieur de la pièce<br>
+
Prendre l'anneau troué, et enfoncer dedans les piliers dédiés, le côté épais orienté vers l'intérieur de la pièce
 +
 
 
(Photo)
 
(Photo)
 +
 
====Étape 2====
 
====Étape 2====
Enrouler la bande de papier autour de l'ossature précédemment créée.<br>
+
Enrouler la bande de papier autour de l'ossature précédemment créée.
Un chevauchement des deux bouts est attendu, et utile pour la suite<br>
+
 
 +
Un chevauchement des deux bouts est attendu, et utile pour la suite
 +
 
 
(Photo)
 
(Photo)
 
====Étape 3====
 
====Étape 3====
Insérer les deux anneaux de renforts (les plus grands et fins) autour du papier afin de le pincer avec l'ossature. Les garder à un tier de la distance de chaque bord pour l'instant.<br>
+
Insérer les deux anneaux de renforts (les plus grands et fins) autour du papier afin de le pincer avec l'ossature. Les garder à un tiers de la distance de chaque bord pour l'instant.
 +
 
 
(Photo)
 
(Photo)
 
====Étape 4====
 
====Étape 4====
Insérer le disque troué sur les piliers pour entièrement bloquer le papier et fermer le cylindre d'un côté.<br>
+
Insérer le disque troué sur les piliers pour entièrement bloquer le papier et fermer le cylindre d'un côté.
Il s'agit de l'étape la plus délicate du montage, prendre son temps et y aller par petits pas est vivement recommandé.<br>
+
 
Note: la photo montre un anneau troué, mais la pièce est bien pleine dans le plan.<br>
+
Il s'agit de l'étape la plus délicate du montage, prendre son temps et y aller par petits pas est vivement recommandé.
Note: Il est conseillé pour des raisons de simplification de la tâche d'insérer préalablement les boutons poussoir dans les 4 trous centraux et de les raccorder à des fils pour faciliter les connexions futures.<br>
+
 
 +
Note: la photo montre un anneau troué, mais la pièce est bien pleine dans le plan.
 +
 
 +
Note: Il est conseillé pour des raisons de simplification de la tâche d'insérer préalablement les boutons poussoir dans les 4 trous centraux et de les raccorder à des fils pour faciliter les connexions futures.
 +
 
 
(Photo)
 
(Photo)
 +
 +
====test du montage du POCL====
 +
début 16h50
 +
  
 
====Électronique====
 
====Électronique====
 +
[[Fichier:POCL-Poke-etape2.JPG|400px]] [[Fichier:POCL-Poke-etape3.JPG|400px]] [[Fichier:POCL-Poke-etape.JPG|400px]]
 +
 
====MQTT====
 
====MQTT====
 
L'interaction entre les POCL passe par un serveur MQTT (Message Queuing Telemetry Transport)
 
L'interaction entre les POCL passe par un serveur MQTT (Message Queuing Telemetry Transport)
* Service proposé par https://cloud.shiftr.io/welcome
 
 
* voir [[MQTT]]
 
* voir [[MQTT]]
  
<html>
+
Ce serveur est basé sur le broker libre [https://mosquitto.org/ Mosquitto].
<!DOCTYPE html>
 
<html>
 
  <head>
 
    <meta charset="utf-8" />
 
    <title>Example</title>
 
    <script src="https://unpkg.com/mqtt/dist/mqtt.min.js"></script>
 
  </head>
 
  <body>
 
    <button id="button">Envoie un pokou</button>
 
  
    <script>
 
      const client = mqtt.connect('wss://pocl21:BauhTg9l28jam1lR@pocl21.cloud.shiftr.io', {
 
        clientId: 'WikiTestDemo'
 
      });
 
  
      client.on('connect', function() {
+
=====Le Broker MQTT Shiftr.io (obsolète)=====
        console.log('connected!');
+
Devant les limitation de la démo de ce broker, nous avons monté notre propre server MQTT
        client.subscribe('Poke');
+
* Service proposé par https://cloud.shiftr.io/welcome
      });
 
  
      client.on('message', function(topic, message) {
 
        console.log(topic + ': ' + message.toString());
 
      });
 
  
      document.querySelector('button').addEventListener('click', function() {
+
Aller sur cette page pour trouver le bouton permettant d'envoyer des pokous (en phase de test, ne laissez pas trop vos POCL branchés, à cause de la liitation du sevreur Shifter.io) :
        client.publish('Poke', 'pokou');
 
      });
 
    </script>
 
  </body>
 
</html>
 
  
 +
===Arduino===
 +
Le code Arduino présenté correspond à celui du quatrième modèle
 +
* Il faut installer le [https://www.wikidebrouillard.org/wiki/Utiliser_le_D1_mini_avec_Arduino gestionnaire de carte ESP8266 pour piloter le D1 mini]
 +
* Il faut installer la bibliothèque MQTT de Joël Gähwiler (voir image plus bas)
 +
* bibliothèque Adafruit Néopixel
  
<html>
+
[[Fichier:BibliothequeMQTTPOCL.png|600px]]
  <iframe src="https://pocl21.cloud.shiftr.io/embed?widgets=1" width="1000" height="800" frameborder="0" allowfullscreen></iframe>
 
</html>
 
  
===Arduino===
+
<syntaxhighlight lang="C++" line>
Le code Arduino présenté correspond à celui du quatrième modèle
 
<pre>
 
 
/////////////////////////
 
/////////////////////////
 
//      POCL Poke      //
 
//      POCL Poke      //
 
/////////////////////////
 
/////////////////////////
 
/*
 
/*
  * Un POCL imaginé et réalisé au Hackathon POCL à l'Edulab Rennes 2 les 9 et 10 décembre 2021.
+
  * Un POCL imaginé et réalisé au Hackathon POCL à l'édulab Rennes 2 les 9 et 10 décembre 2021.
 +
*
 +
* Difficultés :
 +
* Configurez le logiciel Arduino pour gérer la carte D1 mini (ESP8266).
 +
* Intégrer les biobliothèues requises par le projet :
 +
** #include <MQTT.h> -> pour gérer le protocole de communication c'est la bibliothèque MQTT de Joël Gähwiler : https://github.com/256dpi/arduino-mqtt
 +
** #include <Adafruit_NeoPixel.h> -> pour gérer les rubans de led
 
  *  
 
  *  
 
  *                                      BROCHAGE                             
 
  *                                      BROCHAGE                             
Ligne 113 : Ligne 137 :
 
                     Bouton -  |[X]D6-12    0-D3[X]| - ruban de leds             
 
                     Bouton -  |[X]D6-12    0-D3[X]| - ruban de leds             
 
                           -  |[ ]D7-13    2-D4[ ]| LED_BUILTIN           
 
                           -  |[ ]D7-13    2-D4[ ]| LED_BUILTIN           
                           -  |[ ]D8-15    GND[X]| - GND (Bouton, MP3-TF-16P)             
+
                           -  |[ ]D8-15    GND[X]| - GND (Boutons, ruban de leds)             
                           -  |[ ]3V3       5V[X]| - ruban de Led         
+
                           -  |[ ]3V3 .      5V[X]| - ruban de Led         
 
                               |      +---+      |                     
 
                               |      +---+      |                     
 
                               |_______|USB|_______|                       
 
                               |_______|USB|_______|                       
Ligne 144 : Ligne 168 :
 
// https://github.com/256dpi/arduino-mqtt
 
// https://github.com/256dpi/arduino-mqtt
 
*/
 
*/
#include <ConditionalPrinter.h>
 
#include <EncryptedConnectionData.h>
 
#include <EncryptedConnectionLog.h>
 
#include <ESP8266WiFiMesh.h>
 
#include <EspnowConnectionManager.h>
 
#include <EspnowDatabase.h>
 
#include <EspnowEncryptionBroker.h>
 
#include <EspnowMeshBackend.h>
 
#include <EspnowNetworkInfo.h>
 
#include <EspnowProtocolInterpreter.h>
 
#include <EspnowTransmitter.h>
 
#include <ExpiringTimeTracker.h>
 
#include <FloodingMesh.h>
 
#include <HeapMonitor.h>
 
#include <JsonTranslator.h>
 
#include <MeshBackendBase.h>
 
#include <MeshCryptoInterface.h>
 
#include <MessageData.h>
 
#include <MutexTracker.h>
 
#include <NetworkInfo.h>
 
#include <NetworkInfoBase.h>
 
#include <PeerRequestLog.h>
 
#include <RequestData.h>
 
#include <ResponseData.h>
 
#include <Serializer.h>
 
#include <TcpIpMeshBackend.h>
 
#include <TcpIpNetworkInfo.h>
 
#include <TimeTracker.h>
 
#include <TransmissionOutcome.h>
 
#include <TransmissionResult.h>
 
#include <TypeConversionFunctions.h>
 
#include <UtilityFunctions.h>
 
 
 
#include <ESP8266WiFi.h>
 
#include <ESP8266WiFi.h>
 
#include <MQTT.h>
 
#include <MQTT.h>
 
#include <Adafruit_NeoPixel.h>
 
#include <Adafruit_NeoPixel.h>
  
const char ssid[] = "iPhone de Antony";
+
const char ssid[] = "LeNomDeVotreReseauWifi";
const char pass[] = "12345678";
+
const char pass[] = "LeCodeDeVotreWifi";
  
 
WiFiClient net;
 
WiFiClient net;
 
MQTTClient client;
 
MQTTClient client;
 +
#define BROKER_IP "debrouillards.ddns.net" //IP du serveur sur lequel est installé le Broker MQTT
  
 
unsigned long lastMillis = 0;
 
unsigned long lastMillis = 0;
Ligne 213 : Ligne 205 :
  
 
   Serial.print("\nconnecting...");
 
   Serial.print("\nconnecting...");
   //connection au serveur MQTT : identifiant, canal, mot de passe
+
   //connection au serveur MQTT : identifiant, User, mot de passe
   while (!client.connect("GAWELLE", "pocl21", "BauhTg9l28jam1lR")) {
+
   while (!client.connect("LeNomDeVotrePOCL", "poclpokou", "pokou")) {
 
     Serial.print(".");
 
     Serial.print(".");
 
     delay(1000);
 
     delay(1000);
Ligne 221 : Ligne 213 :
 
   Serial.println("\nconnected!");
 
   Serial.println("\nconnected!");
  
// on s'abonne au sujet (topic) "Poke"  
+
// on s'abonne au sujet (topic) "/Poke"  
   client.subscribe("/Poke");
+
   client.subscribe("/Poke"); // Attention à la casse !! La casse c'est maj ou minuscule
   // client.unsubscribe("/hello");
+
   // client.unsubscribe("/Poke");// Pour se désiscrire
 
}
 
}
  
Ligne 248 : Ligne 240 :
 
    
 
    
 
   for(int i=0; i<NUMPIXELS; i++) {
 
   for(int i=0; i<NUMPIXELS; i++) {
     pixels.setPixelColor(i, pixels.Color(150, b, 200));
+
     pixels.setPixelColor(i, pixels.Color(250, 150, b));
 
   }
 
   }
 
   pixels.show();  // On allume les rubans
 
   pixels.show();  // On allume les rubans
Ligne 261 : Ligne 253 :
  
 
     // pixels.Color() prends les valeurs RGB de 0,0,0 jusqu'à 255,255,255
 
     // pixels.Color() prends les valeurs RGB de 0,0,0 jusqu'à 255,255,255
     pixels.setPixelColor(i, pixels.Color(b, 100, 100));
+
     pixels.setPixelColor(i, pixels.Color(b, 50, 255));
 
   }
 
   }
 
   pixels.show();  // on affiche les pixels
 
   pixels.show();  // on affiche les pixels
Ligne 279 : Ligne 271 :
  
 
   // on se connecte au client
 
   // on se connecte au client
   client.begin("pocl21.cloud.shiftr.io", net);
+
   client.begin(BROKER_IP, 1883, net); // (IP, port,je ne sais pas à quoi correspond "net")
 
   client.onMessage(messageReceived);
 
   client.onMessage(messageReceived);
  
Ligne 304 : Ligne 296 :
 
   }
 
   }
 
}
 
}
</pre>
+
</syntaxhighlight>
 +
 
 +
Et la Version pour ESP32 !
 +
 
 +
<syntaxhighlight lang="C++" line>
 +
/////////////////////////
 +
//      POCL Poke      //
 +
/////////////////////////
 +
 
 +
/*
 +
* Un POCL imaginé et réalisé au Hackathon POCL à l'édulab Rennes 2 les 9 et 10 décembre 2021.
 +
*
 +
* Difficultés :
 +
* Configurez le logiciel Arduino pour gérer la ESP32.
 +
* Intégrer les biobliothèues requises par le projet :
 +
** #include <MQTT.h> -> pour gérer le protocole de communication c'est la bibliothèque MQTT de Joël Gähwiler : https://github.com/256dpi/arduino-mqtt
 +
** #include <Adafruit_NeoPixel.h> -> pour gérer les rubans de led
 +
*
 +
*                                      BROCHAGE                           
 +
                                _________________                       
 +
                              /    ESP32 WROOM \                     
 +
                          -  |[ ]RST        TX[ ]| -                   
 +
                          -  |[ ]A0  -GPIO  RX[ ]| -                   
 +
                              |[ ]  16    5  [ ]| -                   
 +
                              |[ ]  14    4  [ ]| -                   
 +
                    Bouton -  |[X]12      0  [X]| - ruban de leds           
 +
                          -  |[ ]  13    2  [ ]| LED_BUILTIN         
 +
                          -  |[ ]  15    GND[X]| - GND (Boutons, ruban de leds)           
 +
                          -  |[ ]3V3 .      5V[X]| - ruban de Led       
 +
                              |      +---+      |                   
 +
                              |_______|USB|_______|                     
 +
 
 +
Matériel :
 +
- des fils dupont.
 +
- un ruban de led RGB WS28B12
 +
- D1 mini (Wemos, LOLIN,...)
 +
- bouton poussoir
 +
- une alimentation 5V
 +
*/
 +
 
 +
/*
 +
 
 +
* Un travail d'équipe de :
 +
* Alma Oskouei
 +
* Gaëlle Bescond
 +
* Tony Vanpoucke
 +
* Wing-Anh Luy
 +
* Antony Le Goïc-Auffret
 +
 
 +
  ___
 +
/ ___ \
 +
|_|  | |
 +
    /_/
 +
    _  ___  _
 +
    |_| |___|_| |_
 +
        ___|_  _|
 +
        |___| |_|
 +
 
 +
Les petits Débrouillards - décembre 2021 CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 +
 
 +
// Programme inspiré de celui par Joël Gähwiler
 +
 
 +
// Pour tester sur un PC avec mosquito d'installé (sudo apt install -y mosquitto mosquitto-clients)
 +
// mosquitto_pub -h 86.223.98.89 -p 1883 -u "poclpokou" -P "pokou" -m "pokou" -t /Poke
 +
 
 +
 
 +
// https://github.com/256dpi/arduino-mqtt
 +
 
 +
*/
 +
 
 +
 
 +
#include <MQTT.h>
 +
#include <Adafruit_NeoPixel.h>
 +
#include <WiFi.h>
 +
const char ssid[] = "SSID";
 +
const char pass[] = "Mot de passe";
 +
WiFiClient net;
 +
MQTTClient client;
 +
#define BROKER_IP "debrouillards.ddns.net"  //IP du serveur sur lequel est installé le Broker MQTT
 +
 
 +
unsigned long lastMillis = 0;
 +
 
 +
//=============élément pour le ruban de led et le bouton===============
 +
 
 +
 
 +
// Broche de connexion du ruban de LED
 +
 
 +
#define PIN 0  //
 +
int brocheBouton = 12;  //GPIO de la broche 12
 +
 
 +
 
 +
// Nombre de Led RDGB dans votre ruban
 +
#define NUMPIXELS 13
 +
 
 +
// on configurer un riban nommé "pixels"
 +
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
 +
 
 +
#define T 1  // temps pour gérer le fade du ruban
 +
//==============================================================
 +
 
 +
 
 +
void connect() {
 +
  Serial.print("checking wifi...");
 +
  while (WiFi.status() != WL_CONNECTED) {
 +
    Serial.print(".");
 +
    delay(1000);
 +
  }
 +
 
 +
  Serial.print("\nconnecting...");
 +
  //connection au serveur MQTT : identifiant, User, mot de passe
 +
  while (!client.connect("LeNomDeVotrePOCL", "poclpokou", "pokou")) {
 +
    Serial.print(".");
 +
    delay(1000);
 +
  }
 +
 
 +
  Serial.println("\nconnected!");
 +
  // on s'abonne au sujet (topic) "/Poke"
 +
  client.subscribe("/Poke");  // Attention à la casse !! La casse c'est maj ou minuscule
 +
  // client.unsubscribe("/Poke");// Pour se désiscrire
 +
}
 +
 
 +
void messageReceived(String &topic, String &payload) {
 +
  digitalWrite(2, HIGH);
 +
  fade();
 +
  Serial.println("incoming: " + topic + " - " + payload);
 +
  if (payload == "pokou") {
 +
    Serial.println("clic !");
 +
    digitalWrite(2, LOW);
 +
    delay(100);
 +
    digitalWrite(2, HIGH);
 +
  }
 +
 
 +
  // Note: Do not use the client in the callback to publish, subscribe or
 +
  // unsubscribe as it may cause deadlocks when other things arrive while
 +
  // sending and receiving acknowledgments. Instead, change a global variable,
 +
  // or push to a queue and handle it in the loop after calling `client.loop()`.
 +
}
 +
 
 +
 
 +
void fade() {
 +
  for (int sig = 0; sig < 3; sig++) {
 +
    for (int b = 0; b < 255; b++) {
 +
      pixels.setBrightness(b);
 +
 
 +
      for (int i = 0; i < NUMPIXELS; i++) {
 +
        pixels.setPixelColor(i, pixels.Color(250, 150, b));
 +
      }
 +
      pixels.show();  // On allume les rubans
 +
      delay(T);
 +
    }
 +
 
 +
 
 +
    for (int b = 255; b > 1; b--) {  //boucle de gestion de la brillance
 +
      pixels.setBrightness(b);
 +
 
 +
      // n'oubliez pas que le premier pixel porte le Numéro 0
 +
      for (int i = 0; i < NUMPIXELS; i++) {  // Pour chaque pixel...
 +
 
 +
        // pixels.Color() prends les valeurs RGB de 0,0,0 jusqu'à 255,255,255
 +
        pixels.setPixelColor(i, pixels.Color(b, 50, 255));
 +
      }
 +
      pixels.show();  // on affiche les pixels
 +
      delay(T);
 +
    }
 +
  }
 +
}
 +
 
 +
 
 +
void setup() {
 +
  Serial.begin(115200);
 +
  pixels.begin();  //on initialise le ruban "pixels"
 +
  pinMode(brocheBouton, INPUT_PULLUP);
 +
 
 +
  pinMode(2, OUTPUT);
 +
  digitalWrite(2, HIGH);
 +
 
 +
  WiFi.begin(ssid, pass);
 +
 
 +
  // on se connecte au client
 +
  client.begin(BROKER_IP, 1883, net);  // (IP, port,je ne sais pas à quoi correspond "net")
 +
  client.onMessage(messageReceived);
 +
 
 +
  connect();
 +
}
 +
 
 +
 
 +
void loop() {
 +
  pixels.clear();  // Set all pixel colors to 'off'
 +
  pixels.show();
 +
 
 +
  client.loop();
 +
  delay(10);  // <- fixes some issues with WiFi stability
 +
 
 +
  if (!client.connected()) {
 +
    connect();
 +
  }
 +
 
 +
 
 +
  // publish a message roughly every second.
 +
  if (digitalRead(brocheBouton) == LOW) {
 +
    Serial.println("Appuis Bouton");
 +
    client.publish("/Poke", "pokou");
 +
    delay(250);
 +
  }
 +
}
 +
</syntaxhighlight>
 +
==Retours d'expérience==
 +
ça marche !
 +
 
 +
shiftr.io, le service MQTT utilisé pour le prototype a une limitation : au bout de 6 heures d'utilisations, le service s'arrête pendant 15 minute !!
 +
 
 +
==Déjà fait==
 +
* 18/12/2021 créer notre propre serveur MQTT
 +
* 20/12/2021 mettre wifimanager pour gérer la configuration de connexion
 +
* 21/12/2021 site web de sélection de la couleur
 +
* 22/12/2021 mémorisation de la couleur sélectionnée, publication du code sur Github : https://github.com/antonydbzh/POCLpokou/blob/main/README.md
 +
 
 +
==Piste de développement à faire pour une V2==
 +
* évaluer les questions de sécurité
 +
* imaginer des fonctionnalités supplémentaires (du son façon R2D2, du mouvement )
 +
* un système de configuration de la couleur (via MQTT et une interface web ?)
 +
 
 +
===Configuration via MQTT===
 +
* chaque D1 mini dispose d'un identifiant unique.
 +
* il est possible de créer un topic MQTT avec cet identifiant qui serait le canal de configuration.
 +
* le POCL est abonné à ce topic et reçoit donc les infos de configuration qu'il peut stocker dans la mémoire.
 +
* on peut créer une page web dans laquelle on renseigne l'identifiant et la couleur (ou tout autre paramètre à configurer).
 +
* la page web envoie la config au topic.
 +
 
 +
===Mieux, Configuration via la fonctionnalité "Point d'Accès"===
 +
* rajouter un sélecteur (interrupteur) qui activé, met le D1 mini en mode config.
 +
* une interface web qui demande la config : wifi, couleur, fonctionnalité,....
 +
 
 +
===Question de sécurité===
 +
* le système est très facilement "spamable".
 +
 
 +
===Sources d'infos===
 +
* www.martyncurrey.com/esp8266-and-C-arduino-ide-part-5-adding-wifimanager/
 +
* Voir exemple de la bib WiFiManager AutoconnectwithFSparamaters
 +
 
 +
==Usages==
 +
* Mobiliser les concepts de Many-to-many au lieu de one-to-one
 +
* concept de POCL communautaire
 +
* Un POCL qui a des heures d'ouverture ? (8h à 20h par exemple) ?
 +
* Conserver le fait d'avoir reçu un pokou ?
  
 +
==pour tester à partir d'une application==
 +
l'appli multiplateforme MQTTX : https://mqttx.app/ permet de recevoir et d'envoyer des pokous
  
 
[[Catégorie:POCL]]
 
[[Catégorie:POCL]]
 +
[[Catégorie:led]][[Catégorie:ruban de led]][[Catégorie:WS1812B]]

Version actuelle datée du 14 novembre 2024 à 15:50

Résumé du Projet

Le POCL: Poke est un POCL communautaire interactif. Sa fonction est d'envoyer et recevoir un message, nommé "pokou" vers ou provenant des autres POCL: Poke.

Le projet a été réalisé par Alma, Wing-Anh, Tony, Antony, Gaelle

Il envoie un message à la communauté de ses homomorphes, qui réagissent par une ou des actions perceptibles par leurs possesseurs (signal lumineux, vibration etc...)

POCL-equipe-poke.JPG POCL-equipe-poke2.JPG

Prototype réalisés

4 prototypes différents ont été réalisés, chacun apportant une évolution/modification supplémentaire.

  • Le premier prototype est fait, en plus de l'électronique, de carton et de papier.
  • Le deuxième prototype consiste en du bois découpé au laser pour remplacer le carton et mieux emprisonner le papier. Cette deuxième génération donnera la forme générale quasiment finale.
  • Le troisième prototype a intégré un bouton dans la structure d'un couvercle pour pouvoir interagir réellement avec les autres POCL.
  • Le quatrième et dernier prototype s'est vu octroyer trois boutons supplémentaires pour pouvoir envoyer plus de "pokous", ainsi que d'un "maintien d'élégance" pour permettre aux fils d'en sortir sans détériorer le papier sur la durée.

Fabrication d'un POCL: Poke

La construction d'un POCL: Poke se fera sur la base du prototype le plus à jour, c'est-à-dire le quatrième.
Attention, les photos du montage proviennent des deuxième et troisième prototypes

Proto

POCL-Prototype-poke.JPG POCL-PrototypePoke2.JPG

Y'a un truc à voir ici : https://www.youtube.com/watch?v=0ZCrEbmvCAQ

Matériel

  • 1 D1 Mini
  • 1 Ruban de LED ou autre objet au choix permettant un stimulus sensoriel pour l'utilisateur
  • 1 Bouton poussoir (4 s'il est prévu d'augmenter la capacité de pokous)
  • Fils conducteurs
  • Découpeuse laser
  • Planches de bois de 5mm d'épaisseur (ou carton facile à découper)
  • Papier fin (des feuilles A4 font parfaitement l'affaire)
  • Colle à bois (optionnel)
  • Connexion internet
  • Ciseaux

Découpe du bois

Découper le bois à la découpeuse laser

Schémas

Télécharger la notice de montage

Télécharger le fichier pour la découpe laser

Pock-Elv5Imagedecoupelaser.png

Pock model 0.png Pock model 1.png

Pock model 2.png Pock model 3.png

Pock model 4.png Pock model 5.png

Pock model 6.png Pock model 7.png

Pock model 8.png

Découpe papier

Découper le papier en une bande large de 6 cm et longue de 28 cm (27.4 cm pour une feuille A4)

Prélude

La boîte est un cylindre dont le matériau laisse passer la lumière de façon diffuse comme le papier.

Les extrémités du cylindre sont faites de bois découpé au laser afin de renforcer la structure. Le carton peut le remplacer si besoin.

Pour une meilleure apparence finale, les gravures des pièces doivent être orientées vers l'extérieur de l'objet.

Étape 1

Prendre l'anneau troué, et enfoncer dedans les piliers dédiés, le côté épais orienté vers l'intérieur de la pièce

(Photo)

Étape 2

Enrouler la bande de papier autour de l'ossature précédemment créée.

Un chevauchement des deux bouts est attendu, et utile pour la suite

(Photo)

Étape 3

Insérer les deux anneaux de renforts (les plus grands et fins) autour du papier afin de le pincer avec l'ossature. Les garder à un tiers de la distance de chaque bord pour l'instant.

(Photo)

Étape 4

Insérer le disque troué sur les piliers pour entièrement bloquer le papier et fermer le cylindre d'un côté.

Il s'agit de l'étape la plus délicate du montage, prendre son temps et y aller par petits pas est vivement recommandé.

Note: la photo montre un anneau troué, mais la pièce est bien pleine dans le plan.

Note: Il est conseillé pour des raisons de simplification de la tâche d'insérer préalablement les boutons poussoir dans les 4 trous centraux et de les raccorder à des fils pour faciliter les connexions futures.

(Photo)

test du montage du POCL

début 16h50


Électronique

POCL-Poke-etape2.JPG POCL-Poke-etape3.JPG POCL-Poke-etape.JPG

MQTT

L'interaction entre les POCL passe par un serveur MQTT (Message Queuing Telemetry Transport)

Ce serveur est basé sur le broker libre Mosquitto.


Le Broker MQTT Shiftr.io (obsolète)
Devant les limitation de la démo de ce broker, nous avons monté notre propre server MQTT


Aller sur cette page pour trouver le bouton permettant d'envoyer des pokous (en phase de test, ne laissez pas trop vos POCL branchés, à cause de la liitation du sevreur Shifter.io) :

Arduino

Le code Arduino présenté correspond à celui du quatrième modèle

BibliothequeMQTTPOCL.png

  1 /////////////////////////
  2 //      POCL Poke      //
  3 /////////////////////////
  4 /*
  5  * Un POCL imaginé et réalisé au Hackathon POCL à l'édulab Rennes 2 les 9 et 10 décembre 2021.
  6  * 
  7  * Difficultés :
  8  * Configurez le logiciel Arduino pour gérer la carte D1 mini (ESP8266).
  9  * Intégrer les biobliothèues requises par le projet :
 10  ** #include <MQTT.h> -> pour gérer le protocole de communication c'est la bibliothèque MQTT de Joël Gähwiler : https://github.com/256dpi/arduino-mqtt
 11  ** #include <Adafruit_NeoPixel.h> -> pour gérer les rubans de led
 12  * 
 13  *                                      BROCHAGE                            
 14                                 _________________                        
 15                                /     D1 mini     \                       
 16                            -  |[ ]RST        TX[ ]| -                    
 17                            -  |[ ]A0  -GPIO  RX[ ]| -                    
 18                               |[ ]D0-16    5-D1[ ]| -                    
 19                               |[ ]D5-14    4-D2[ ]| -                    
 20                     Bouton -  |[X]D6-12    0-D3[X]| - ruban de leds             
 21                            -  |[ ]D7-13    2-D4[ ]| LED_BUILTIN          
 22                            -  |[ ]D8-15     GND[X]| - GND (Boutons, ruban de leds)             
 23                            -  |[ ]3V3 .      5V[X]| - ruban de Led        
 24                               |       +---+       |                     
 25                               |_______|USB|_______|                      
 26 
 27 Matériel :
 28 - des fils dupont.
 29 - un ruban de led RGB WS28B12
 30 - D1 mini (Wemos, LOLIN,...)
 31 - bouton poussoir
 32 - une alimentation 5V
 33 */
 34 /*
 35  * Un travail d'équipe de :
 36  * Alma Oskouei
 37  * Gaëlle Bescond
 38  * Tony Vanpoucke
 39  * Wing-Anh Luy
 40  * Antony Le Goïc-Auffret
 41    ___
 42  / ___ \
 43 |_|   | |
 44      /_/ 
 45      _   ___   _ 
 46     |_| |___|_| |_
 47          ___|_   _|
 48         |___| |_|
 49 Les petits Débrouillards - décembre 2021 CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 50 // Programme inspiré de celui par Joël Gähwiler
 51 // https://github.com/256dpi/arduino-mqtt
 52 */
 53 #include <ESP8266WiFi.h>
 54 #include <MQTT.h>
 55 #include <Adafruit_NeoPixel.h>
 56 
 57 const char ssid[] = "LeNomDeVotreReseauWifi";
 58 const char pass[] = "LeCodeDeVotreWifi";
 59 
 60 WiFiClient net;
 61 MQTTClient client;
 62 #define BROKER_IP "debrouillards.ddns.net" //IP du serveur sur lequel est installé le Broker MQTT
 63 
 64 unsigned long lastMillis = 0;
 65 
 66 //=============élément pour le ruban de led et le bouton===============
 67 
 68 // Broche de connexion du ruban de LED
 69 #define PIN D3 // 
 70 
 71 int brocheBouton = 12; //GPIO de la broche D6
 72 
 73 // Nombre de Led RDGB dans votre ruban
 74 #define NUMPIXELS 13 
 75 
 76 // on configurer un riban nommé "pixels"
 77 Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
 78 
 79 #define T 1 // temps pour gérer le fade du ruban
 80 //==============================================================
 81 
 82 void connect() {
 83   Serial.print("checking wifi...");
 84   while (WiFi.status() != WL_CONNECTED) {
 85     Serial.print(".");
 86     delay(1000);
 87   }
 88 
 89   Serial.print("\nconnecting...");
 90   //connection au serveur MQTT : identifiant, User, mot de passe
 91   while (!client.connect("LeNomDeVotrePOCL", "poclpokou", "pokou")) {
 92     Serial.print(".");
 93     delay(1000);
 94   }
 95 
 96   Serial.println("\nconnected!");
 97 
 98 // on s'abonne au sujet (topic) "/Poke" 
 99   client.subscribe("/Poke"); // Attention à la casse !! La casse c'est maj ou minuscule
100   // client.unsubscribe("/Poke");// Pour se désiscrire
101 }
102 
103 void messageReceived(String &topic, String &payload) {
104   digitalWrite(LED_BUILTIN, HIGH);
105   fade();
106   Serial.println("incoming: " + topic + " - " + payload);
107   if (payload == "pokou"){
108     Serial.println("clic !");
109     digitalWrite(LED_BUILTIN, LOW);
110     delay(100);
111     digitalWrite(LED_BUILTIN, HIGH);
112   }
113   // Note: Do not use the client in the callback to publish, subscribe or
114   // unsubscribe as it may cause deadlocks when other things arrive while
115   // sending and receiving acknowledgments. Instead, change a global variable,
116   // or push to a queue and handle it in the loop after calling `client.loop()`.
117 }
118 
119 void fade() {
120   for (int sig=0; sig<3; sig++){
121   for (int b=0; b<255; b++){
122   pixels.setBrightness(b);
123   
124   for(int i=0; i<NUMPIXELS; i++) {
125     pixels.setPixelColor(i, pixels.Color(250, 150, b));
126   }
127   pixels.show();   // On allume les rubans
128   delay(T);
129   }
130 
131   for (int b=255; b>1; b--){ //boucle de gestion de la brillance
132   pixels.setBrightness(b);
133   
134   // n'oubliez pas que le premier pixel porte le Numéro 0
135   for(int i=0; i<NUMPIXELS; i++) { // Pour chaque pixel...
136 
137     // pixels.Color() prends les valeurs RGB de 0,0,0 jusqu'à 255,255,255
138     pixels.setPixelColor(i, pixels.Color(b, 50, 255));
139   }
140   pixels.show();   // on affiche les pixels
141   delay(T);
142   }
143   }
144 }
145 
146 void setup() {
147   Serial.begin(115200);
148   pixels.begin(); //on initialise le ruban "pixels"
149   pinMode(brocheBouton,INPUT_PULLUP);
150   
151   pinMode(LED_BUILTIN, OUTPUT);
152   digitalWrite(LED_BUILTIN, HIGH);
153   WiFi.begin(ssid, pass);
154 
155   // on se connecte au client
156   client.begin(BROKER_IP, 1883, net); // (IP, port,je ne sais pas à quoi correspond "net")
157   client.onMessage(messageReceived);
158 
159   connect();
160 }
161 
162 void loop() {
163   pixels.clear(); // Set all pixel colors to 'off'
164   pixels.show();
165   
166   client.loop();
167   delay(10);  // <- fixes some issues with WiFi stability
168 
169   if (!client.connected()) {
170     connect();
171   }
172 
173   // publish a message roughly every second.
174 
175   if ( digitalRead(brocheBouton) == LOW ){
176   Serial.println("Appuis Bouton"); 
177   client.publish("/Poke", "pokou");
178   delay(250);
179   }
180 }

Et la Version pour ESP32 !

  1 /////////////////////////
  2 //      POCL Poke      //
  3 /////////////////////////
  4 
  5 /*
  6  * Un POCL imaginé et réalisé au Hackathon POCL à l'édulab Rennes 2 les 9 et 10 décembre 2021.
  7  * 
  8  * Difficultés :
  9  * Configurez le logiciel Arduino pour gérer la ESP32.
 10  * Intégrer les biobliothèues requises par le projet :
 11  ** #include <MQTT.h> -> pour gérer le protocole de communication c'est la bibliothèque MQTT de Joël Gähwiler : https://github.com/256dpi/arduino-mqtt
 12  ** #include <Adafruit_NeoPixel.h> -> pour gérer les rubans de led
 13  * 
 14  *                                      BROCHAGE                            
 15                                 _________________                        
 16                                /     ESP32 WROOM \                       
 17                            -  |[ ]RST        TX[ ]| -                    
 18                            -  |[ ]A0  -GPIO  RX[ ]| -                    
 19                               |[ ]   16    5   [ ]| -                    
 20                               |[ ]   14    4   [ ]| -                    
 21                     Bouton -  |[X]12       0   [X]| - ruban de leds             
 22                            -  |[ ]   13    2   [ ]| LED_BUILTIN          
 23                            -  |[ ]   15     GND[X]| - GND (Boutons, ruban de leds)             
 24                            -  |[ ]3V3 .      5V[X]| - ruban de Led        
 25                               |       +---+       |                     
 26                               |_______|USB|_______|                      
 27 
 28 Matériel :
 29 - des fils dupont.
 30 - un ruban de led RGB WS28B12
 31 - D1 mini (Wemos, LOLIN,...)
 32 - bouton poussoir
 33 - une alimentation 5V
 34 */
 35 
 36 /*
 37 
 38  * Un travail d'équipe de :
 39  * Alma Oskouei
 40  * Gaëlle Bescond
 41  * Tony Vanpoucke
 42  * Wing-Anh Luy
 43  * Antony Le Goïc-Auffret
 44 
 45    ___
 46  / ___ \
 47 |_|   | |
 48      /_/ 
 49      _   ___   _ 
 50     |_| |___|_| |_
 51          ___|_   _|
 52         |___| |_|
 53 
 54 Les petits Débrouillards - décembre 2021 CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
 55 
 56 // Programme inspiré de celui par Joël Gähwiler
 57 
 58 // Pour tester sur un PC avec mosquito d'installé (sudo apt install -y mosquitto mosquitto-clients)
 59 // mosquitto_pub -h 86.223.98.89 -p 1883 -u "poclpokou" -P "pokou" -m "pokou" -t /Poke
 60 
 61 
 62 // https://github.com/256dpi/arduino-mqtt
 63 
 64 */
 65 
 66 
 67 #include <MQTT.h>
 68 #include <Adafruit_NeoPixel.h>
 69 #include <WiFi.h>
 70 const char ssid[] = "SSID";
 71 const char pass[] = "Mot de passe";
 72 WiFiClient net;
 73 MQTTClient client;
 74 #define BROKER_IP "debrouillards.ddns.net"  //IP du serveur sur lequel est installé le Broker MQTT
 75 
 76 unsigned long lastMillis = 0;
 77 
 78 //=============élément pour le ruban de led et le bouton===============
 79 
 80 
 81 // Broche de connexion du ruban de LED
 82 
 83 #define PIN 0  //
 84 int brocheBouton = 12;  //GPIO de la broche 12
 85 
 86 
 87 // Nombre de Led RDGB dans votre ruban
 88 #define NUMPIXELS 13
 89 
 90 // on configurer un riban nommé "pixels"
 91 Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
 92 
 93 #define T 1  // temps pour gérer le fade du ruban
 94 //==============================================================
 95 
 96 
 97 void connect() {
 98   Serial.print("checking wifi...");
 99   while (WiFi.status() != WL_CONNECTED) {
100     Serial.print(".");
101     delay(1000);
102   }
103 
104   Serial.print("\nconnecting...");
105   //connection au serveur MQTT : identifiant, User, mot de passe
106   while (!client.connect("LeNomDeVotrePOCL", "poclpokou", "pokou")) {
107     Serial.print(".");
108     delay(1000);
109   }
110 
111   Serial.println("\nconnected!");
112   // on s'abonne au sujet (topic) "/Poke"
113   client.subscribe("/Poke");  // Attention à la casse !! La casse c'est maj ou minuscule
114   // client.unsubscribe("/Poke");// Pour se désiscrire
115 }
116 
117 void messageReceived(String &topic, String &payload) {
118   digitalWrite(2, HIGH);
119   fade();
120   Serial.println("incoming: " + topic + " - " + payload);
121   if (payload == "pokou") {
122     Serial.println("clic !");
123     digitalWrite(2, LOW);
124     delay(100);
125     digitalWrite(2, HIGH);
126   }
127 
128   // Note: Do not use the client in the callback to publish, subscribe or
129   // unsubscribe as it may cause deadlocks when other things arrive while
130   // sending and receiving acknowledgments. Instead, change a global variable,
131   // or push to a queue and handle it in the loop after calling `client.loop()`.
132 }
133 
134 
135 void fade() {
136   for (int sig = 0; sig < 3; sig++) {
137     for (int b = 0; b < 255; b++) {
138       pixels.setBrightness(b);
139 
140       for (int i = 0; i < NUMPIXELS; i++) {
141         pixels.setPixelColor(i, pixels.Color(250, 150, b));
142       }
143       pixels.show();  // On allume les rubans
144       delay(T);
145     }
146 
147 
148     for (int b = 255; b > 1; b--) {  //boucle de gestion de la brillance
149       pixels.setBrightness(b);
150 
151       // n'oubliez pas que le premier pixel porte le Numéro 0
152       for (int i = 0; i < NUMPIXELS; i++) {  // Pour chaque pixel...
153 
154         // pixels.Color() prends les valeurs RGB de 0,0,0 jusqu'à 255,255,255
155         pixels.setPixelColor(i, pixels.Color(b, 50, 255));
156       }
157       pixels.show();  // on affiche les pixels
158       delay(T);
159     }
160   }
161 }
162 
163 
164 void setup() {
165   Serial.begin(115200);
166   pixels.begin();  //on initialise le ruban "pixels"
167   pinMode(brocheBouton, INPUT_PULLUP);
168 
169   pinMode(2, OUTPUT);
170   digitalWrite(2, HIGH);
171 
172   WiFi.begin(ssid, pass);
173 
174   // on se connecte au client
175   client.begin(BROKER_IP, 1883, net);  // (IP, port,je ne sais pas à quoi correspond "net")
176   client.onMessage(messageReceived);
177 
178   connect();
179 }
180 
181 
182 void loop() {
183   pixels.clear();  // Set all pixel colors to 'off'
184   pixels.show();
185 
186   client.loop();
187   delay(10);  // <- fixes some issues with WiFi stability
188 
189   if (!client.connected()) {
190     connect();
191   }
192 
193 
194   // publish a message roughly every second.
195   if (digitalRead(brocheBouton) == LOW) {
196     Serial.println("Appuis Bouton");
197     client.publish("/Poke", "pokou");
198     delay(250);
199   }
200 }

Retours d'expérience

ça marche !

shiftr.io, le service MQTT utilisé pour le prototype a une limitation : au bout de 6 heures d'utilisations, le service s'arrête pendant 15 minute !!

Déjà fait

  • 18/12/2021 créer notre propre serveur MQTT
  • 20/12/2021 mettre wifimanager pour gérer la configuration de connexion
  • 21/12/2021 site web de sélection de la couleur
  • 22/12/2021 mémorisation de la couleur sélectionnée, publication du code sur Github : https://github.com/antonydbzh/POCLpokou/blob/main/README.md

Piste de développement à faire pour une V2

  • évaluer les questions de sécurité
  • imaginer des fonctionnalités supplémentaires (du son façon R2D2, du mouvement )
  • un système de configuration de la couleur (via MQTT et une interface web ?)

Configuration via MQTT

  • chaque D1 mini dispose d'un identifiant unique.
  • il est possible de créer un topic MQTT avec cet identifiant qui serait le canal de configuration.
  • le POCL est abonné à ce topic et reçoit donc les infos de configuration qu'il peut stocker dans la mémoire.
  • on peut créer une page web dans laquelle on renseigne l'identifiant et la couleur (ou tout autre paramètre à configurer).
  • la page web envoie la config au topic.

Mieux, Configuration via la fonctionnalité "Point d'Accès"

  • rajouter un sélecteur (interrupteur) qui activé, met le D1 mini en mode config.
  • une interface web qui demande la config : wifi, couleur, fonctionnalité,....

Question de sécurité

  • le système est très facilement "spamable".

Sources d'infos

  • www.martyncurrey.com/esp8266-and-C-arduino-ide-part-5-adding-wifimanager/
  • Voir exemple de la bib WiFiManager AutoconnectwithFSparamaters

Usages

  • Mobiliser les concepts de Many-to-many au lieu de one-to-one
  • concept de POCL communautaire
  • Un POCL qui a des heures d'ouverture ? (8h à 20h par exemple) ?
  • Conserver le fait d'avoir reçu un pokou ?

pour tester à partir d'une application

l'appli multiplateforme MQTTX : https://mqttx.app/ permet de recevoir et d'envoyer des pokous