MOTIVATION
L'inauguration à Tokyo en juin 2018 du premier musée d'art digital immersif nous questionne à nouveau autour de la définition de l'oeuvre d'art.
Depuis toujours, celle-ci trouve sa raison d'être et son fondement dans la relation qui s'instaure avec le spectateur : l'art digital, grâce aux nouvelles possibilités d'interaction, ouvre des occasions inédites pour une expansion de la conception artistique en introduisant l’idée d'une transformation continue face à l'action et à l'émotion du spectateur.
L’image, suivant la tradition de notre culture, a toujours essayé de proposer une histoire, et à travers elle, de transmettre un message. Pendant des siècles elle a été un véhicule d'émotions, et à l'usage exclusif des pouvoirs, finalisé aussi à l’endoctrinement ; en même temps la représentation devait suivre des normes très strictes et définies.
Un éloignement progressif par rapport à ces impositions, jusqu'à un abandon de la représentation figurative, a porté au mouvement abstrait du début du XX siècle. En quittant une narration en relation avec des données réelles, le spectateur a assumé un rôle toujours plus important : puisqu'il pouvait projeter ses émotions dans l'oeuvre d’art : et l'oeuvre d'art abstraite, dans sa liberté, sans proposer une histoire dans le sens classique, est devenue un miroir des émotions de l'observateur.

DESCRIPTIF
L'oeuvre My tree is your tree (Mon arbre est ton arbre), est une installation interactive composée d'un dessin à l'encre sur papier, deux sources lumineuses indépendantes ainsi qu'un casque muni de senseurs biométriques (cf : voir précision technique en pied de page).
L'installation propose l’image d'un arbre, tel qu'un objet idéal parfaitement dessiné par la nature.
Détenteur d'un archaïque pouvoir symbolique, le vieux chêne représenté dans le dessin, avec ses majestueuses formes, évoque la force et le pouvoir, tout en signifiant aussi l'élément masculin de la Nature. Sous les thèmes de la loyauté, l'endurance et l'héroïsme, j'ai souhaité convier le public à une expérience unique qui lui permet d'être interconnecté avec une oeuvre graphique.
Une couronne de feuillage intègre un casque qui peut relever et quantifier les états de concentration et de méditation. Ainsi, l'activité cérébrale du spectateur est prise en compte par les senseurs et affectent l’éclairage: le dessin devient alors luminescent.
Plus précisément, le recours à l'ultraviolet est en relation avec la longueur d'onde de la lumière qui se propage dans les neurones du cerveau (biophotons-UV).
Un casque/couronne permet donc au spectateur d'entrer en résonnance avec la couronne de l'arbre dessiné, ce qui crée un lien entre l'image représentée et les émotions de celui-ci.
Les temps longs et dilatés du travail graphique opèrent un contrepoint à l'urgence des émotions, et invitent à l'exercice du regard, à la lecture.

CONCEPTS
L'idée de la couronne et de ses racines, en dehors de leur habitat naturel, est une façon de les décontextualiser tels d'anciens tableaux botaniques.
Sur les traces du dualisme cartésien visible/invisible : la couronne se réfère symboliquement à « la Pensée » (Res cogitans) et les racines à « la Matière » (Res extensa). Un tel arbre se propose au regard dans sa totalité, interface entre le monde visible (couronne, lumière, pensée, conscience) et la réalité souterraine et cachée (racines, l'obscurité, l'inconscient, le subconscient).
De plus, le dualisme entre les dimensions macro et micro est présent dans la nature avec ses structures fractales : dans l'installation, les branches et les racines du dessin, interagissent avec neurones et synapses de l'observateur.
Le participant, suivant son état d'âme et sa pensée, transforme en temps réel l'aspect de l’oeuvre graphique en modifiant l'illumination.
My tree is your tree (dessin), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm
My tree is your tree (détail), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm

My tree is your tree (détail), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm

