Projet 1 – Légumes capacitifs

POT’O’POP

LE BUT

Le but de notre projet est de construire un véritable orchestre composé de fruits et de légumes.

Il y a 3 instruments :

Le piano banane : composé de 4 bananes il peut produire 4 notes !

Le poivron percu : en secouant le poivron, bam ! Une caisse claire qui claque !

Le modulo-poireau : en soufflant dedans, l’on peut moduler un son

 

Pour réussir ce projet nous avons utilisé les logiciels Arduino, processing et ableton live.

 

Arduino nous sert à capter le potentiel électrique de nos différents légumes à l’aide de ces deux bibliothèques :

https://github.com/SFE-Chris/UNO-HIDKeyboard-Library

https://github.com/sebnil/Moving-Avarage-Filter–Arduino-Library-

Ensuite nous utilisons la bibliotheque Serial Port pour faire communiquer Arduino et Processing. A chaque fois qu’il y a une interaction avec un légume, une chaine de caractere est envoyé à Processing.

Sur Processing nous traitons ces chaines de caractères et à l’aide de la bibliotheque the midi bus library (http://www.smallbutdigital.com/themidibus.php), nous créons un routage midi interne avec notre ordinateur MAC (ne marche pas sous windows).

Des informations midi sont alors envoyées à Ableton Live qui les traduit en Son.

 

Difficultés rencontrées :

– La courgette est un légume très instable. Nous souhaitions faire un piano composé de plusieurs légumes mais nous avons eut des problemes d’interférences d’où notre choix de n’utiliser que des bananes, un fruit très stable.

– Nous avons constaté la grande instabilité de notre systeme. Celui-ci interfaçant 3 logiciels différents, parfois ça marchait, parfois non, sans explications rationelles….

 

Circuits Arduino de notre projet :

Pot'o'pop_bb

 

Voici les fichiers sources :

ARDUINO :

/* Author: Bhavya Shukla in reference to Arduino uno
Multiple Keys*/
#include <HIDKeyboard.h>
#include <MovingAvarageFilter.h>

MovingAvarageFilter movingAvarageFilter(20);
MovingAvarageFilter movingAvarageFilter1(20);
MovingAvarageFilter movingAvarageFilter2(20);
MovingAvarageFilter movingAvarageFilter3(20);

HIDKeyboard Keyboard;
boolean check = false;
boolean check1 = false;
boolean check2 = false;
boolean check3 = false;
boolean pvert;
boolean porange;

int potVal = 0;
int redVal = 0;
int ledPin = 13;
void setup() {
// On démarre la communication série
Serial.begin(9600);

Keyboard.begin();

// on déclare la PIN 6 comme OUTPUT
pinMode(13, OUTPUT);
pvert = digitalRead(6);
porange = digitalRead(7);
}
void loop() {

//// CODE POUR LE POIREAU /////////////
//On lit la valeur du potentiomètre
potVal = analogRead(5);
// On l’affiche dans la console série
Serial.println(potVal, DEC);
redVal = potVal / 4; // On normalise la valeur de 0 à 255
// on envoie la valeur de luminosité à la PIN 6
analogWrite(13, redVal);

//bananes
float input = analogRead(0);

float input1 = analogRead(1);

float input2 = analogRead(2);

float input3 = analogRead(3);
//poivron vert
float input4 = digitalRead(6);

//poivron vert
float input5 = digitalRead(7);

//Banane
float output = 0;

//Banane
float output1 = 0;

//Banane
float output2 = 0;

//Banane
float output3 = 0;

//Banane
output = movingAvarageFilter.process(input);

output1 = movingAvarageFilter1.process(input1);

output2 = movingAvarageFilter2.process(input2);

output3 = movingAvarageFilter3.process(input3);
//// TESTS ///////////////////////////////////////////////////

//Serial.println(« poivron vert »);
//Serial.println(digitalRead(6));

//// LA Banane 0///////////////////////////////////////////////////

// Si le courant qui passe inférieur à 300 on joue une note
if (output < 300 ) { // you can change this parameter to fine tune the sensitivity

if (!check){
Serial.println(0);
check = !check;
}

}
// FOnction pour le relachement mais ne marche pas
if (output >600) {

if (check){
check = !check;
Serial.println(0);
}
}
//// LA Banane 1///////////////////////////////////////////////////
// Si le courant qui passe inférieur à 300 on joue une note
if (output1 < 300 ) { // you can change this parameter to fine tune the sensitivity

if (!check1){
Serial.println(1);
check1 = !check1;
}

}

if (output1 >600) {

if (check1){
check1 = !check1;
Serial.println(1);
}
}

//// LA Banane 2///////////////////////////////////////////////////
// Si le courant qui passe inférieur à 300 on joue une note
if (output2 < 300 ) { // you can change this parameter to fine tune the sensitivity

if (!check2){
Serial.println(2);
check2 = !check2;
}

}

if (output2 >600) {

if (check2){
check2 = !check2;
Serial.println(2);
}
}

//// LA Banane 3///////////////////////////////////////////////////
// Si le courant qui passe inférieur à 300 on joue une note
if (output3 < 300 ) { // you can change this parameter to fine tune the sensitivity

if (!check3){
Serial.println(3);
check3 = !check3;
}

}

if (output3 >600) {

if (check3){
check3 = !check3;
Serial.println(3);
}
}

/// Poireau orange ////
// on envoie une info lorsque le capteur change d’état
if (digitalRead(7) != porange){
Serial.println(4);
porange = !porange;
}
/// Poireau vert ////
// on envoie une info lorsque le capteur change d’état
if (digitalRead(6) != pvert){
Serial.println(5);
pvert = !pvert;

}

}

 

 

PROCESSING :

// Importation de la librairie qui permet d’établir la connexion processing arduino
import processing.serial.*;

// Importation de la librairie qui permet d’envoyer du midi
import themidibus.*;

/
Serial port; // Le port pour communiquer avec arduino
MidiBus myBus; // The MidiBus
float brightness = 0;
short LF = 10; // « Fin de ligne »
// Variable qui permet d’activer une note de piano
float piano;
// Variable qui permet d’activer une note de percu
float percu;
// Variable numéro de la note midi de percu jouée
int notepercu;
// Variable numére de la note de piano midi joué
int notepiano;
// Variable pour changer la vélocité de la note selon la pression exercée dans le poireau
int velocitypoireau;

void setup()
{
size(500, 500);
// Affiche les ports disponibles
println(Serial.list());
// Sélectionner le bon port
String portName = Serial.list()[2];
// Etablir la connexion
port = new Serial(this, portName, 9600);
port.bufferUntil(‘\n’);

// afficher bus midi
MidiBus.list(); // List all available Midi devices on STDOUT. This will show each device’s index and name.
// Sélection bus midi
myBus = new MidiBus(this, -1, « versLive »);
}

void draw()
{
// Affiche l’arriere plan (ne sert à rien)
background(0,0,brightness);
// Invoque la fontion note qui envoie des notes en midi
note();
}
// Fonction qui s’active quand une info arrive du port
void serialEvent(Serial p)
{
// stocke le message quand une ligne est sautée
String message = p.readStringUntil(LF);
if (message != null)
{
// on affiche le message dans la console
print(message);

// SI c’est un message a deux caractères, c’est un message qui provient du poireau
if (message.length() > 3){
float f = new Float(message);
velocitypoireau = int(f);
}

// SInon ça provient du piano ou de la perci
else{

// on récupére le premier caractere du message pour le comparer
// Ce caractère correspond à l’instrument que l’on va attribuer
char messageCuted = message.charAt(0);
//char messageCuted = message.charAt(1);
// on récupère le reste des caractères qui correspond à la note midi jouée
//String test = toString(message.charAt(1));

// On compare le premier caractère, 1 = carotte
if (messageCuted == (‘1′))
{
// on récupère l’instrument
piano = 1;
notepiano = 30;
}

if (messageCuted == (‘2′))
{
// on récupère l’instrument
piano = 1;
notepiano = 60;
}

if (messageCuted == (‘3′))
{
// on récupère l’instrument
piano = 1;
notepiano = 90;
}

if (messageCuted == (‘4′))
{
// on récupère l’instrument
percu = 1;
notepercu = 125;
}

if (messageCuted == (‘5′))
{
// on récupère l’instrument
percu = 1;
notepercu = 120;
}
}
}

}
void note()
{

// Note du poireau envoyée en permanence
myBus.sendNoteOn(1, int(random(120)), velocitypoireau);
// Si le piano est activé
if (piano == 1){
int channel = 0;
int pitch = 30;
int velocity = 100;
// Onjoue la note
myBus.sendNoteOn(channel, notepiano, velocity);
// 200ms plus tard on l’éteind
delay(200);
myBus.sendNoteOff(channel, notepiano, velocity);
piano = 0;
}

// Si la percu est activée
if (percu == 1){
int channel = 2;
int pitch = 30;
int velocity = 100;
// Onjoue la note
myBus.sendNoteOn(channel, notepercu, velocity);
// 200ms plus tard on l’éteind
delay(200);
myBus.sendNoteOff(channel, notepercu, velocity);
percu = 0;
}
}

 

 

 

http://playground.arduino.cc/Main/CapacitiveSensor?from=Main.CapSense

Laisser un commentaire

Votre e-mail ne sera jamais publié ni communiqué.

Vous pouvez utiliser ces balises et attributs HTML <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>