hyperdramatik - Benutzerbeiträge [de]

Random Acts of Vulnerability

2021-12-02T15:27:27Z

Rodolfo.acostacastro: /* DOME 3 (mini-dom) */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
[http://hyperdramatik.net/mediawiki/index.php?title=How_to:_build_a_mini_Dome_Pod_from_Drinking_Straws Instructions to Mini-Dome]

== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Hacks ==

Einfache Arduino-to-Arduino Kommunikation mit Vactrol

== Sound ==

Beispiele hochladen

=arbeitsprozess=

==1te Runde==
===Mini-Workshops===
====Ella Sound Workshop====
====Zoe Silicon Workshop====
===BAT===

==2te Runde==
===Proberaum HFS===
===NextLevel Festival===

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-02T07:55:13Z

Rodolfo.acostacastro: /* DOME 3 (mini-dom) */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Hacks ==

Einfache Arduino-to-Arduino Kommunikation mit Vactrol

== Sound ==

Beispiele hochladen

=arbeitsprozess=

==1te Runde==
===Mini-Workshops===
====Ella Sound Workshop====
====Zoe Silicon Workshop====
===BAT===

==2te Runde==
===Proberaum HFS===
===NextLevel Festival===

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Datei:RosaTelefonHack5.JPG

2021-12-02T07:48:08Z

Rodolfo.acostacastro:

Datei:RosaTelefonHack4.JPG

2021-12-02T07:46:05Z

Rodolfo.acostacastro:

Datei:RosaTelefonHack3.JPG

2021-12-02T07:45:15Z

Rodolfo.acostacastro:

Datei:RosaTelefonHack2.JPG

2021-12-02T07:44:46Z

Rodolfo.acostacastro:

Datei:RosaTelefonHack.JPG

2021-12-02T07:43:52Z

Rodolfo.acostacastro: Rodolfo.acostacastro lud eine neue Version von Datei:RosaTelefonHack.JPG hoch

Inneres des Spielzeugstelefon

Datei:RosaTelefonHack.JPG

2021-12-02T07:43:28Z

Rodolfo.acostacastro: Rodolfo.acostacastro lud eine neue Version von Datei:RosaTelefonHack.JPG hoch

Inneres des Spielzeugstelefon

Datei:RosaTelefonHack.JPG

2021-12-02T07:42:03Z

Rodolfo.acostacastro: Inneres des Spielzeugstelefon

Inneres des Spielzeugstelefon

Random Acts of Vulnerability

2021-12-02T07:37:29Z

Rodolfo.acostacastro: /* arbeitsprozess */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

=arbeitsprozess=

==1te Runde==
===Mini-Workshops===
====Ella Sound Workshop====
====Zoe Silicon Workshop====
===BAT===

==2te Runde==
===Proberaum HFS===
===NextLevel Festival===

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-02T07:33:54Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

=arbeitsprozess=

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-02T07:33:30Z

Rodolfo.acostacastro:

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= '''dokumentation_JAM''' 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

=arbeitsprozess=

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-02T07:32:59Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

'''= dokumentation_JAM 📎=
'''

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

=arbeitsprozess=

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-02T07:32:47Z

Rodolfo.acostacastro: /* Arbeitsprozess */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

=arbeitsprozess=

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-02T07:32:28Z

Rodolfo.acostacastro:

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

=Arbeitsprozess=

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:12:57Z

Rodolfo.acostacastro: /* DOME 3(mini-dom) */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 (mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:12:35Z

Rodolfo.acostacastro: /* DOME (3 mini-dom) */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3(mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:12:14Z

Rodolfo.acostacastro: /* DOME 3 mini-dom */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME (3 mini-dom) =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:11:42Z

Rodolfo.acostacastro: /* DOME 3 MINI-DOM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 mini-dom =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:11:06Z

Rodolfo.acostacastro: /* DOME 3 MINI-DOM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =
== Harte Materialien ==

Kunstrasen, Number pad, Bürstenroboter, ...

== Softe Materialien ==

== Sound ==

Beispiele hochladen

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:08:16Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:05:38Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let's go! 🔥

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:03:05Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

PS --> [https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T20:02:41Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

PS --> [[https://www.w3schools.com/charsets/ref_emoji.asp how to display Emojis: ]]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:59:10Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

PS --> [[how to display Emojis: https://www.w3schools.com/charsets/ref_emoji.asp]]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:58:43Z

Rodolfo.acostacastro: /* dokumentation_JAM 📎 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

PS --> how to display Emojis [[Special: https://www.w3schools.com/charsets/ref_emoji.asp]]

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:53:22Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM 📎=

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:52:59Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

📎

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:52:28Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

📎

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:52:12Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
📎

* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:48:52Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen 🦁
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:48:32Z

Rodolfo.acostacastro:

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

🦁

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:47:26Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM = 🦁

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:44:45Z

Rodolfo.acostacastro: /* dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
* let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T19:38:13Z

Rodolfo.acostacastro: /* MINI-DOME */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
*let´s go!

= DOME 1 =

== Harte Materialien ==

*Stretch-Jersey
*Polymorph
*Audiojacks
*Aux-Kabel
*Kunstblumen
*Röhrenfernsehe
etc...

== Softe Materialien ==

*Processing-Codes
*Fingerhäkeln: https://www.youtube.com/watch?v=vfScF5EQ3sU

== Sound ==

*Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= DOME 3 MINI-DOM =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T13:32:49Z

Rodolfo.acostacastro: /* DOME 2 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
*let´s go!

= DOME 1 =

== Harte Materialien ==

Polymorph, Kunstrasen, Audiojacks, Aux-Kabel, Kunstblumen, Röhrenfernseher, Jersey, etc...

== Softe Materialien ==

Codes Processing

== Sound ==

Klangbeispiele hochladen

= DOME 2 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= MINI-DOME =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T13:32:34Z

Rodolfo.acostacastro: /* DOME 3 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
*let´s go!

= DOME 1 =

== Harte Materialien ==

Polymorph, Kunstrasen, Audiojacks, Aux-Kabel, Kunstblumen, Röhrenfernseher, Jersey, etc...

== Softe Materialien ==

Codes Processing

== Sound ==

Klangbeispiele hochladen

= DOME 2 =

= MINI-DOME =

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T13:32:14Z

Rodolfo.acostacastro: /* DOME 2 */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
*let´s go!

= DOME 1 =

== Harte Materialien ==

Polymorph, Kunstrasen, Audiojacks, Aux-Kabel, Kunstblumen, Röhrenfernseher, Jersey, etc...

== Softe Materialien ==

Codes Processing

== Sound ==

Klangbeispiele hochladen

= DOME 2 =

= DOME 3 =

== Harte Materialien ==

Watte, Silikon, Kunstblumen, LED-Kerzen....

== Softe Materialien ==

== Sound/Klang ==

Beispiele hochladen

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:06:59Z

Rodolfo.acostacastro: /* Dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
*let´s go!

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:06:41Z

Rodolfo.acostacastro: /* Dokumentation_JAM */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
*let´s go!

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:06:19Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Dokumentation_JAM =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:05:34Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:05:12Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:04:58Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.

[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]
----

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:04:43Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

* Bilddokumentation sammelt und einordnen
* künstlerisch/ästhetisch mit dem Material umgehen
* Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
* Code-Snippets, Schaltpläne, Materialen, Skizzen
* usw.
----
[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T12:03:22Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

- Bilddokumentation sammelt und einordnen
- künstlerisch/ästhetisch mit dem Material umgehen
- Dokumentieren auch Fehler, persönliche Ansprüche und Gespräche, Unerwartetes genauso wie
- Code-Snippets, Schaltpläne, Materialen, Skizzen
- usw.
[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T11:59:15Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

Text text text text
[[File:doku_nextLevel.jpg| thumb |Die Frage ist: wie stellt man eine Dokumentation?]]

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T11:58:26Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

Text text text text
[[File:doku_nextLevel.jpg| thumb |caption]] wie stellt man eine Dokumentation?

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T11:57:25Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

Text text text text
[[File:doku_nextLevel.jpg|frameless|border|caption]] wie stellt man eine Dokumentation?

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>

Random Acts of Vulnerability

2021-12-01T11:56:22Z

Rodolfo.acostacastro: /* Meta-Dokumentation */

Random Acts of Vulnerability ist ein immersives Spiel für vier Spieler*innen in vier Dimensionen. Durch Erkundung und Dokumentation der jeweils eigenen Dimension, formen die Spieler*innen anhand des Gesammelten und Erlebten die Erzählungen selbst.
Auf ein installatives Netz aus experimentellen Materialen, soften Schaltkreisen, meditativen Klangwelten, grotesken Interfaces und verzerrten Output-Signalen aufbauend, werden Fragen nach Isolation, Einsamkeit, immaterieller und haptischer Vernetzung und der Herstellung von Verhandlungsgrundlagen gestellt.

Eine Arbeit von: Zoe Lohmann, Ella Estrella Tischa Raetzer, Rodolfo Acosta Castro, Lena Böckmann

Video: https://www.youtube.com/watch?v=850KCMYEAow&t=7s

https://live.staticflickr.com/65535/51681534884_545f161fd9.jpg

= Meta-Dokumentation =

[[File:doku_nextLevel.jpg|frameless|border|caption]]

= relevant links =

ESP with Arduino: http://hyperdramatik.net/mediawiki/index.php?title=ESP32_mit_Arduino

MQTT: http://hyperdramatik.net/mediawiki/index.php?title=Hauptseite#MQTT

DOMEs: http://hyperdramatik.net/mediawiki/index.php?title=Dome_Pod_KIT

= code examples from the project =

== Arduino code for sounds in the fishing-dome ==

// running on an ESP [[Spaghetti Monster]]

<source lang="js" line start="2" highlight="4-6">

int numOfSensors = 6;

byte analogPins[] = {
36, 39, 34, 35, 32, 33
};

void setup() {
for (int i = 0; i < numOfSensors; i++) {
pinMode(analogPins[i], INPUT);
}
Serial.begin(9600);
}

void loop() {
for (int i = 0; i < numOfSensors; i++) {
Serial.print(analogRead(analogPins[i]));
Serial.print("\t");
}
Serial.println();
delay(20);
}
</source>

== Processing code for sounds in the fishing-dome ==

CODE DESCRIPTION:
6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the fishing-dome

6 textile stretch sensors trigger
6 different sounds
when they pass a threshold.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import processing.serial.*;
import ddf.minim.*;
Serial myPort;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

///////////////////////////////////
//change these:
///////////////////////////////////
int numOfSensors = 6;
int ADCmax = 4095;
//int ADCmax = 1023;
float[] sensorThresholds = {1000, 1000, 1000, 1000, 1000, 1000};//new float[numOfSensors];
///////////////////////////////////

float[] sensorValues = new float[numOfSensors];
float[] previousSensorValues = new float[numOfSensors];
float xpos = 0;

void setup () {
size(600, 400);
smooth();
background(255);

println(Serial.list());
String portName = Serial.list()[1];
myPort = new Serial(this, "/dev/cu.SLAB_USBtoUART", 9600);
myPort.clear();
myPort.bufferUntil('\n');

minim = new Minim(this);
sound0 = minim.loadSample( "harddisc_grummeln_kurz.wav", 512);
sound1 = minim.loadSample("crazyfrogbardcore.wav", 512);
sound2 = minim.loadSample("musterfinal.wav", 512);
sound3 = minim.loadSample("harddisc_grummeln_kurz.wav", 512);
sound4 = minim.loadSample("hihat_single.wav", 512);
sound5 = minim.loadSample("kick_single.wav", 512);
}

void draw () {
graph();
}

void graph() {
for (int i=0; i<numOfSensors; i++) {
if (sensorValues[i] < sensorThresholds[i]) sound(i);

// map the incoming values to an appropriate range:
float ypos = map(sensorValues[i], ADCmax, 0, 0, height/numOfSensors);

// figure out the y position for this particular graph:
float graphBottom = i * height/numOfSensors;
ypos = ypos + graphBottom;

// draw the graph bottoms:
stroke(0);
strokeWeight(1);
line(0, graphBottom, width, graphBottom);

// draw the thresholds:
stroke(200, 0, 0);
strokeWeight(1);
float redLine = map(sensorThresholds[i], ADCmax, 0, 0, height/numOfSensors);
line(0, redLine + graphBottom, width, redLine + graphBottom);

stroke(0);
strokeWeight(2);
line(xpos, previousSensorValues[i], xpos+1, ypos);

previousSensorValues[i] = ypos;

// if you've drawn to the edge of the window, start at the beginning again:
if (xpos >= width) {
xpos = 0;
background(215);
} else xpos+=0.1;
}
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

// if it's not empty:
if (inString != null) {
// trim off any whitespace:
inString = trim(inString);

// convert to an array of ints:
int incomingValues[] = int(split(inString, "\t"));

if (incomingValues.length <= numOfSensors && incomingValues.length > 0) {
for (int i = 0; i < incomingValues.length; i++) {
sensorValues[i] = incomingValues[i];
print(sensorValues[i] + "\t");
}
println();
}
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
case 4:
sound4.trigger();
break;
case 5:
sound5.trigger();
break;
}
}
</source>

== Processing code for sounds in the dating-dome ==

CODE DESCRIPTION:
4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.

<source lang="js" line start="2" highlight="4-6">
/*
RANDOM ACTS OF VULNERABILITY
code for sounds in the dating-dome

4 very sensitive "balloon-pushbuttons"
on a makey makey trigger sound files.
every minute there is a scene change
and the sound files are updated.
sound files should be stored in a folder
called "data" within the sketch folder.
*/

import ddf.minim.*;

Minim minim;
AudioSample sound0;
AudioSample sound1;
AudioSample sound2;
AudioSample sound3;
AudioSample sound4;
AudioSample sound5;

int delayTime = 800;
boolean w_released = true;
boolean d_released = true;
boolean s_released = true;
boolean a_released = true;
int maxCount = 3;
int w_count = 0;
int a_count = 0;
int s_count = 0;
int d_count = 0;
int szene = 0;
int previousSzene;
int soundChangeInterval = 5000;

void setup () {
size(1000, 800);
smooth();
minim = new Minim(this);
background(255);
}

void draw () {
szene = minute() % 3;
if (szene != previousSzene) {
previousSzene = szene;
println(szene);

if (szene == 0) {
sound0 = minim.loadSample("be.wav", 1000);
sound1 = minim.loadSample("come.wav", 1000);
sound2 = minim.loadSample("together.wav", 1000);
sound3 = minim.loadSample("withMe.wav", 1000);
}
if (szene == 1) {
sound0 = minim.loadSample("hihat_single.wav", 1000);
sound1 = minim.loadSample("hihat_single.wav", 1000);
sound2 = minim.loadSample("hihat_single.wav", 1000);
sound3 = minim.loadSample("hihat_single.wav", 1000);
}
if (szene == 2) {
sound0 = minim.loadSample("kick_single.wav", 1000);
sound1 = minim.loadSample("kick_single.wav", 1000);
sound2 = minim.loadSample("kick_single.wav", 1000);
sound3 = minim.loadSample("kick_single.wav", 1000);
}
}
}

void keyPressed() {
if ((key == 'w' || key == 'W') && w_released == true && w_count < maxCount) {
background(0);
w_released = false;
sound(0);
delay(delayTime);
w_count ++;
a_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 'a' || key == 'A') && a_released == true && a_count < maxCount) {
background(200, 0, 0);
a_released = false;
sound(1);
delay(delayTime);
a_count ++;
w_count = 0;
s_count = 0;
d_count = 0;
}
if ((key == 's' || key == 'S') && s_released == true && s_count < maxCount) {
background(0, 200, 0);
s_released = false;
sound(2);
delay(delayTime);
s_count ++;
w_count = 0;
a_count = 0;
d_count = 0;
}
if ((key == 'd' || key == 'D') && d_released == true && d_count < maxCount) {
background(0, 0, 200);
d_released = false;
sound(3);
delay(delayTime);
d_count ++;
w_count = 0;
a_count = 0;
s_count = 0;
}
}

void keyReleased() {
if (key == 'd' || key == 'D') {
d_released = true;
}
if (key == 'a' || key == 'A') {
a_released = true;
}
if (key == 's' || key == 'S') {
s_released = true;
}
if (key == 'w' || key == 'W') {
w_released = true;
}
}

void sound(int soundSample)
{
switch(soundSample) {
case 0:
sound0.trigger();
break;
case 1:
sound1.trigger();
break;
case 2:
sound2.trigger();
break;
case 3:
sound3.trigger();
break;
}
}
}
</source>