My tree is your tree (détail), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm
My tree is your tree (détail lumière ultraviolette, éteinte vs. allumée), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm
My tree is your tree (détail lumière ultraviolette, éteinte vs. allumée), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm
My tree is your tree (détail), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm
My tree is your tree, installation interactive, 2018​​​​​​​
Relation spectateur-oeuvre
My tree is your tree, installation interactive, 2018​​​​​​​
Diagramme technique
My tree is your tree, installation interactive, 2018​​​​​​​
ZF entrain de dessiner
My tree is your tree (détail), 2018​​​​​​​
Encre noire, encre UV et acrylique sur panneau contreplaqué, 1600mm x 1150mm
My tree is your tree (étapes du dessin), 2018​​​​​​​
Esquisse au crayon à papier et passage à l'encre noire
PRÉCISION TECHNIQUE
My tree is your tree (Mon arbre est ton arbre) présente une installation interactive.
Le spectateur, suivant son état d'âme et sa pensée, modifie en temps réel l'aspect d'un oeuvre graphique avec l'illumination.
L'installation se compose de quatre éléments :
Une oeuvre graphique,
Deux sources de lumière,
Une couronne/casque biométrique,
Une unité de contrôle.
L'oeuvre graphique est un dessin à l'encre noire, encre UV et acrylique, sur panneau contreplaqué monté sur armature en bois. Dimensions : 1600mm x 1150mm.
Deux sources lumineuses indépendantes illuminent le dessin. L’une est une lampe halogène, l’autre une lampe ultraviolette, toutes les deux réglables. Elles sont montées sur trépied ou fixées au plafond. Alimentation sur secteur.
Une couronne de feuillage intègre un casque muni de senseur biométrique qui peut relever et quantifier les états de concentration et de méditation. Alimentation par batterie.
L'unité de contrôle se compose d’un miniordinateur avec un microprocesseur.
Un programme ad hoc, conçu pour cette installation élabore les signaux fournis par le casque biométrique. Le programme transmet ensuite les données élaborées aux différentes sources lumineuses. Alimentation sur secteur.

REMERCIEMENTS
Paolo Blendinger
Carla Burani
Howard Burns
Cosimo Filippini
Giusi Filippini-Boni
Sabrina Lorte

PROGRAMME
////////////////////////////////////////////////////////
// STEP 1
// ARDUINO MEGA, Grove Bluetooth interfaced with Mindwave Mobile.
// CONFIGURING GROVE BLUETOOTH MODULE V3.1
// 
// LOAD THIS SKETCH ON ARDUINO
//
// Source code provided by Arduino, Grove, NeuroSky Inc. and it's implemented by Zeno Filippini.
// This code is provided license free.
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//
 // Multiple Serial test
// Receives from serial port 1, sends to to Arduino Serial Monitor.
 // Works only with boards with more than one serial like Arduino Mega, Due, Zero etc.
//  The circuit:
 // Grove Bluetooth module v.3.1. device attached to Serial port 1
//  Serial Monitor open on Serial port 0
//
// ARDUINO SERIAL MONITOR SET-UP
// No line ending
// 57600 baud
//
// CONFIGURE GROVE BLUETOOTH MODULE
//tape command: AT // enter configuration mode
//tape command: AT+NAME=MYNAME // set Bluetooth module name
//tape command: AT+BAUD7 // set 57600 Baud
//tape command: AT+ROLEM // set in master mode
//tape command: AT+PIN0000 // set password to 0000
//tape command: AT+CMODE0 // master <-> slave can automatic connect and reconnect
//tape command:AT+CON123456789ABC // enter and set IP address of the MindWave
//
// CHECK SETTING
// tape command: AT+BAUD? -> echo: BAUD:57600
// tape command: AT+ROLE? -> echo: ROLE:M
// tape command: AT+NAME? -> echo: NAME: MYNAME
// tape command: AT+PIN? -> echo: PIN:0000
// RESET SETTING IF NEEDED
// tape command: AT+DEFAULT // Restore all setup value to factory setup
///////////////////////////////////////////////// ///////

void setup() {
  // initialize both serial ports:
  Serial.begin(57600);
  Serial.println("Arduino with Grove SBTv3.1 is ready");
  Serial1.begin(57600);
  Serial.println("SBTv3.1 started at 57600");
}
void loop() {
  // read from serial port 1 and send to Arduino Serial Monitor
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
  }
  //   // Keep reading from Arduino Serial Monitor and send to serial port 1
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.write(inByte);
  }
}
////////////////////////////////////////////////////////
// CLOSE SERIAL MONITOR AND LOAD SKETCH LISTED BELOW
////////////////////////////////////////////////////////

