Latest activities
Publishing practises Varia
date 18-01-2022
Existing algorithmic publishing practises around Varia, Rotterdam
Publishing Experiments
Quilting
Zines
interesting zine made by Michael Murtaugh and Manetta Berends, as a way to share their thoughts and documents their classes: https://hub.xpub.nl/sandbot/SWAAT/00/SWAAT-00.pdf
Jupyter notebook became a part of this publication process, in Markdown, processed using Weasyprint
code becomes a recipe and can be contextualised using the Jupyter notebooks; code becomes textual language, doesn't need to be separated from 'natural' language; you can see the immediate outcome of pieces of code
Nourishing Network
https://a-nourishing-network.radical-openness.org/
https://a-nourishing-network.radical-openness.org/pages/documentation.html
- each week 1 article was written, it was sent in 2-fold in a parcel together with an enveloppe; one could subscribe and would receive a parcel a week, with 1 text to keep and 1 text to send on to someone else
- the text would also be published online each Friday, and be automatically posted from the website to rss-feed/mastodon, a mailinglist could also have been an interesting option
Continuous Publishing: Lumbung
https://roelof.info/lumbung/
- uses feeds/rss to bring together material from different places
- developed for Transmediale 15
- Activity Pub: the protocol behind Fediverse (Mastodon etc), each environment functions on itself, but because they speak the same language, you can bring them together automatically.
Continuous Publishing: Multi feeder
https://multi.vvvvvvaria.org/
- this is a way to publish what happens in and around Varia, using the rss feed of the website and the hashtag on Mastodon
- the idea is to develop a newsletter/gazette this way
- it is a way to show that there are multiple ways to become an author, there are different ways of writing possible
Agents for distribution
Logbot
https://vvvvvvaria.org/logs/
log with examples of plain text culture: https://vvvvvvaria.org/logs/x-y/
- was created during Relearn Rotterdam 2017
- needs the xmmp protocol to chat, when logbot is in the chatroom, it logs all images/messages, is a continuous way to save things
- you create a very thin social layer between internal and public exchange
- logbot generates automatically a webpage
- code of Varia bots: https://git.vvvvvvaria.org/varia/bots
- it is way to publish collectively, in the moment, daily, continuous; it is the strength of algoritmic publishing, something you cannot do with print
- cfr enron mailinglist: time becomes a factor (daily, weekly)
- you can also delete things in the stream
Tools
Jupyter Lab
can run on a server, but also locally
direct & literary: combines Markdown with code, can be a nice way to publish code
works well online, is an occasion to talk about a server (vs computer)
could be a tool for the algoliterary publishing house if multiple makers participate
it could be interesting to look at the differences/potentialities between Jupyeter Lab and git-repository
notebooks can be seen as private interactive websites, you can not work collectively on 1 notebook
binder: you upload notebook online, everyone gets access: https://jupyter.org/binder
Python library for plain text
Resonant publishing (ATNOFS)
this needs more clarification: it is a next edition of the Ethertoff, where editors and graphic designers work together simultaneously
you create a stylesheet together, can adapt the template, and you generate the pdf
html, css, MD
responds to the wish to make pads speak Python, based on your text you can generate new texts
References
On distribution models
https://pad.vvvvvvaria.org/getting-it-out-there
- references on experiments with different distribution models
Bots as digital infrapunctures
https://bots-as-digital-infrapunctures.dataschool.nl/
- by Cristina Cochior
- you need to understand first the social codes of the environment in which you make your bot live, 'bot logic'
- algorithmic agents (bot, worker): something that 'lives' somewhere, it is a way tog et information to people, it shifts to focus from interest to publishing, you need to think about the message, to whom you want to talk, the intention with which you publish, how to avoid to overwhelm people, ...
A living library of plants
date 19-11-2021
A living library of plants, workshop with students of ESA St-Luc
[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
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
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 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 , 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.
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.
Click on the File menu on the top menu bar.
Click on the Preferences menu item. This will open a Preferences dialog box.
You should be on the Settings tab in the Preferences dialog box by default.
Look for the textbox labeled “Additional Boards Manager URLs ”.
If there is already text in this box add a coma at the end of it, then follow the next step.
Paste the following link into the text box – *https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json*
Click the OK button to save the setting.
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:
In the Arduino IDE click on the Tools menu on the top menu bar.
Scroll down to the Board: entry (i.e. Board: Arduino/Genuino Uno ).
A submenu will open when you highlight the Board: entry.
At the top of the submenu is Boards Manager . Click on it to open the Boards Manager dialog box.
In the search box in the Boards Manager enter “esp32 ”.
You should see an entry for “esp32 by Espressif Systems ”. Highlight this entry and click on the Install button.
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
2 - Then you can select on which port it will be communicating (the USB port)
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
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 beginning 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
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.
In order to see what is being printed, we need to open the serial monitor in the Tool section and select baud rate 115200
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.
-> as you can see the alligator clip is connected to G4 which is touch 0 (T0) on this pin-out diagram
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:
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:
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
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 ); }
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?
#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> 🍃 Hello There 🍃;</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
#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.
// 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.
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
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
// 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?
#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> 🍃 we learn to bear the intimacy of scrutiny and to flourish within it 🍃;</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
How to use esp-32 as a touch sensor
Driver for the esp-32
Arduino website for download
esp-32 wifi communication with arduino IDE
creating a webserver with esp-32
Misc links
On mineral necessary for electronics
the secret life of plants - controversial documentary sometimes dubbed as pseudo-science - for inspiration
wikipedia on the secret life of plants
Supply chain analysis for minerals needed for electronics
tree thinking
Jagadish Chandra Bose
Chaine d'approvisionnement de plusieurs matériaux d'un ordinateur
Francis Hallé on specific trees
Music
Mall Grab - Spirit Wave
Soichi Terada - Bamboo fighter
Susobrino - La hoja de eucalipto
Stevie Wonder - the secret life of plants
Une bibliothèque vivante de plantes
date 19-11-2021
Une bibliothèque vivante de plantes, atelier avec les étudiants de St-Luc
[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.
é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é
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
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 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.
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.
Cliquez sur le menu File dans la barre de menu supérieure.
Cliquez sur l'élément de menu Préférences . Cela ouvrira une boîte de dialogue de préférences.
Vous devriez être sur l'onglet Paramètres de la boîte de dialogue Préférences par défaut.
Recherchez la zone de texte intitulée "Additional Boards Manager URLs ".
S'il y a déjà du texte dans cette zone, ajoutez une virgule à la fin de celui-ci, puis suivez l'étape suivante.
Collez le lien suivant dans la zone de texte - https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Cliquez sur le bouton OK pour enregistrer le paramètre.
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 :
Dans l'IDE Arduino, cliquez sur le menu Tools dans la barre de menu supérieure.
Faites défiler vers le bas jusqu'à l'entrée Board: (c'est-à-dire Board : Arduino/Genuino Uno ).
Un sous-menu s'ouvre lorsque vous mettez en évidence l'entrée Board: .
En haut du sous-menu se trouve Boards Manager . Cliquez dessus pour ouvrir la boîte de dialogue Boards Manager.
Dans la boîte de recherche du gestionnaire de cartes, entrez "esp32 ".
Vous devriez voir une entrée pour "esp32 by Espressif Systems ". Mettez cette entrée en surbrillance et cliquez sur le bouton Installer .
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.
2 - Ensuite vous pouvez sélectionner sur quel port il va communiquer (le port USB)
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.
Si vous n'avez pas d'erreur, vous pouvez l'envoyer avec le bouton flèche.
Brancher le capteur
Avant de brancher votre capteur, débranchez votre carte esp-32.
-> comme vous pouvez le voir la pince crocodile est connectée à G4 qui est la touche 0 (T0) sur ce schéma de brochage
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.
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.
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
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 :
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 :
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.
#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> 🍃 ; Hello There 🍃;</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
#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.
// 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.
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
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
// 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 ?
#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> 🍃 </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> 🍃 </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
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 ) ; }
Tâche
1- Comment pourriez vous intégrer ce capteur à votre serveur web?
Liens techniques
Documentation de l'Espressif sur l'esp-32
Comment utiliser l'esp-32 comme capteur tactile
Pilote pour l'esp-32
Site Arduino pour le téléchargement
Communication wifi de l'esp-32 avec l'IDE arduino
création d'un serveur web avec l'esp-32
Liens divers
la vie secrète des plantes - documentaire(-fiction) controversé - pour inspiration seulement
wikipedia sur la vie secrète des plantes
Une analyse de la chaine d'approvisionnement des minéraux nécessaires aux composant électroniques
Chaine d'approvisionnement de plusieurs matériaux d'un ordinateur
Francis Hallé on specific trees
Tree thinking
Jagadish Chandra Bose
Musique
Mall Grab - Spirit Wave
Soichi Terada - Bamboo fighter
Susobrino - La hoja de eucalipto
Stevie Wonder - La vie secrète des plantes
Forest bathing workshop
date 18-11-2021
Forest Bathing workshop with students of ESA Saint-Luc, Bruxelles
Introducing the context
connecting to the macro-cosmos:
walk in silence
mute phones
open up to experiments, even if there can be some resistance
Bois de la Cambre / Forêt de Soignes:
Introducing some species
Looking at bark, leafs, fruits, specific values in use, in Celtic use
- beech
- hornbeam
- poplar
- oak
- linden
- maple
- chestnut
Experiments
share a memory of a tree
choose a tree and say hello, observe its bark, look up to the leaves, down to the roots, be conscious about the wood wide web
how does a tree manage to have its leafs change colour and fall down (this workshop was in autumn)
photosynthesis
basic exchange tree-human: oxygen & CO2
breathing together
guided meditation: become an oak of 35Oys old, smell the soil in which it is rooted
meet a tree
find a tree that calls you
greet the tree
ask a question following Philippine practise
explore your expression with your own medium (drawing/writing/photography...)
final sharing
Performing the tree sort algorithm
date 18-11-2021
Repository for the workshop on the tree sort algorithm .
You'll find the workshop material in the workshop folder.
Recipes
Recipes used during the workshop to execute the tree sort algorithm manually (with a group of people).
To insert a node within a tree
This recipe inserts a new node into an (empty) tree. It is assumed there is a place defined where the tree will be started (rooting point?). When the recipe is executed the current position is considered to be rooting point.
Look at your current position , if it's empty (there is no node) this will be your place: you are inserted in the tree, and the recipe is finished. If there is a node continue with step two.
Ask the node in the current position for its value.
Compare the answer of the node to your own value. Is your value smaller than theirs? Then follow the left arm of the node, and take that as the new current position and move back to step one. Otherwise continue with step four.
Is your own value the same as or bigger than the answer the node gave? Then follow the right arm of the node, and take that as your new current position and go back to step one.
To measure the depth of a tree
This recipe discovers the depth of the deepest branch in the (sub)tree. It is initiated by asking the root or any other node to measure its depth.
Ask the node attached to your left arm for its depth, or take zero if you have none.
Ask the node attached to your right arm for its depth, or take zero if you have none.
Pick the greater one out of the answers you collected in step one and two, and add 1 (increment by one).
Answer the number you calculated in step 3 to the node which asked you to measure your depth.
To traverse the tree in order:
This recipe transforms the (sub)tree into an orderd row (or list) . It is initiated by asking the root or any other node to traverse.
If you have a left node: ask it to traverse. Once it has finished traversing ask the resulting row (list) to stand to the left of you. It is important the row maintains it order.
If you have a right node: ask it to traverse. Once it has finished traversing ask the resulting row (list) to stand to the right of you. It is important the row maintains it order.
By combining the row on the left, yourself, and the row to your right a new row has formed. Tell the node who asked you to traverse that you're ready.
Code implementations
In the folder workshop/code a simple implementation of the tree sort algorithm can be found.
workshop/code/treesort.py
Implementation of the binary search tree. When the script is
python workshop/code/treesort.py
workshop/code/tree-visualizer.py
Visualizes a tree using graphviz
python workshop/code/tree_visualizer.py
workshop/code/text-tree.py
Reads a text (workshop/text-to-sort.txt) and generates a visual tree:
python workshop/code/text_tree.py
Requirements
The implementations are written in python and require python 3, find information on how to install python here
The visualizer and the text_tree both use graphviz to generate the visualization. Find information on how to install graphviz here
The visualizer and the text_tree also require graphviz the graphviz python bindings . The easiest way to install them is through pip:
Wworkshop Oracle for Consentful Publishing Infrastructures
date 18-11-2021
Welcome to the workshop engaging the Oracle for Consentful Publishing Infrastructures that we are currently developing.
To begin read aloud these collective conditions from below. Eveyone in the space (on or offline) is invited to read one condition outloud, and the next person can read the next one.
The purpose of these collective conditions is to create intentional ways of being together in any space that create collective access for many bodyminds.
C o l l e c t i v e C o n d i t i o n s
If anyone would like to share the duties of translating, let's talk about how this can happen.
No "well actually's" --> don't correct others on minor mistakes ‘well ACTUALLY a TLS handshake...’, https://www.recurse.com/.
One diva one mic --> don't interrupt.
If you would like anyone to slow down, please ask or raise your hand.
Privacy --> personal stories stay within the room.
Movement is good and taking care of your own needs is good leaving space for silence is good.
Leaving the room and coming back in is good.
Be mindful of speaking times and use your voice to speak up.
This is a space that welcomes all genders, is decidedly anti-racist and anti- ableist, there is no room for -isms such as: classism, racism, ableism, anti- queer sentiment, misogyny, ageism, religious discrimination or any other form of discrimination and oppression.
Not all disabilities are apparent, please don't assume what is normal for other people.
Not all genders are apparent, please don't assume someone else's gender based on their presentation.
There is as many teachers in this room as there are people in this space.
This is a multi lingual space. Please ask for clarification or translation.
Caretaking is a responsibility shared by everyone --> please feel free to check in with your neighbor, and neighbors feel free to say yes or no.
When mistakes happen: Let us make sure that people affected by a mistake receive the care they need. Let us set further conditions to make sure that mistakes are not repeated and that we as a group can account for them.
If you bring material into the space that might have an emotional impact on the people in the space, please share a content warning.
After reading these out loud together, please discuss them amongst the group. Are all of the words clear to everyone? Does anyone disagree with any of these conditions? Would anyone prefer a reformulation of how they are articulated?
Please begin by reading the text: A Few Rules for Predicting the Future by Octavia Butler, published in Essence Magazine in 2000. A link to it is here: http://kalamu.com/neogriot/2013/07/09/history-octavia-butler-gave-us-a-few-rules-for-predicting-the-future/
After reading, please discuss with your group what came up. What were you surprised by? What not? What do you think it means to predict the future as Octavia Butler suggests it?
While you are discussing assign one person to make three lists of the: values, objects and situations that emerge from reading Butler's text?
After some discussion, please take a break of at least 15 min .
Welcome back to the Oracle for Consentful Publishing Infrastructures .
How to use the Oracle for Consentful Publishing Infrastructures
Welcome! This oracle is a hands-on card deck designed to help us collectively envision and share ideas for what consentful publishing infrastructures might be... or might not be.
The game is part of Anaïs Berck's residency exploring the concept of an Algoliterary Publishing House. As Anaïs Berck represents a collective of humans, trees and algorithms, the algoliterary publishing house will function within this collective.
This means that we will have to rethink all aspects of publishing in collaboration with all entities involved. This raises a series of questions, like: how can questions around ethics and ecology be thought alongside print or online publishing? What does consent mean when working with trees and more than humans?
To begin this workshop, please start with a definition of consent, publishing and infrastructure as these are the terms that you are asked to work with in this workshop.
The framework of consent that we are thinking with is based on the principles of FRIES, which is easy to remember because FRIES are delicious. :) So for us we think about consent that is: Freely Given, Reversable, Informed, Enthuastic and Specific. This means that it is specific to each circumstance, aware of all of the information needed to make a decision, can be stopped at any time: not coercive -- it is not something that is wishy-washy or un-enthuastic and it is understandable as a clear 'yes' from both parties.
In this research we are working with, we think about publishing as a yet indeterminate practice - which is why we are thinking with this oracle. Publishing could mean - to publish a book, but it also could mean to think about growth as publishing or reciept printing as publishing. We are thinking about taking publishing to be a process that is about dissemination / sharing - but leave open ended the methods of how this sharing unfolds.
In this research we think with infrastructures that are temporary and specific. Infrastructure could mean a building or bureaucratic system but it also could be the format of a book. Infrastructures are repeatable, require care and can make sharing possible when it otherwise might not be.
The wisdom of the oracle is questionable, sometimes embedded with values we wish to pursue, sometimes not. We offer this as an unstable tool to consider what values are often already embedded in technological infrastructures and which ones are not. What kind of inventing, play, agencies and collaborations will be necessary to remake the world of publishing with care for more-than-humans included? How does consent work with more-than-humans including trees, algorithms, machines and more?
This oracle has been inspired and iterated on by the Oracle for Transfeminist Tech , which we love and can be found and learned about here: https://www.transfeministech.codingrights.org/.
Goal: The purpose of the Oracle for Consentful Publishing Infrastructures is to create ideas for technologies that are imbued with values that will remake the world so that many worlds can fit.
Take anywhere between 10 / 20 minutes for each step depending on how long you have for the activity.
11:15 - 12:30
1. Consult the Oracle
Each group/person takes:
1 or 2 Values Cards
1 Object Card
1 People and Places Card 1 Situation Card
2. Read your cards
_Value card(s): Each Value card represents a value from the texts we have shared in the reader but also that take into account the lectures from Monday. Take a moment to reflect individually and/or discuss in your group, what this value means to you. Do you wish to take this value into your work or leave it behind?
If you decide to leave it behind, keep working with this value and write down three steps in each direction away from this value, what is the most intense version of this value, what is the furthest value from this one? For example if you had 'optimisation' - perhaps the steps towards most intensity of this value would be: extraction, removal of bodies, automation - and the steps away from optimisation might be - slowing down, working with problems, doing very little. Consider what this spectrum of values around 'optimisation' is and keep brainstorming until you have an intensity of this value that works for you. Once you have finalised this, continue on.
_Object card: Each Object card represents an object referenced in our text from the reader or from the lectures on Monday.
_People/Places card: in the people/places cards all say the same thing. "Be in your own body. Be in the place you inhabit." Some speculative design exercises encourage you to imagine that you are another kind of person, but trans*feminism encourages us to recognize the importance of situated and embodied knowledge. Instead of pretending that you are someone else and you know what they need, take a moment to reflect on who you are. What body are you in? Where do you live? What privileges and burdens do your body and place provide?
_Situation card: Situations cards provide you with a situation that you need to deal with. This is a way to focus your energy on an apparatus that you might want to transform.
3. Create your Blueprint
Your goal is to envision a consentful publishing infrastructure/technology that:
_is embodied in your Object;
_is guided by your Values;
_is developed by and for your People, in your Place;
_and will help you work with the situation presented to you by the oracle.
Remember, it's the future, so objects are not limited by today's capabilities... everything's possible!
This speculative exercise should have a title, a diagram or drawing of your technology, and a brief description of how it works and what it creates.
4. Share your ideas
At the end: Share your ideas back with the others! Share your ideas about how this process did or did not work for you with us! As this is still in progress and we are accumulating ideas/processes & methods. Very happy to hear your thoughts on this work.
Thank you for participating in this workshop. These instructions are available to be iterated on or borrowed to lead your own workshop. Please do let us know at publishinghouse@anaisberck.be if you would like to be in dialogue!