clean-up

3 years ago · e29a2bc57c
parent 237c7d99eb
commit e29a2bc57c
24 changed files with 3 additions and 1520 deletions
--- a/Saint-Luc_Guillaume/.DS_Store
+++ b/Saint-Luc_Guillaume/.DS_Store
--- a/Saint-Luc_Guillaume/A
+++ b/Saint-Luc_Guillaume/A
@ -1,610 +0,0 @@
 # A living library of plants
 [TOC]
 ## Concept
 ### Inspiration
 From electro-culture to recent touché experiments, using electricity to connect and foster our relationship with plants are numerous.
 ![electro-culture: two plants, one with electrode, the other without. Illustration of an experiment to prove the efficiency of growing plants with electricity ](https://upload.wikimedia.org/wikipedia/commons/2/2d/EKult022.jpg)
 [*electro-culture: two plants, one with electrode, the other without. Illustration of an experiment to prove the efficiency of growing plants with electricity* ](https://fr.wikipedia.org/wiki/%C3%89lectroculture#/media/Fichier:EKult022.jpg)
 Here we continue this tradition, as a way to make sense of the technology we have, and as an excuse to spend time with plants.
 ### Déroulement
 The workshop a living library of plants is to link texts, trees and human  through the use of the ESP32 microcontroller.
 The idea is to create a small wifi access point, tied to a plant, that will publish different text depending on its electrical activity and the moisture of its soil.
 ##Set-up (30 minutes- keep faith)
 ###Necessary elements
 In order to participate to this workshop you will need:
 an esp32 microcontroller: for this workshop we used the one proposed by [AZdelivery](https://www.az-delivery.de/en/products/esp32-developmentboard)
 a microUSB cable
 a soil moisture sensor with Dupont cables
 a crocodile cable/ alligator clip
 ###Installing the Arduino IDE
 For this workshop we will use the arduino IDE. It is an open-source, easy to use IDE (Integrated Development Environment ) to upload code to a microcontroller. It was developped for a range of microcontroller also named arduino (which is why it can be confusing).
 To install it, [you can follow this link](https://www.arduino.cc/en/software) and click on the download link fitted to your operating system (macOS, windows or Linux)
 ###Installing the USB driver of the esp32
 The esp32 is a microcontroller, meaning that it can perform some simple computing task such as reading a sensor, printing a message on a communication canal or performing simple operations.
 The ESP32 is not a traditionnal arduino board and requires a specific driver to be installed for it to be able to communicate with your computer. A driver is a small programm that will allow the communication between your computer and another device, in other words it will make your computer recognise the esp32.
 You can find the driver [on this website](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers), select the link corresponding to your operating system(macOS, Windows, Linux) and follow the isntructions.
 ###Installing the library for esp32 on the arduino IDE 1/2
 Now your computer recognise the esp32, but the arduino IDE should know which language to speak to it. In order for them two to communicate smoothly, we need to install a library for the esp32 on the arduino IDE.
 1. Open the Arduino IDE. Make sure that you are at version 1.8 or higher, if not then update your IDE with the latest version.
 2. Click on the *File* menu on the top menu bar.
 3. Click on the *Preferences* menu item. This will open a Preferences dialog box.
   <img src="/Users/u0122145/Documents/11_guillaume_scripts/anais_berck/workshop/preference.png" alt="preference" style="zoom: 50%;" />
 4. You should be on the *Settings* tab in the Preferences dialog box by default.
 5. Look for the textbox labeled “*Additional Boards Manager URLs*”.
 6. If there is already text in this box add a coma at the end of it, then follow the next step.
 7. Paste the following link into the text box – ***https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json\***
 8. Click the OK button to save the setting. 
 ![preference_window](/Users/u0122145/Documents/11_guillaume_scripts/anais_berck/workshop/preference_window.png)
 ###Installing the library for esp32 on the arduino IDE 2/2 
 Next, you will need to use the new  entry to actually add the ESPO32 boards to your Arduino IDE. You do that by following this procedure:
 1. In the Arduino IDE click on the *Tools* menu on the top menu bar.
 2. Scroll down to the *Board:* entry (i.e. *Board: Arduino/Genuino Uno*).
 3. A submenu will open when you highlight the *Board:* entry.
 4. At the top of the submenu is *Boards Manager*. Click on it to open the Boards Manager dialog box.
   ![gestionnaire de cartes](gestionnaire de cartes.png)
 5. In the search box in the Boards Manager enter “*esp32*”.
   ![gestionnaire de carte window](gestionnaire de carte window.png)
 6. You should see an entry for “*esp32 by Espressif Systems*”. Highlight this entry and click on the *Install* button.
 7. This will install the ESP32 boards into your Arduino IDE
 ###Selecting the right board and port
 1 - Once your board library is installed, you can select the board in the board manager. Select either esp32 Dev Board or Node32s
 ![Capture d’écran to show how to select right board](Capture d’écran 2021-10-24 à 14.45.11.png)
 2 - Then you can select on which port it will be communicating (the USB port)
 ![Capture d’écran to show which port to use](Capture d’écran 2021-10-24 à 14.46.22.png)
 Now you are ready to create script and upload them to your microcontroller ! Well done.
 ## Using esp-32 touch sensor with a crocodile cable
 ###Sensing electricity
 Here is the code you want to put in your arduino IDE before sending it to your esp-32
 ```c
 int touch_sensor_value=0;
 void setup()
 {
 Serial.begin(115200);
 Serial.println("Touch sensor - ESP32 - electric feel");
 }
 void loop()
 {
 touch_sensor_value = touchRead(T0);
 Serial.print("It can feel = ");
 Serial.println( touch_sensor_value);
 delay(1000);
 }
 ```
 To make sure that you made no mistake you can check it first with the little checkmark button before sending it with the little arrow.
 In order to know wether your touch sensor and your code is running, you need to open your serial monitor. It is a tool that let you peak into the conversation between the esp32 and your computer.
 In order to do this go to Tool>Serial Monitor
 If all go well you should be able to see the values of your touch sensor.
 Now if we detail this script:
 **1- Enummerating the actors in our process.** 
 We first declare a variable, something that will be monitored, something that exists for the esp32, in our case the value of the sensor, how much electricity. At the beggining of the process, it is zero.
 `int touch_sensor_value=0;`
 **2- Setting the stage.** 
 void setup is a way to start the command of the esp-32, it will only be run once.
 `void setup()`
 `{`
 In our case, we want to communicate with the esp-32 on the canal that represent the baud frequency of 115200, so in the voice setup we will open this canal.
 `Serial.begin(115200);`
 And in order to make sure that this is open, we will print, say something on it
 `Serial.println("Touch sensor - ESP32 - electric feel");`
 And then we will close this first, setup script.
 `}`
 **3- Describing recurring events/command**
 the stage is set, so now we will describe what we want the controller to continually do. In our case, it is to check the value on the alligator clip and print it in our communication canal, the serial 115200
 The loop is a way to start recurring command, that will be called again and again
 ```
 void loop()
 {
 ```
 inside this loop command we ask the esp-32 to read the value on its sensor attached to its pin T0 and store it in the touch-sensor-value variable. How much electrical energy is there?
 `touch_sensor_value = touchRead(T0);`
 Then we print this value in the serial communication canal
 ```
 Serial.print("It can feel = ");
 Serial.println( touch_sensor_value);
 ```
 And then we let the esp32 rest for a second before starting again from the start of the loop.
 ```
 delay(1000);
 }
 ```
 In order to see what is being printed, we need to open the serial monitor in the Tool section and select baud rate 115200
 ![Capture d’écran to show how to open serial monitor](Capture d’écran 2021-10-24 à 14.47.39.png)
 ![Capture d’écran of the serial monitor](Capture d’écran 2021-10-24 à 14.50.37.png)
 ###Task:
 Find your own way to ask (or not) for permission to attach the alligator clip to the plant. Do not attach the clip directly as it closes quite strongly, attache a piece of coil that you put around the trunk.
 *"Asking permission shows respect for the personhood of the plant, but it  is also an assessment of the well-being of the population. Thus I must  use both sides of my brain to listen to the answer. The analytic left  reads the empirical signs to judge whether the population is large and  healthy enough to sustain a harvest, whether it has enough to share. The intuitive right hemisphere is reading something else, a sense of  generosity, an open-handed radiance that says take me, or sometimes a  tight-lipped recalcitrance that makes me put my trowel away. I can’t  explain it, but it is a kind of knowing that is for me just as  compelling as a no-trespassing sign. This time, when I push my trowel  deep I come up with a thick cluster of gleaming white bulbs, plump,  slippery, and aromatic. I hear yes, so I make a gift from the soft old  tobacco pouch in my pocket and begin to dig."*
 Braiding sweetgrass
 If you feel like it gave it to you, attach the clip to the plant and check the behavior when you touch the plant on a the trunk, on the leaf, near the soil.
 ![Alligator clip attached to the G0 of a esp32 microcontroller on a table with cables in the background](IMG_1566.png)
 -> as you can see the alligator clip **is connected to G4 which is touch 0** **(T0)** on this pin-out diagram
 ###![schematic of an esp-32 pinout](esp-32-pinout_bigger.png)Making text appear whenever the sensor is touched
 So now we can see the value on the alligator clip. We now want to use this information to trigger a behaviour, whenever the value drops under a certain level, we want to display a text:
 ```c
 int touch_sensor_value=0;
 void setup()
 {
 Serial.begin(115200);
 Serial.println("Touch sensor - ESP32 - electric feel");
 }
 void loop()
 {
 touch_sensor_value = touchRead(T0);
 Serial.print("It can feel = ");
 Serial.println( touch_sensor_value);
 if (touch_sensor_value<40){
 Serial.println("     | ");  
 Serial.println("   <>|<> ");  
 Serial.println("  <>~|~<> "); 
 Serial.println("<>~<>|<>~<>  ");
 Serial.println("<>~<>|<>~<>  ");
 Serial.println("  <>~|~<> "); 
 Serial.println("     |  "); 
 Serial.println("     |  "); 
 Serial.println("For each of us as women, there is a dark place within, where hidden and growing our true spirit rises");
 Serial.println("\"beautiful/and tough as chestnut/stanchions against (y)our nightmare of weakness/\"** and of impotence.");
 Serial.println("Audre Lorde");
 Serial.println("     | ");  
 Serial.println("   <>|<> "); 
 Serial.println("  <>~|~<> "); 
 Serial.println("<>~<>|<>~<>  ");
 Serial.println("<>~<>|<>~<>  ");
 Serial.println("  <>~|~<> "); 
 Serial.println("     |  "); 
 Serial.println("     |  "); 
 delay(10000);
 } 
 else { 
 Serial.println("    ~|~ "); 
 Serial.println("  ~  | ~  ");
 Serial.println("  ~  |  ~    ");
 Serial.println("    ~|~   "); 
 Serial.println("     |  "); 
 Serial.println("     |  "); 
 } 
 delay(1000);
 }
 ```
 What we do first is getting the value of the sensor:
 ```c
 touch_sensor_value = touchRead(T0);
 Serial.print("It can feel = ");
 Serial.println( touch_sensor_value);
 ```
 Then we add a condition that says : if the value is inferior to 10, then print this message, if it is superior, print this other message.
 We do this as follows.
 We first open the condition
 `if (touch_sensor_value<40){`
 Then we print the message (the tree is just aesthetically pleasing)
 ```
 Serial.println("For each of us as women, there is a dark place within, where hidden and growing our true spirit rises");
 Serial.println("\"beautiful/and tough as chestnut/stanchions against (y)our nightmare of weakness/\"** and of impotence.");
 ```
 Then we close this condition
 `}`
 And we add another statement for all other cases that do not conform to this first condition
 ```
 else { 
 Serial.println("    ~|~ "); 
 [....]
 }
 ```
 ###Task
 Come up with your own text and illustrative elements when the plant is touched. Code your own behaviour for the interaction.
 ## Using esp-32 with a moisture sensor
 To use the esp-32 with a moisture sensor, we do a similar exercise, with the addition of  an electrical circuit for the soil moisture sensor, which needs to be electrified itself, hence we must connect it to a pin that gives it a current of 5V and a pin that gives it a ground.
 Once this is done, here is the code to read the output
 ```c
 int SENSE= 2; // Soil Sensor input at Analog PIN A0 
 int value= 0;
 void setup() {
 Serial.begin(9600);
 Serial.println("SOIL MOISTURE SENSOR"); 
 Serial.println("-----------------------------");
 }
 void loop() {
 value= analogRead(SENSE); 
 value= value/10; 
 Serial.println(value); 
 }
 ```
 ![an esp32 micro-controller with dupont cables one yellow linked to pin g2 and one grey gnd, in the background there is a moisture sensor](IMG_1564.png)
 ![an esp-32 controller with an orange cable tied to pin V5, there is a plate with a leaf in the background and a small aluminium corner of a macbook pro](IMG_1565.png)
 ## Creating a webserver with the esp-32
 In our last task, we are gonna set-up a web server that runs autonomously on the esp-32 and that can react to the touch or the soil moisture.
 MAYBE WITHOUT HTML AT FIRST?
 ```c
 #include <WiFi.h>
 #include <WebServer.h>
 // SSID & Password
 const char* ssid = "Plant_poem";  // Enter your SSID here
 const char* password = "";  //Enter your Password here
 // IP Address details
 IPAddress local_ip(192, 168, 1, 1);
 IPAddress gateway(192, 168, 1, 1);
 IPAddress subnet(255, 255, 255, 0);
 WebServer server(80);  // Object of WebServer(HTTP port, 80 is default)
 // HTML & CSS contents which display on web server
 String HTML = "<!DOCTYPE html>\
 <html>\
 <body>\
 <h1>    &#127811; Hello There  &#127811;;</h1>\
 </body>\
 </html>";
 void setup() {
  Serial.begin(115200);
  // Create SoftAP
  WiFi.softAP(ssid, password);
  WiFi.softAPConfig(local_ip, gateway, subnet);
  Serial.print("Connect to My access point: ");
  Serial.println(ssid);
  server.on("/", handle_root);
  server.begin();
  Serial.println("HTTP server started");
  delay(100);
 }
 void loop() {
  server.handleClient();
 }
 // Handle root url (/)
 void handle_root() {
  server.send(200, "text/html", HTML);
 }
 ```
 ###Detailling the process
 **0- Calling libraries**
 ```c
 #include <WiFi.h>
 #include <WebServer.h>
 ```
 This first part will include some code that is placed in another file and that will allow us to go quicker by using functions already written by other people
 **1- Enummerating/presenting the actors in our process.** 
 ```c
 // SSID & Password
 const char* ssid = "Plant_poem";  // Enter your SSID here !to change!
 const char* password = "";  //Enter your Password here !leave empty!
 // IP Address details
 IPAddress local_ip(192, 168, 1, 1);
 IPAddress gateway(192, 168, 1, 1);
 IPAddress subnet(255, 255, 255, 0);
 WebServer server(80);  // Object of WebServer(HTTP port, 80 is default)
 // HTML & CSS contents which display on web server
 String HTML = "<!DOCTYPE html>\
 <html>\
 <body>\
 <h1>    &#127811; Hello There  &#127811;;</h1>\
 </body>\
 </html>";
 ```
 Here we first declare two variables, which are gonna be the name of the network of your network and its password
 The second paragraph is about the adress of your network, its IP adress, to what you will connect to see your website
 The third paragraph is the content of your website, here in html
 **2- Setting the stage.** 
 ```c
 void setup() {
  Serial.begin(115200);
  // Create SoftAP
  WiFi.softAP(ssid, password);
  WiFi.softAPConfig(local_ip, gateway, subnet);
  Serial.print("Connect to My access point: ");
  Serial.println(ssid);
  server.on("/", handle_root);
  server.begin();
  Serial.println("HTTP server started");
  delay(100);
 }
 ```
 Here we are gonna first open the communication canal for baud rate 115200
 Then create our own Wi-Fi access point using the variable we declared in the previous step and let know the user by printing a statement on the communication canal
 Then we will specify what happens on the "/" adress of our server. Here we call another function called handle_root . the behavior of this function will be explained in the next step.
 Then activate our server and let it know through the communication canal
 **3- Describing recurring events/command**
 ```c
 void loop() {
  server.handleClient();
 }
 ```
 Here we ask the controller to handle the client (your browser) so it can access the server.
 **4- special function - handle root**
 ```c
 // Handle root url (/)
 void handle_root() {
  server.send(200, "text/html", HTML);
 }
 ```
 This function details what is happening when someones connect to 192.168.1.1 without any character after this (the root address)
 ### How to add touch sensor to this code?
 In order to add a sensor to the code we must:
 1- introduce its name
 2- make the script check for its value chronically
 3- use this always updated value in a if statement
 How would that look? Can you point out the steps in the code below?
 ```c
 #include <WiFi.h>
 #include <WebServer.h>
 // SSID & Password
 const char* ssid = "Plant_poem";  // Enter your SSID here
 const char* password = "";  //Enter your Password here
 int touch_sensor_value=0;
 // IP Address details
 IPAddress local_ip(192, 168, 1, 1);
 IPAddress gateway(192, 168, 1, 1);
 IPAddress subnet(255, 255, 255, 0);
 WebServer server(80);  // Object of WebServer(HTTP port, 80 is default)
 // HTML & CSS contents which display on web server
 String HTML = "<!DOCTYPE html>\
 <html>\
 <body>\
 <h1>    &#127811; we learn to bear the intimacy of scrutiny and to flourish within it &#127811;;</h1>\
 </body>\
 </html>";
 void setup() {
  Serial.begin(115200);
  // Create SoftAP
  WiFi.softAP(ssid, password);
  WiFi.softAPConfig(local_ip, gateway, subnet);
  Serial.print("Connect to My access point: ");
  Serial.println(ssid);
  server.on("/", handle_root);
  server.begin();
  Serial.println("HTTP server started");
  delay(100);
 }
 // Handle root url (/)
 void handle_root() {
  if (touch_sensor_value<40){
  server.send(200, "text/html", HTML);
  }
  else { 
 Serial.println("Nothing to print here    ~|~ "); 
 } 
 }
 void loop() {
  server.handleClient();
  touch_sensor_value = touchRead(T0);
 Serial.print("It can feel = ");
 Serial.println( touch_sensor_value);
 }
 ```
 ###Task
 How would you do the same with the soil moisture sensor? How can you combine the two?
 ##Technical links
 [Espressif documentation on esp-32](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/establish-serial-connection.html)
 [How to use esp-32 as a touch sensor](https://microcontrollerslab.com/esp32-touch-sensor-button-example/)
 [Driver for the esp-32](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers)
 [Arduino website for download](https://www.arduino.cc/en/software)
 [esp-32 wifi communication with arduino IDE](https://microcontrollerslab.com/esp32-server-client-wi-fi-communication-arduino-ide/)
 [creating a webserver with esp-32](https://electropeak.com/learn/create-a-web-server-w-esp32/)
 ## Misc links 
 [On mineral necessary for electronics](https://www.dissentmagazine.org/online_articles/the-problem-with-conflict-minerals)
 [the secret life of plants](https://www.youtube.com/watch?v=xvtcA46O-vA) - controversial documentary sometimes dubbed as pseudo-science - for inspiration
 [wikipedia on the secret life of plants](https://en.wikipedia.org/wiki/The_Secret_Life_of_Plants)
 [Supply chain analysis for minerals needed for electronics](https://www.dissentmagazine.org/online_articles/the-problem-with-conflict-minerals)
 [tree thinking](https://placesjournal.org/article/tree-thinking/)
 [Jagadish Chandra Bose](https://en.wikipedia.org/wiki/Jagadish_Chandra_Bose)
 [Chaine d'approvisionnement de plusieurs matériaux d'un ordinateur](https://supplystudies.com/manifest/#manifest-https://supplystudies.com/manifest/json/samples/typical-laptop.json)
 [Francis Hallé on specific trees](https://thereader.mitpress.mit.edu/walking-trees-parasitic-flowers-remarkable-plants-illustrated-guide)
 ##Music
 [Mall Grab - Spirit Wave](https://open.spotify.com/track/5zfDn2VAMkLya9CRKEYZyb?si=c8a501261b734c9e)
 [Soichi Terada - Bamboo fighter](https://open.spotify.com/track/0QKc8g97mQsbybkvHYN2Bi?si=f2956b81b57c4c58)
 [Susobrino - La hoja de eucalipto](https://open.spotify.com/track/5jWvkNfoQW1A42btmzJinP?si=934bdf4d871d48df)
 [Stevie Wonder - the secret life of plants](https://open.spotify.com/album/3LSgLZrSXELqWt5eqb6XMY?si=y25zwRzbQlCJFWJiFTcAUA)
--- a/Saint-Luc_Guillaume/Algolit.md
+++ b/Saint-Luc_Guillaume/Algolit.md
@ -1,265 +0,0 @@
 ---
 type: slide
 slideOptions:
  transition: slide
 ---
 <style>
  @font-face {
    font-family: 'Fantasque-Bold';
    font-style: bold;
    font-weight: normal;
    src: local('Fantasque-Bold'), local('FantasqueSansMono-Bold'),
      url(https://www.algolit.net/skins/foreground/assets/fonts/fantasque/FantasqueSansMono-Bold.ttf?a4603) format('woff2');
  }
@font-face {
 font-family:'Fantasque-Regular';
 src:local('Fantasque-Regular'), local('FantasqueSansMono-Regular'),
     url(https://www.algolit.net/skins/foreground/assets/fonts/fantasque/FantasqueSansMono-Regular.ttf?f3fdc);
 font-weight:normal;
 font-style:normal
 }
 body {
   font-family: Fantasque-Regular !important;
 }
 h1, h2, h3, h4, h5, h6
 {
    font-family: "Fantasque-Regular", Helvetica, "Liberation Sans", Calibri, Arial, sans-serif; /* Sans-serif headers */
    /* font-family: "Fantasque-Regular", "Georgia", "Times New Roman", serif; /* Serif headers */
    page-break-after: avoid; /* Firefox, Chrome, and Safari do not support the property value "avoid" */
 }
 </style>
 ****************
 <h1 style="text-align: center; font-family: Fantasque-Bold"> Algolit</h1>
 ****************
 ---
 <h2 style="text-align: center"> Qu'est ce qu'algolit?</h2>
 ---
 <p style="text-align: center; font-family: Fantasque-Regular"> Litterature electronique, code libre et textes</p>
  <aside class="notes">
 Algolit est un groupe artistique qui se réunit une fois par mois à Bruxelles autour de la littérature électronique, de l'open source et des textes. Comme vous l'avez peut-être deviné, le nom est une combinaison d'"algorithmes" et de "littérature".
  </aside>
 ---
 <aside class="notes">
 Algolit a été initié en 2012 par les auteurs An Mertens et Catherine Lenoble, comme un projet de Constant. Constant est une organisation à but non lucratif, gérée collectivement par des artistes. Il se concentre sur les pratiques artistiques à travers les logiciels et licences libres.
    </aside>
 ![site internet du groupe artistique Constant](https://algolit.net/images/constant.png)
 ---
 <aside class="notes">
 En tant que groupe de travail, nous fonctionnons sur une base volontaire. Nous nous réunissons une fois par mois pour une journée complète. En général, quelqu'un prépare un sujet pour la session, puis nous passons le reste de la journée à explorer le code et les recettes. Nous essayons de comprendre les règles de l'algorithme et de les appliquer à un autre sujet. Chaque participant arrive avec ses connaissances, ses désirs et ses besoins, et contribue comme il l'entend. 
     </aside>
 ![groupe d'humains assis à une table, dans le fond, un paysage urbain](https://www.paramoulipist.be/wp-content/uploads/2018/10/2_an-algolit.jpg)
 ---
 <aside class="notes"> 
 hack 
 </aside>
 ---
 <aside class="notes">
 Le programme est annoncé ici. Après chaque session, nous partageons également les notes. Les participants viennent de l'écriture, de l'activisme, de la programmation, de la conception graphique, de l'art sonore et de l'art visuel. 
    </aside>
 ![site internet du groupe d'artistes algolit](https://algolit.net/images/algolit_website.png)
 ---
 <aside class="notes"> 
 Le fonctionnement d'Algolit est basé sur les méthodes de l'Oulipo.  
 L'Oulipo (abréviation française : "Ouvroir de littérature potentielle") a été créé dans les années 1960 à Paris par les écrivains Raymond Queneau et François Le Lionnais. Ils créent des œuvres en utilisant des techniques d'écriture restrictives. 
 </aside>
 ![Photo d'un groupe d'humains, certains assis autours d'une table, la plupart en chemise, dans ce qui parait être une cour avec des plantes autour](https://external-content.duckduckgo.com/iu/?u=http%3A%2F%2Fwww.diptyqueparis-memento.com%2Fwp-content%2Fuploads%2F2016%2F07%2F06-Meeting-of-the-Oulipo-in-Boulogne.jpg&f=1&nofb=1)
 ---
 <aside class="notes"> 
 L'un des membres du groupe est Georges Perec qui a écrit un roman entier sans utiliser la lettre e dans "La Disparition". 
    </aside>
 ![page de garde du roman la disparition de Georges Perec](https://external-content.duckduckgo.com/iu/?u=http%3A%2F%2Fimg.xcitefun.net%2Fusers%2F2013%2F11%2F342731%2Cxcitefun-la-disparition-book.jpg&f=1&nofb=1)
 ---
 <aside class="notes"> 
 Dans "Tentative d'épuisement d'un lieu parisien", il a entrepris d'écrire tout ce qu'il a vu en restant assis sur un banc de la rue parisienne pendant une journée.   
 ALgolit comprend la notion de littérature comme les membres de l'Oulipo : il peut s'agir de n'importe quel type de texte, y compris la Bible, les conditions d'utilisation de Google, les numéros de téléphone, les tickets de caisse des supermarchés...
 </aside>
 ![Page de garde du roman tentative d'épuisement d'une rue Parisienne par Georges Perec](https://bourgoisediteur.fr/wp-content/uploads/2020/04/Perec-Tentative-depuisement-Titres-e1588177193188.jpg)
 ---
 <aside class="notes"> 
 Chez Algolit, nous essayons de rendre les contraintes du code visibles à travers le travail que nous faisons.
 En programmation, les contraintes sont nombreuses ; c'est un contexte qui offre de nombreuses possibilités d'expérimentation. Algolit a essayé depuis le début de s'engager auprès du code comme un moyen de faire des œuvres qui visualisent ses contraintes.
 Au départ, nous nous sommes inspirés des contraintes existantes de l'Oulipo.
 Exemple : littérature définitionnelle
 </aside>
 ![Capture d'écran du site oulipo avec une définition d'une des techniques](https://algolit.net/images/oulipo.png)
 ---
 <aside class="notes"> 
 Nous nous sommes ensuite concentrés sur la perspective narrative des algorithmes existants, tels que la chaîne de Markov.
 </aside>
 ![photos de mains triant des cartes sur lesquelles on voit des mots manuscrits](https://www.paramoulipist.be/wp-content/uploads/2017/03/markov-768x576.jpg)
 ---
 <aside class="notes"> 
 Plus tard, nous avons également décidé de nous consacrer à l'apprentissage automatique et aux réseaux de neurones artificiels. Parfois, nos expériences se traduisent par des créations que nous montrons dans des expositions.
 </aside>
 ![gif montrant une femme touchant un écran avec trois personnes autour](https://gitlab.com/guillaume_slizewicz/blog/-/raw/master/static/img/gif_algolit/Une_anthologie_2_low_l.gif)
 ---
 <aside class="notes"> 
  Nous utilisons un code gratuit ou open source, ou nous écrivons notre propre code. Si nous pouvons apprendre à lire et à écrire dans le contexte d'Algolit, c'est grâce aux chercheurs universitaires qui partagent leurs résultats dans des articles ou publient leur code en ligne. En tant qu'artistes, nous pensons qu'il est important de partager cette attitude. C'est pourquoi nous documentons nos réunions. Nous partageons les notes des sessions. Pour cela, nous utilisons le logiciel libre Etherpad, qui nous permet d'écrire collectivement.
    </aside>
 ![gif montrant un notebook etherpad se remplissant](https://gitlab.com/guillaume_slizewicz/blog/-/raw/master/static/img/gif_algolit/algopad.gif)
 ---
 <aside class="notes"> 
 Nous publions également le code dans notre dépôt Gitlab sous des licences libres.
    </aside>
 ![capture d'écran du site gitlab et d'un dossier d'algolit](https://algolit.net/images/Algolit_gitlab.png)
 ---
 <aside class="notes"> 
 Et voici un générateur de texte basé sur une chaîne de markov, un algorithme simple, qui utilise nos notes comme données pour créer de petits haïkus.
 </aside>
 ![gif présentant une série de haiku produit par une chaine de markov par algolit](https://gitlab.com/guillaume_slizewicz/blog/-/raw/master/static/img/gif_algolit/algomarkpad.gif)
 ---
 <h2 style="text-align: center; font-family: Fantasque-Regular"> Moments publics</h2>
 ---
 <h3 style="text-align: center; font-family: Fantasque-Regular"> Rencontres algoliteraires  </h3>
 <h3 style="text-align: center; font-family: Fantasque-Regular"> Algoliterary Encounters </h3>
 <aside class="notes"> 
     Nous avons également organisé des expositions.
 La première s'est déroulée dans une bibliothèque publique de Bruxelles, en novembre 2017. C'était une première tentative de partager nos expériences avec l'apprentissage automatique. Nous avons montré des jeux de données existants et utilisés par de nombreux algorithmes, comme GLOVE de l'Université de Stanford, ou des jeux de données que nous avons créés nous-mêmes. Par exemple, nous avons inventé une technique avec des tableaux pour expliquer les différentes étapes de la technique des "word embeddings", une technique de modélisation du langage qui permet de représenter les mots dans un espace vectoriel multidimensionnel et de générer des règles de "grammaire" propres à la machine.
    </aside>
 ---
 ![2 murs à un mètre de distance placardés de feuilles écrites](http://gallery.constantvzw.org/var/albums/Algoliterary-Encounter/PWFU4619.JPG?m=1510310403)
 ---
 ![plusieurs tables sur lesuqelles sont présentés des feuilles imprimés, en face desquelles un groupe d'une dizaine de personnes est debout](https://gallery.constantvzw.org/var/albums/Algoliterary-Encounter/PWFU4639.JPG?m=1510310445)
 ---
 <h3 style="text-align: center; font-family: Fantasque-Regular"> Data Workers</h3>
 ---
 ![poster de l'exposition data worker par algolit](https://www.algolit.net/images/1/1d/Data-workers_poster_square.jpg )
 <aside class="notes"> 
 Nous avons poursuivi ce travail d'exploration artistique et créé une deuxième exposition, plus cohérente dans sa forme et son contenu. Nous l'avons appelé "Data Workers". L'itinéraire a suivi les différentes phases nécessaires à la création d'un modèle informatique linguistique. Il y avait "les nettoyeurs", "les informateurs", "les lecteurs", "les apprenants" et les modèles formés que nous appelons "les Oracles".
    L'exposition a eu lieu au Mundaneum pendant un mois en avril 2019. Elle s'est terminée par une présentation et un atelier d'Allison Parrish. Célèbre poétesse Américaine
    </aside>
 ---
 <aside class="notes"> 
 Le lieu de l'exposition, Le Mundaneum, était un projet de deux avocats belges, Paul Otlet et Henri Lafontaine. Au début du XXe siècle, ils ont voulu créer un centre de documentation universel, où ils rassembleraient et classeraient toutes les connaissances du monde.  
 Les archives du Mundaneum sont situées à Mons, dans le sud de la Belgique. Ils sont présentés comme les précurseurs de Google - qui a réussi à installer un centre de données dans la même ville - avec un peu de marketing urbain par la suite. Pour Algolit, le lieu était emblématique de l'exposition. L'ensemble du discours repose sur la pensée universaliste occidentale qui a cherché à catégoriser, documenter et enregistrer la totalité du monde afin de nourrir la notion de progrès, sans tenir compte de la violence que la classification peut entraîner. Cette vision est toujours présente dans le Mundaneum, comme dans de nombreuses autres collections d'archives.
 Et cela correspond tout à fait aux développements actuels dans le domaine de l'apprentissage automatique, où la phrase "plus de données feront un meilleur modèle" est devenue un mantra et où les algorithmes amplifient et renforcent les catégories existantes.
    </aside>
 ![photo du mundaneum dans laquelle on voit plusieurs femmes en train de travailler ainsi qu'un homme au milieu](https://img.over-blog-kiwi.com/1/49/30/83/20150518/ob_a3d6b8_employe-s-du-mundaneum-image-d-arch.jpg)
 ---
 ![oeuvre de Christina Cochior représentant les différent jeux de données utilisé dans le monde. Des cartes sont disposés sur des tiroirs entrouverts](https://www.paramoulipist.be/wp-content/uploads/2019/03/87C2342_javi-1024x677.jpg)
 <aside class="notes"> 
 Non seulement nous montrons des installations sur écran, mais nous essayons également d'incorporer des œuvres physiquement dans l'espace.
 Cette image est une création de Cristina Cochior qui donne forme aux différents ensembles de données. Vous pouvez voir les tiroirs qui sortent de l'armoire. La taille de l'ouverture du tiroir est liée au nombre de mots dans l'ensemble de données.
    </aside>
 ---
 ![photographie de l'exposition data workers. Un grand globe terrestre est entouré de feuilles qui paraissent en lévitations ainsi que de deux écran à forte luminosité](http://gallery.constantvzw.org/var/albums/Data%20Workers/data_workers-71.jpg?m=1554029132 )
 <aside class="notes"> 
 L'Algoliterator est un réseau neuronal formé sur des textes numérisés. Voici une installation utilisant les œuvres complètes de Jules Vernes.
 L'Algoliterator sélectionne une phrase dans le corpus et continue à écrire seul. 
 Le réseau génère trois nouveaux fragments à partir des phrases qu'il a lues. Il peut contrôler le niveau d'apprentissage du réseau et lui faire générer des phrases sur la base d'un apprentissage primitif, intermédiaire ou final.
 Une fois le nouveau texte généré, vous pouvez l'imprimer et l'emporter chez vous comme souvenir. Nous utilisons une imprimante thermique ou parfois, comme le montre l'image ci-dessous, un traceur automatique.
    </aside>
 ---
 ![gif présentant l'oeuvre algolittérateur d'algolit](https://gitlab.com/guillaume_slizewicz/blog/-/raw/master/static/img/gif_algolit/Algoliterator.gif)
 ---
 ![petit robot à coté d'un écran](https://algolit.net/images/thumb/a/a2/MG_3040_algoliterator1.jpg/800px-MG_3040_algoliterator1.jpg)
 ---
 ![traceur automatique qui écrit avec une écriture qui semble humaine pour glossolalie et barbarisme d'algolit](https://gitlab.com/guillaume_slizewicz/blog/-/raw/master/static/img/mdl/low_res/algolit_mdl-28_low.jpg)
 ---
 <h2 style="text-align: center; font-family: Fantasque-Regular"> Conclusion</h2>
 <aside class="notes"> 
 * Échouer
 * Donner une voix artistique à cette grande population d'agents invisibles mais très performants dans le monde d'aujourd'hui.
 En conclusion, nous pensons qu'il est important de mentionner qu'avec Algolit nous nous sommes permis d'échouer. Parfois avec grâce, parfois de façon absurde. Nous ne prétendons pas que l'algorithme réussit, mais nous observons les étapes qu'il franchit pour arriver à une réponse et nous observons le résultat des itérations.
 Nous préférons souvent rester dans les espaces où les prédictions ne fonctionnent pas. Nous préférons observer les moments où cette hypothèse échoue. Nous préférons souvent utiliser de petits ensembles de données plutôt que d'investir dans Amazon avec des formations énormes.
 Nous préférons comprendre les algorithmes tels qu'ils sont, et les montrer de manière "nue". De cette façon, nous donnons une voix à une large population d'agents invisibles mais très performants dans le monde d'aujourd'hui.
--- a/Saint-Luc_Guillaume/IMG_1561.png
+++ b/Saint-Luc_Guillaume/IMG_1561.png
--- a/Saint-Luc_Guillaume/IMG_1562.png
+++ b/Saint-Luc_Guillaume/IMG_1562.png
--- a/Saint-Luc_Guillaume/IMG_1563.png
+++ b/Saint-Luc_Guillaume/IMG_1563.png
--- a/Saint-Luc_Guillaume/IMG_1564.png
+++ b/Saint-Luc_Guillaume/IMG_1564.png
--- a/Saint-Luc_Guillaume/IMG_1565.png
+++ b/Saint-Luc_Guillaume/IMG_1565.png
--- a/Saint-Luc_Guillaume/IMG_1566.png
+++ b/Saint-Luc_Guillaume/IMG_1566.png
--- a/Saint-Luc_Guillaume/Une
+++ b/Saint-Luc_Guillaume/Une
@ -1,644 +0,0 @@
 # Une bibliothèque vivante de plantes
 [TOC]
 ## Concept
 ### Inspiration
 De l'électro-culture aux récentes expériences de touché, les utilisations de l'électricité pour connecter et favoriser notre relation avec les plantes sont nombreuses.
 ![électro-culture : deux plantes, l'une avec électrode, l'autre sans. Illustration d'une expérience visant à prouver l'efficacité de la culture des plantes à l'électricité ](https://upload.wikimedia.org/wikipedia/commons/2/2d/EKult022.jpg)
 [*électroculture : deux plantes, l'une avec électrode, l'autre sans. Illustration d'une expérience visant à prouver l'efficacité de la culture des plantes à l'électricité* ](https://fr.wikipedia.org/wiki/%C3%89lectroculture#/media/Fichier:EKult022.jpg)
 Nous poursuivons ici cette tradition, comme une façon de donner du sens à la technologie dont nous disposons, et comme excuse pour passer du temps avec les plantes.
 ### Déroulement
 L'atelier une bibliothèque vivante de plantes a pour but de relier les textes, les arbres et les humains grâce à l'utilisation du microcontrôleur ESP32.
 L'idée est de créer un petit point d'accès wifi, lié à une plante, qui publiera différents textes en fonction de sa conductance et de l'humidité de son sol.
 ## set-up (30 minutes de souffrance, tenez bon)
 ### Éléments nécessaires
 Pour participer à cet atelier, vous aurez besoin :
 un microcontrôleur esp32 : pour cet atelier nous avons utilisé celui proposé par [AZdelivery](https://www.az-delivery.de/en/products/esp32-developmentboard)
 un câble microUSB
 un capteur d'humidité du sol avec des câbles Dupont
 un câble crocodile/une pince crocodile
 ### Installation de l'IDE Arduino
 Pour cet atelier, nous utiliserons l'IDE Arduino. Il s'agit d'un IDE (Integrated Development Environment - environnement de programmation intégré) open source et facile à utiliser pour télécharger du code vers un microcontrôleur. Il a été développé pour une gamme de microcontrôleurs également appelés arduino (c'est pourquoi il peut prêter à confusion). On parle bien ici du software et non du hardware
 Pour l'installer, [vous pouvez suivre ce lien](https://www.arduino.cc/en/software) et cliquer sur le lien de téléchargement adapté à votre système d'exploitation (macOS, windows ou Linux)
 ### Installation du pilote USB de l'esp32
 L'esp32 est un microcontrôleur, ce qui signifie qu'il peut effectuer des tâches informatiques simples comme lire un capteur, imprimer un message sur un canal de communication ou effectuer des opérations mathématiques.
 L'ESP32 n'est pas une carte arduino traditionnelle et nécessite l'installation d'un pilote spécifique pour pouvoir communiquer avec votre ordinateur. Un driver/pilote est un petit programme qui va permettre la communication entre votre ordinateur et un autre périphérique, en d'autres termes, il va permettre à votre ordinateur de reconnaître l'ESP32.
 Vous pouvez trouver le pilote [sur ce site] (https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers), sélectionnez le lien correspondant à votre système d'exploitation (macOS, Windows, Linux) et suivez les instructions.
 ### Installation de la bibliothèque pour esp32 sur l'IDE arduino 1/2
 Maintenant votre ordinateur reconnaît l'esp32, mais l'IDE arduino doit savoir quelle langue lui parler. Pour que les deux communiquent de manière fluide, nous devons installer une bibliothèque pour l'esp32 sur l'IDE arduino.
 1. Ouvrez l'IDE Arduino. Assurez-vous que vous êtes à la version 1.8 ou plus, si non, mettez à jour votre IDE avec la dernière version.
 2. Cliquez sur le menu *File* dans la barre de menu supérieure.
 3. Cliquez sur l'élément de menu *Préférences*. Cela ouvrira une boîte de dialogue de préférences.
   <img src="preference.png" alt="preference" style="zoom : 50% ;" />
 4. Vous devriez être sur l'onglet *Paramètres* de la boîte de dialogue Préférences par défaut.
 5. Recherchez la zone de texte intitulée "*Additional Boards Manager URLs*".
 6. S'il y a déjà du texte dans cette zone, ajoutez une virgule à la fin de celui-ci, puis suivez l'étape suivante.
 7. Collez le lien suivant dans la zone de texte - ***https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json***
 8. Cliquez sur le bouton OK pour enregistrer le paramètre. 
 ![preference_window](preference_window.png)
 ### Installation de la bibliothèque pour esp32 sur l'IDE arduino 2/2 
 Ensuite, vous devrez utiliser la nouvelle entrée pour ajouter les cartes ESPO32 à votre IDE Arduino. Pour ce faire, suivez cette procédure :
 1. Dans l'IDE Arduino, cliquez sur le menu *Tools* dans la barre de menu supérieure.
 2. Faites défiler vers le bas jusqu'à l'entrée *Board:* (c'est-à-dire *Board : Arduino/Genuino Uno*).
 3. Un sous-menu s'ouvre lorsque vous mettez en évidence l'entrée *Board:*.
 4. En haut du sous-menu se trouve *Boards Manager*. Cliquez dessus pour ouvrir la boîte de dialogue Boards Manager.
   ![gestionnaire de cartes](gestionnaire de cartes.png)
 5. Dans la boîte de recherche du gestionnaire de cartes, entrez "*esp32*".
   ![gestionnaire de carte window](gestionnaire de carte window.png)
 6. Vous devriez voir une entrée pour "*esp32 by Espressif Systems*". Mettez cette entrée en surbrillance et cliquez sur le bouton *Installer*.
 7. Ceci va installer les cartes ESP32 dans votre IDE Arduino.
 ### Sélection de la bonne carte et du bon port
 1 - Une fois que votre bibliothèque de cartes est installée, vous pouvez sélectionner la carte dans le gestionnaire de cartes. Sélectionnez soit esp32 Dev Board, soit Node32s.
 ![Capture d'écran pour montrer comment sélectionner la bonne carte](bonne_carte.png)
 2 - Ensuite vous pouvez sélectionner sur quel port il va communiquer (le port USB)
 ![Capture d'écran pour montrer quel port utiliser](bon_port.png)
 Maintenant vous êtes prêt à créer des scripts et à les télécharger sur votre microcontrôleur ! Bien joué.
 ## Utilisation d'un capteur tactile ESP32 avec un câble crocodile (30-45 minutes)
 ### Détection de l'électricité
 Voici le code que vous devez mettre dans votre IDE arduino avant de l'envoyer à votre esp-32
 ```
 int touch_sensor_value=0;
 void setup()
 {
 Serial.begin(115200);
 Serial.println("Touch sensor - ESP32 - electric feel");
 }
 void loop()
 {
 touch_sensor_value = touchRead(T0);
 Serial.print("Nous pouvons sentir = ");
 Serial.println( touch_sensor_value);
 delay(1000);
 }
 ```
 Pour vous assurer que vous n'avez pas fait d'erreur, vous pouvez d'abord vérifier avec le petit bouton avec une marque cochée. 
 ![Capture de l'IDE arduino avec la marque cochée entourée de rouge](arduino_check.png)
 Si vous n'avez pas d'erreur, vous pouvez l'envoyer avec le bouton flèche.
 ![Capture d’écran de l'IDE d'arduino avec la marque flèche entouré de rouge](arduino_arrow.png)
 ### Brancher le capteur
 Avant de brancher votre capteur, **débranchez votre carte esp-32.**
 ![Pince crocodile attachée au G0 d'un microcontrôleur esp32 sur une table avec des câbles en arrière-plan](IMG_1566.png)
 -> comme vous pouvez le voir la pince crocodile **est connectée à G4 qui est la touche 0** **(T0)** sur ce schéma de brochage
 ![schéma d'un pinout esp-32](esp-32-pinout_bigger.png)
 Une fois votre capteur branché, vous pouvez brancher l'esp-32 par usb.
 Afin de savoir si votre capteur tactile et votre code fonctionnent, vous devez ouvrir votre moniteur série. C'est un outil qui vous permet de voir la conversation entre l'esp32 et votre ordinateur.
 Pour ce faire, allez dans Tool>Serial Monitor.
 Si tout va bien, vous devriez être capable de voir les valeurs de votre capteur tactile.
 Maintenant si nous détaillons ce script :
 **1- Sommer les acteurs de notre processus.** 
 Nous déclarons d'abord une variable, quelque chose qui sera surveillé, quelque chose qui existe pour l'esp32, dans notre cas la valeur du capteur, combien d'électricité. Au début du processus, elle est à zéro.
 `int touch_sensor_value=0;``
 **2- Mise en place de la scène.** 
 void setup est un moyen de lancer la commande de l'esp-32, il ne sera exécuté qu'une seule fois.
 `void setup()`
 `{`
 Dans notre cas, nous voulons communiquer avec l'esp-32 sur le canal qui représente la fréquence de baud de 115200, donc dans le setup vocal nous allons ouvrir ce canal.
 ``Serial.begin(115200);``
 Et pour s'assurer que c'est ouvert, on va imprimer, dire quelque chose dessus
 `Serial.println("Touch sensor - ESP32 - electric feel");`
 Et puis nous allons fermer ce premier script de configuration.
 `}`
 **3- Décrire des événements récurrents/commandes**
 Le décor est planté, alors maintenant nous allons décrire ce que nous voulons que le contrôleur fasse continuellement. Dans notre cas, c'est de vérifier la valeur sur la pince crocodile et de l'imprimer dans notre canal de communication, le serial 115200.
 La boucle est un moyen de lancer une commande récurrente qui sera appelée encore et encore.
 ```
 void loop()
 {
 ```
 Dans cette commande en boucle, nous demandons à l'esp-32 de lire la valeur de son capteur relié à sa broche T0 et de la stocker dans la variable touch-sensor-value. Combien d'énergie électrique y a-t-il ?
 `touch_sensor_value = touchRead(T0);`
 Puis nous imprimons cette valeur dans le canal de communication série
 ```
 Serial.print("On peut sentir = ") ;
 Serial.println( touch_sensor_value) ;
 ```
 Et puis nous laissons l'esp32 se reposer une seconde avant de recommencer depuis le début de la boucle.
 ```
 delay(1000) ;
 }
 ```
 Afin de voir ce qui est imprimé, nous devons ouvrir le moniteur série dans la section Outil et sélectionner le débit en bauds 115200
 ![Capture d'écran pour montrer comment ouvrir le moniteur série](serial_baud_1.png)
 ![Capture d'écran du moniteur série](serial_baud_2.png)
 ### Tâche :
 Trouvez votre propre moyen de demander la permission d'attacher la pince crocodile à la plante. N'attachez pas la pince directement car elle se ferme assez fortement, attachez un morceau de bobine que vous mettez autour du tronc.
 *"« Une fois de plus, je demande gentiment la permission de cueillir.
 J’exprime mon respect envers l’identité individuelle de la plante, mais j’évalue aussi le bien-être de sa population. Il me faut consécutivement utiliser les deux hémisphères de mon cerveau pour entendre et écouter la réponse. L’hémisphère gauche, analytique, déchiffre les signes empiriques pour juger si la population est assez nombreuse et en bonne santé pour supporter une récolte, si le poireau a poussé en quantité suffisante pour partager. L’hémisphère droit, intuitif, déchiffre d’autres signes : la générosité, une espèce d’irradiation qui me dit « cueille-le », ou, parfois, une résistance qui me fait aussitôt ranger ma truelle. Je ne peux l’expliquer, c’est une sorte de savoir intuitif qui, à mes yeux, est aussi éloquent qu’un panneau d’interdiction. Cette fois, lorsque j’enfonce ma truelle, j’extrais une belle grappe de bulbes blancs étincelants, dodus, glissants et odorants. J’entends « oui ». Aussitôt, je fais don en sortant du tabac d’un vieux sachet. Après, je creuse. »
 Extrait de: Robin Wall Kimmerer. « Tresser les herbes sacrées. » ".
 Si vous avez l'impression qu'il vous l'a donné, attachez la pince à la plante et vérifiez le comportement lorsque vous touchez la plante sur un tronc, sur une feuille, près du sol.
 ### Faire apparaître du texte à chaque fois que le capteur est touché
 Nous pouvons maintenant voir la valeur sur la pince crocodile. Nous voulons maintenant utiliser cette information pour déclencher un comportement, chaque fois que la valeur descend sous un certain niveau, nous voulons afficher un texte :
 ```c
 int touch_sensor_value=0 ;
 void setup()
 {
 Serial.begin(115200) ;
 Serial.println("Capteur tactile - ESP32 - sensation électrique") ;
 }
 void loop()
 {
 touch_sensor_value = touchRead(T0) ;
 Serial.print("Il peut sentir = ") ;
 Serial.println( touch_sensor_value) ;
 si (touch_sensor_value<40){
 Serial.println(" | ") ;  
 Serial.println(" <>|<> ") ;  
 Serial.println(" <>~|~<> ") ; 
 Serial.println("<>~<>|<>~<> ") ;
 Serial.println("<>~<>|<>~<> ") ;
 Serial.println(" <>~|~<> ") ; 
 Serial.println(" | ") ; 
 Serial.println(" | ") ; 
 Serial.println("Pour chacune d'entre nous en tant que femme, il y a un endroit sombre à l'intérieur, où se cache et grandit notre véritable esprit") ;
 Serial.println("\"belle/et dure comme une châtaigne/stanchions contre (y)notre cauchemar de faiblesse/\"** et d'impuissance.") ;
 Serial.println("Audre Lorde") ;
 Serial.println(" | ") ;  
 Serial.println(" <>|<> ") ; 
 Serial.println(" <>~|~<> ") ; 
 Serial.println("<>~<>|<>~<> ") ;
 Serial.println("<>~<>|<>~<> ") ;
 Serial.println(" <>~|~<> ") ; 
 Serial.println(" | ") ; 
 Serial.println(" | ") ; 
 delay(10000) ;
 } 
 else { 
 Serial.println(" ~|~ ") ; 
 Serial.println(" ~ | ~ ") ;
 Serial.println(" ~ | ~ ") ;
 Serial.println(" ~|~ ") ; 
 Serial.println(" | ") ; 
 Serial.println(" | ") ; 
 } 
 delay(1000) ;
 }
 ```
 Ce que nous faisons d'abord est de récupérer la valeur du capteur :
 ```c
 touch_sensor_value = touchRead(T0) ;
 Serial.print("On peut sentir = ") ;
 Serial.println( touch_sensor_value) ;
 ```
 Ensuite, nous ajoutons une condition qui dit : si la valeur est inférieure à 10, alors nous imprimons ce message, si elle est supérieure, nous imprimons cet autre message.
 Nous procédons comme suit.
 Nous ouvrons d'abord la condition
 `if (touch_sensor_value<40){`
 Puis nous imprimons le message (l'arbre est juste esthétiquement plaisant)
 ```
 Serial.println("Pour chacune d'entre nous en tant que femme, il y a un endroit sombre à l'intérieur, où se cache et grandit notre véritable esprit") ;
 Serial.println("\"belle/et dure comme une châtaigne/stanchions contre (votre)cauchemar de faiblesse/\"** et d'impuissance.") ;
 ```
 Puis nous fermons cette condition
 `}`
 Et nous ajoutons une autre déclaration pour tous les autres cas qui ne sont pas conformes à cette première condition
 ```
 else { 
 Serial.println(" ~|~ ") ; 
 [....]
 }
 ```
 ### Tâche
 Créez votre propre texte et vos propres éléments d'illustration lorsque la plante est touchée. Codez votre propre comportement pour l'interaction.
 ## Pause (15 minutes)
 ## Créer un serveur web avec l'esp-32 (45 minutes)
 Dans notre dernière tâche, nous allons mettre en place un serveur web qui tourne de manière autonome sur l'esp-32 et qui peut réagir au toucher ou à l'humidité du sol.
 ```c
 #include <WiFi.h>
 #include <WebServer.h>
 // SSID et mot de passe
 const char* ssid = "Plant_poem" ; // Entrez votre SSID ici
 const char* password = "" ; //Entrez votre mot de passe ici
 // Détails de l'adresse IP
 IPAddress local_ip(192, 168, 1, 1) ;
 IPAddress gateway(192, 168, 1, 1) ;
 IPAddress subnet(255, 255, 255, 0) ;
 WebServer server(80) ; // Objet du WebServer (port HTTP, 80 par défaut)
 // Contenu HTML & CSS qui s'affiche sur le serveur web
 String HTML = "<!DOCTYPE html>\
 <html>\
 <body>\
 <h1> &#127811 ; Hello There &#127811;;</h1>\
 </corps>\
 </html>" ;
 void setup() {
  Serial.begin(115200) ;
  // Créez le SoftAP
  WiFi.softAP(ssid, password) ;
  WiFi.softAPConfig(local_ip, gateway, subnet) ;
  Serial.print("Connexion à mon point d'accès : ") ;
  Serial.println(ssid) ;
  server.on("/", handle_root) ;
  server.begin() ;
  Serial.println("Serveur HTTP démarré") ;
  delay(100) ;
 }
 void loop() {
  server.handleClient() ;
 }
 // Gestion de l'url racine (/)
 void handle_root() {
  server.send(200, "text/html", HTML) ;
 }
 ```
 ### Description du processus
 **0- Appel des bibliothèques**
 ```c
 #include <WiFi.h>
 #include <WebServer.h>
 ```
 Cette première partie comprendra du code placé dans un autre fichier et qui nous permettra d'aller plus vite en utilisant des fonctions déjà écrites par d'autres personnes.
 **1- Enumération/présentation des acteurs de notre processus.** 
 ```c
 // SSID & Mot de passe
 const char* ssid = "Plant_poem" ; // Entrez votre SSID ici !à changer !
 const char* password = "" ; //Entrez votre mot de passe ici !laissez vide !
 // Détails de l'adresse IP
 IPAddress local_ip(192, 168, 1, 1) ;
 IPAddress gateway(192, 168, 1, 1) ;
 IPAddress subnet(255, 255, 255, 0) ;
 WebServer server(80) ; // Objet du WebServer (port HTTP, 80 par défaut)
 // Contenu HTML & CSS qui s'affiche sur le serveur web
 String HTML = "<!DOCTYPE html>\".
 <html>\
 <body>\
 <h1> &#127811 ; Hello There &#127811;;</h1>\\N
 </corps>\N
 </html>" ;
 ```
 Ici on commence par déclarer deux variables, qui vont être le nom du réseau de votre réseau et son mot de passe.
 Le deuxième paragraphe concerne l'adresse de votre réseau, son adresse IP, à laquelle vous allez vous connecter pour voir votre site web.
 Le troisième paragraphe est le contenu de votre site web, ici en html.
 **2- Mise en place du décor.** 
 ```c
 void setup() {
  Serial.begin(115200) ;
  // Créez le SoftAP
  WiFi.softAP(ssid, password) ;
  WiFi.softAPConfig(local_ip, gateway, subnet) ;
  Serial.print("Connexion à mon point d'accès : ") ;
  Serial.println(ssid) ;
  server.on("/", handle_root) ;
  server.begin() ;
  Serial.println("Serveur HTTP démarré") ;
  delay(100) ;
 }
 ```
 Ici, nous allons d'abord ouvrir le canal de communication pour une vitesse de transmission de 115200.
 Puis créer notre propre point d'accès Wi-Fi en utilisant la variable que nous avons déclarée à l'étape précédente et faire connaître l'utilisateur en imprimant une déclaration sur le canal de communication.
 Ensuite, nous allons spécifier ce qui se passe sur l'adresse "/" de notre serveur. Ici, nous appelons une autre fonction appelée handle_root. Le comportement de cette fonction sera expliqué dans l'étape suivante.
 Puis activer notre serveur et le faire savoir par le canal de communication.
 **3- Décrire les événements récurrents/commandes**
 ```c
 void loop() {
  server.handleClient() ;
 }
 ```
 Ici, nous demandons au contrôleur de gérer le client (votre navigateur) pour qu'il puisse accéder au serveur.
 **4- fonction spéciale - handle root**
 ```c
 // Gère l'url de la racine (/)
 void handle_root() {
  server.send(200, "text/html", HTML) ;
 }
 ```
 Cette fonction détaille ce qui se passe lorsque quelqu'un se connecte à 192.168.1.1 sans aucun caractère après ceci (l'adresse racine)
 ## Comment ajouter un capteur tactile à ce code ? (15-45 minutes)
 Afin d'ajouter un capteur au code, nous devons :
 1- introduire son nom
 2- faire en sorte que le script vérifie sa valeur de façon chronique
 3- utiliser cette valeur toujours mise à jour dans une instruction if.
 A quoi cela ressemblerait-il ? Pouvez-vous indiquer les étapes du code ci-dessous ?
 ```c
 #include <WiFi.h>
 #include <WebServer.h>
 // SSID et mot de passe
 const char* ssid = "Plant_poem" ; // Entrez votre SSID ici
 const char* password = "" ; //Entrez votre mot de passe ici
 int touch_sensor_value=0 ;
 // Détails de l'adresse IP
 IPAddress local_ip(192, 168, 1, 1) ;
 IPAddress gateway(192, 168, 1, 1) ;
 IPAddress subnet(255, 255, 255, 0) ;
 WebServer server(80) ; // Objet du WebServer (port HTTP, 80 par défaut)
 // Contenu HTML & CSS qui s'affiche sur le serveur web
 String HTML = "<!DOCTYPE html>\
 <html><head><meta http-equiv= \"Content-Type\" content=\"text/html;charset=utf-8\">\
 <body>\
 <h1> &#127811 </h1>\
 <p>\"Nous tournons maintenant nos pensées vers les arbres. La Terre a beaucoup de familles d'arbres qui ont leurs propres fonctionnements et usages. Certains nous fournissent un abri et de l'ombre, d'autres des fruits, de la beauté et d'autres, des objets utiles. Beaucoup de personnes dans le monde utilisent un arbre comme symbole de paix et de force. D'un seul esprit, nous saluons et remercions la vie de l'arbre. Maintenant, nos esprits ne font qu'un. Extrait de: Robin Wall Kimmerer. Tresser les herbes sacrées.\"</p> \ 
 <h1> &#127811 </h1>\
 </body>\
 </html>" ;
 void setup() {
  Serial.begin(115200) ;
  // Créez le SoftAP
  WiFi.softAP(ssid, password) ;
  WiFi.softAPConfig(local_ip, gateway, subnet) ;
  Serial.print("Connexion à mon point d'accès : ") ;
  Serial.println(ssid) ;
  server.on("/", handle_root) ;
  server.begin() ;
  Serial.println("Serveur HTTP démarré") ;
  delay(100) ;
 }
 // Traitement de l'url racine (/)
 void handle_root() {
  if (touch_sensor_value<40){
  server.send(200, "text/html", HTML) ;
  }
  else { 
 Serial.println("Rien à imprimer ici ~|~ ") ; 
 } 
 }
 void loop() {
  server.handleClient() ;
  touch_sensor_value = touchRead(T0) ;
 Serial.print("On peut sentir = ") ;
 Serial.println( touch_sensor_value) ;
 }
 ```
 ### Tâche
 1- Créez votre propre librairie portative et accessible à distance grâce à ce code. Trouver un texte que vous avez envie de partager et faites le apparaitre.
 ### Option Facultative - Utilisation de l'esp-32 avec un capteur d'humidité
 Pour utiliser l'esp-32 avec un capteur d'humidité, nous faisons un exercice similaire à celui avec le capteur tactile, avec l'ajout d'un circuit électrique pour le capteur d'humidité du sol, qui doit être électrifié lui-même, donc nous devons le connecter à une broche qui lui donne un courant de 5V et une broche qui lui donne une masse.
 Une fois ceci fait, voici le code pour lire la sortie
 ```c
 int SENSE= 2 ; // Entrée du capteur de sol sur la broche analogique A0 
 int value= 0 ;
 void setup() {
 Serial.begin(9600) ;
 Serial.println("SOIL MOISTURE SENSOR") ; 
 Serial.println("-----------------------------");
 }
 void loop() {
 value= analogRead(SENSE) ; 
 value= valeur/10 ; 
 Serial.println(valeur) ; 
 }
 ```
 ![un microcontrôleur esp32 avec des câbles dupont un jaune relié à la broche g2 et un gris gnd, en arrière plan il y a un capteur d'humidité](IMG_1564.png)
 ![un contrôleur esp-32 avec un câble orange relié à la broche V5, il y a une plaque avec une feuille en arrière-plan et un petit coin en aluminium d'un macbook pro](IMG_1565.png)
 ### Tâche
 1- Comment pourriez vous intégrer ce capteur à votre serveur web?
 ### Liens techniques
 [Documentation de l'Espressif sur l'esp-32](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/establish-serial-connection.html)
 [Comment utiliser l'esp-32 comme capteur tactile](https://microcontrollerslab.com/esp32-touch-sensor-button-example/)
 [Pilote pour l'esp-32](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers)
 [Site Arduino pour le téléchargement](https://www.arduino.cc/en/software)
 [Communication wifi de l'esp-32 avec l'IDE arduino](https://microcontrollerslab.com/esp32-server-client-wi-fi-communication-arduino-ide/)
 [création d'un serveur web avec l'esp-32](https://electropeak.com/learn/create-a-web-server-w-esp32/)
 ## Liens divers 
 [la vie secrète des plantes](https://www.youtube.com/watch?v=xvtcA46O-vA) - documentaire(-fiction) controversé - pour inspiration seulement
 [wikipedia sur la vie secrète des plantes](https://en.wikipedia.org/wiki/The_Secret_Life_of_Plants)
 [Une analyse de la chaine d'approvisionnement des minéraux nécessaires aux composant électroniques](https://www.dissentmagazine.org/online_articles/the-problem-with-conflict-minerals)
 [Chaine d'approvisionnement de plusieurs matériaux d'un ordinateur](https://supplystudies.com/manifest/#manifest-https://supplystudies.com/manifest/json/samples/typical-laptop.json)
 [Francis Hallé on specific trees](https://thereader.mitpress.mit.edu/walking-trees-parasitic-flowers-remarkable-plants-illustrated-guide)
 [Tree thinking](https://placesjournal.org/article/tree-thinking/)
 [Jagadish Chandra Bose](https://en.wikipedia.org/wiki/Jagadish_Chandra_Bose)
 ## Musique
 [Mall Grab - Spirit Wave](https://open.spotify.com/track/5zfDn2VAMkLya9CRKEYZyb?si=c8a501261b734c9e)
 [Soichi Terada - Bamboo fighter](https://open.spotify.com/track/0QKc8g97mQsbybkvHYN2Bi?si=f2956b81b57c4c58)
 [Susobrino - La hoja de eucalipto](https://open.spotify.com/track/5jWvkNfoQW1A42btmzJinP?si=934bdf4d871d48df)
 [Stevie Wonder - La vie secrète des plantes](https://open.spotify.com/album/3LSgLZrSXELqWt5eqb6XMY?si=y25zwRzbQlCJFWJiFTcAUA)
--- a/Saint-Luc_Guillaume/arduino_arrow.png
+++ b/Saint-Luc_Guillaume/arduino_arrow.png
--- a/Saint-Luc_Guillaume/arduino_check.png
+++ b/Saint-Luc_Guillaume/arduino_check.png
--- a/Saint-Luc_Guillaume/bon_port.png
+++ b/Saint-Luc_Guillaume/bon_port.png
--- a/Saint-Luc_Guillaume/bonne_carte.png
+++ b/Saint-Luc_Guillaume/bonne_carte.png
--- a/Saint-Luc_Guillaume/esp-32-pinout.png
+++ b/Saint-Luc_Guillaume/esp-32-pinout.png
--- a/Saint-Luc_Guillaume/esp-32-pinout_bigger.png
+++ b/Saint-Luc_Guillaume/esp-32-pinout_bigger.png
--- a/Saint-Luc_Guillaume/gestionnaire
+++ b/Saint-Luc_Guillaume/gestionnaire
--- a/Saint-Luc_Guillaume/gestionnaire
+++ b/Saint-Luc_Guillaume/gestionnaire
--- a/Saint-Luc_Guillaume/library_window.png
+++ b/Saint-Luc_Guillaume/library_window.png
--- a/Saint-Luc_Guillaume/preference.png
+++ b/Saint-Luc_Guillaume/preference.png
--- a/Saint-Luc_Guillaume/preference_window.png
+++ b/Saint-Luc_Guillaume/preference_window.png
--- a/Saint-Luc_Guillaume/serial_baud_1.png
+++ b/Saint-Luc_Guillaume/serial_baud_1.png
--- a/Saint-Luc_Guillaume/serial_baud_2.png
+++ b/Saint-Luc_Guillaume/serial_baud_2.png
--- a/content/pages/activities.md
+++ b/content/pages/activities.md
@ -12,4 +12,6 @@ The research is organised around the following activites. Each activity will be
 - **November/December 2021**: [Literary Python for Beginners](https://www.anaisberck.be/literary-python-for-beginners/), CASO Arts Numériques, ESA La Cambre, Bruxelles
- **November/December 2021**: Follow-up students, New Media Art, ESA Saint-Luc Bruxelles
+- **December 2021**: Discussion with Manetta Berends about the publishing practises around [Varia](http://varia.zone) in Rotterdam
 - **21 March - 2 April 2022**: Residency ‘Bud spotting’ in the Botanical Garden of Meise