////////////////////////////////////////////////////////
// STEP 2
// ARDUINO MEGA, INTERFACED WITH MIND-WAVE-MOBILE
// Setup: attention & meditation coupled with DMX for smooth  brightness change.
// Recive Signal and display signal intensity on 2 grove-LED-bar.
// Set maximum lamp intensity with 2 grove-slide-pot.
// !! Grove Bluetooth module v.3.1 must be configured separately.
// Source code provided by NeuroSky Inc. and implemented by Zeno Filippini.
// This code is provided license free.
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//////////////////////////////////////////////// ///////
#include <Grove_LED_Bar.h>
#include <DmxSimple.h>
Grove_LED_Bar barAtt(9, 8, 0); // Clock pin, Data pin, Orientation
Grove_LED_Bar barMed(11, 10, 0); // Clock pin, Data pin, Orientation
int adcPinAtt = A8; // select the input pin for the potentiometer
int ledPinAtt = A9; // select the pin for the LED
int adcInAtt = 0;   // variable to store the value coming from the sensor
int adcPinMed = A6; // select the input pin for the potentiometer
int ledPinMed = A7; // select the pin for the LED
int adcInMed = 0;   // variable to store the value coming from the sensor
int MaxAttDMX = 0; // Max DMX value Attention
int MaxMedDMX = 0; // Max DMX value Meditation
#define LED 13 // control LED
#define BAUDRATE 57600
#define DEBUGOUTPUT 0
#define powercontrol 10
// checksum variables
byte generatedChecksum = 0;
byte checksum = 0;
int payloadLength = 0;
byte payloadData[64] = {0};
byte poorQuality = 0; // Signal quality, no skyn contact = 200
byte attention = 0; // Store value from Headset
byte meditation = 0; // Store value from Headset
int AttNewDMX = 0;
int AttOldDMX = 0;
int MedNewDMX = 0;
int MedOldDMX = 0;
// system variables
long lastReceivedPacket = 0;
boolean bigPacket = false;
//////////////////// 
// Microprocessor Setup
//////////////////// 
void setup() {
  barAtt.begin();
  barMed.begin();
  DmxSimple.usePin(2); // pin for DMX output
  DmxSimple.maxChannel(10); // highest channel you DmxSimple.write() to
  pinMode(ledPinMed, OUTPUT); // set Potentiometer control Led ledPinMed to OUTPUT
  pinMode(ledPinAtt, OUTPUT); // set Potentiometer control Led ledPinAtt to OUTPUT
  pinMode(LED, OUTPUT);
  Serial.begin(BAUDRATE); // to serial monitor
  Serial1.begin(BAUDRATE); // input bluetooth adapter
}
////////////////////////
// Read data from Serial UART
///////////////////////
byte ReadOneByte() {
int ByteRead;
while(!Serial1.available()); //Get the number of bytes (characters) available for reading from the serial port.
ByteRead = Serial1.read();  //This is data that's already arrived and stored in the serial receive buffer (which holds 64 bytes)
#if DEBUGOUTPUT
Serial.print((char)ByteRead); // echo the same byte out the USB serial (for debug purposes)
#endif
return ByteRead; // read incoming serial data
}
//////////////
//MAIN LOOP
/////////////
void loop() {
  // Look for sync bytes
  if(ReadOneByte() == 170) {
    if(ReadOneByte() == 170) {
      payloadLength = ReadOneByte();
      if(payloadLength > 169) //Payload length can not be greater than 169
      return;
      generatedChecksum = 0;
      for(int i = 0; i < payloadLength; i++) {
        payloadData[i] = ReadOneByte(); //Read payload into memory
        generatedChecksum += payloadData[i];
      }
      checksum = ReadOneByte(); //Read checksum byte from stream
      generatedChecksum = 255 - generatedChecksum; //Take one's compliment of generated checksum
      if(checksum == generatedChecksum) {
        poorQuality = 200;
        attention = 0;
        meditation = 0;
        for(int i = 0; i < payloadLength; i++) { // Parse the payload
          switch (payloadData[i]) {
            case 2:
            i++;
            poorQuality = payloadData[i];
            bigPacket = true;
            break;
            case 4:
            i++;
            attention = payloadData[i];
            break;
            case 5:
            i++;
            meditation = payloadData[i];
            break;
            case 0x80:
            i = i + 3;
            break;
            case 0x83:
            i = i + 25;
            break;
            default:
            break;
          } // switch
        } // for loop
        #if !DEBUGOUTPUT
        if(bigPacket) {
          if(poorQuality == 0)
          digitalWrite(LED, HIGH);
          else
          digitalWrite(LED, LOW);
          if(poorQuality == 200){ // Check if headset is removed and blink first LED of LED-Bar
             barAtt.setLed(1, 1);
             barMed.setLed(1, 1);
             delay(500);  
          }
/*       // output to serial monitor
          Serial.print("Attention: ");
          Serial.print(attention, DEC);
          Serial.print("%; Meditation: ");
          Serial.print(meditation, DEC);
          Serial.print("%; PoorQuality: ");
          Serial.print(poorQuality, DEC);
          Serial.print("; Time since last packet: ");
          Serial.print(millis() - lastReceivedPacket, DEC);
          lastReceivedPacket = millis();
          Serial.print("ms");
          Serial.println();    */
/////////////////////////
//SET OUTPUT GROVE LED BAR
/////////////////////////        
          // Set Grove_LED_Bar values
          int barGraphLevAtt = map(attention, 0, 100, 0, 10); // convert from to
          barAtt.setLevel(barGraphLevAtt);
          int barGraphLevMed = map(meditation, 0, 100, 0, 10); // convert from to
          barMed.setLevel(barGraphLevMed);
//////////////////
//SET OUTPUT DMX
/////////////////
          AttNewDMX = map(attention, 0, 100, 0, MaxAttDMX); // convert from 0-100% to 255 limited by slidepot max value
          MedNewDMX = map(meditation, 0, 100, 0, MaxMedDMX);
          int AttDelta = abs(AttOldDMX-AttNewDMX); // calculate the delta DMX value before-after
          int MedDelta = abs(MedOldDMX-MedNewDMX);
          int interval = 900; // max delay before next packet
          int AttDMXdelay = round(interval/AttDelta); // calculate the DMX step time interval to make variation in interval time
          int MedDMXdelay = round(interval/MedDelta);
          int AttDeltaRef=0; // counter for stepping DMX
          int MedDeltaRef=0;
          if(poorQuality != 200){  // Check if headset is removed
            for (int clk= 0; clk <= interval; clk++) { // DMX master clock
              // START attention DMX variation loop an smooth light intensity changes
              AttDeltaRef++;
              if(AttDeltaRef == AttDMXdelay){
                if(AttNewDMX <= AttOldDMX){
                  DmxSimple.write(10,AttOldDMX); //Channel 10 to control Halogen light
                  AttOldDMX--;        
                }
                else{
                  DmxSimple.write(10,AttOldDMX); //Channel 10 to control Halogen light
                  AttOldDMX++;         
                }
                AttDeltaRef = 0;
              }
              // START meditation DMX variation loop an smooth light intensity changes
              MedDeltaRef++;
              if(MedDeltaRef == MedDMXdelay){
                if(MedNewDMX <= MedOldDMX){
                  DmxSimple.write(1,MedOldDMX); //Channel 1 to control UV light
                  MedOldDMX--;        
                }
                else{
                  DmxSimple.write(1,MedOldDMX); //Channel 1 to control UV light
                  MedOldDMX++;         
                }
                MedDeltaRef = 0;
              }
              delay(1);
            }
          } else {   // Do this if headset is removed
            DmxSimple.write(1, 0);
            DmxSimple.write(10, 0);
          }
          // Other UV-DMX Channels needed for proper operation of the led UV lamp
          DmxSimple.write(2, 0);
          DmxSimple.write(3, 0);
          DmxSimple.write(4, 0);
          DmxSimple.write(5, 255);
          DmxSimple.write(6, 255);
          DmxSimple.write(7, 255);
          DmxSimple.write(8, 255);
          MedOldDMX = MedNewDMX; // Update DMX values
          AttOldDMX = AttNewDMX; // Update DMX values      
        }
        #endif
        bigPacket = false;
      }
      else {
      // Checksum Error
      } // end if else for checksum
    } // end if read 0xAA byte
  } // end if read 0xAA byte
/////////////
//OTHER STUFF
/////////////
  adcInAtt = analogRead(adcPinAtt); // read the value from the sensor:
  MaxAttDMX = map(adcInAtt, 0, 1023, 0, 250) + 5; // convert from slidepot to DMX and add 5 for stability
  if (adcInAtt<2)digitalWrite(ledPinAtt, HIGH); // set led hight if pot is set to 0
  if (adcInAtt>=2)digitalWrite(ledPinAtt, LOW);
  adcInMed = analogRead(adcPinMed); // read the value from the sensor:
  MaxMedDMX = map(adcInMed, 0, 1023, 0, 250) + 5; // convert from slidepot to DMX and add 5 for stability
  if (adcInMed<2)digitalWrite(ledPinMed, HIGH); // set led hight if pot is set to 0
  if (adcInMed>=2)digitalWrite(ledPinMed, LOW);        
}

Back to Top