Luminosidad flectada erráticamente en proximidad

De Casiopea
Observación y propuestas Gestuales
TítuloObservación y propuestas Gestuales
Palabras Clavesecuencias
Período2022-2022
AsignaturaTaller de Diseño de Interacción
Del CursoTaller de Diseño de Interacción 2022
CarrerasDiseño, Diseño Industrial, Interacción y Servicios
Alumno(s)Matilde Croxatto Ullrich, Valentina Dietz, Andrés Aliaga Chandía
ProfesorDaniela Salgado, Leonardo Aravena, Herbert Spencer
URLhttps://github.com/MatildeCU/Luminosidad-flectada-erraticamente-en-proximidad

Observaciones

M - Aproximación versátil desde el vacío expansivo al volumen próximo

Para salir a observar los gestos se define este concepto como “Gestualidad , movimiento que tiene una huella en su acontecer y un eco como evidencia que lo delata, sobre su temporalidad y en su total expansión.”

Al nombrar aparece aquello escondido en la forma, la luz, el vacío.

Al habitar corporalmente un espacio dinámico se pasan por alto las sutilezas del andar, esas salidas del cuerpo en su aproximación a las cosas, el origen de una primera interacción física y sus sutiles expresiones que delatan la ocupación del vacío cercano.

Por esto se decide contemplar la versatilidad y agilidad de las manos dentro del habitar objetual y cotidiano. Lo dactilar que se acopla, presionando, trasladando y transformando, con sus pequeñas y segmentadas líneas que cubren un gran y complejo sistema de manipulación, los dedos se acomodan a las formas y tamaños, pudiendo aplicar fuerzas y movimientos preciosos, el apoyo de la palma juega con los volúmenes transportando la fuerza de torque desde el brazo.

Siendo el contexto en cual se desenvuelve la corporalidad total estas toman un rol más o menos importante, limitada por el rango de movilidad de las falanges de los dedos y la rotación de la muñeca.

Esta aproximación versátil desde el vacío expansivo al volumen próximo permite en su eco la construcción de el ritmo corporal. Se habita sobre una temporalidad latente en la acción. una deslumbrando a la otra en un continuo.

Las manos siendo este puente, que comunica entre la cosa y el cuerpo, que calza con agilidad la forma, transformando dos cosas incomunicadas en una.

Siendo el vacío la mínima expresión, cual proyecta paulatinamente al resto del cuerpo su intención.

La construcción segmentada del gesto se vuelve más aparente

1A6D312B-BFA7-41AE-B3E9-A4E17285B618.jpeg

Resguardo articular por planos y segmentos encontrados en la comprensión corporal. Se observa cómo la mano entro de un espacio conformado por el cuerpo cobra un rol de privacidad en cuanto a la manipulación de un artefacto, en este caso el celular. Se identifican partes de esta extremidad y se nombran las funciones determinadas a cada una dentro del mismo gesto.

C35627D3-5E07-47D2-B23F-263FC27D7939.jpeg

Levedad del espacio inscrito en el movimiento amplificado desde un plano que lo manipula con suavidad. La división del cuerpo para cumplir una tarea, está compuesta por breves y distintos gestos.

5A2D453F-DD33-42B3-BD4A-9E69DDEFB10A.jpeg

Planos Transversales calzados, movilizados con fuerza en una evolución de vacíos y luces flechadas.

C0BE63B4-4AD0-40F4-AA85-C5CD94B7582C.jpeg

Cambio de estado en el vacío angular envolvente, tras la rotación lineal de un volumen.

A-Rodear sostenido del vacío

Desde los átomos a las galaxias es curioso reflexionar que, así como los organismos vivos crecen rodeándose a sí mismos, los seres humanos nos organizamos rodeando o rodeándonos unos a otros, acercándonos, alejándonos y colisionando.

Gesto (Lat. Gestus: traer, llevar consigo), referido formalmente al lenguaje corporal de las personas.

Obs 1 PG tdi AAC.jpg

Se ha tomado como punto de partida el recorrer rodeando y los movimientos que componen la navegación sensorial humana. Dentro de los casos observados, se pudo determinar que el cuerpo se moldea al recorrido. El cuerpo propone un recorrido. El cuerpo sostiene un recorrido.

En el caso de rodeos por una cosas inertes u objeto, el cuerpo adoptará tres ejes que ordenarán su navegación. Uno de dirección y sentido del desplazamiento, este eje es el encargado de desplazar al cuerpo a través del recorrido. Por otra parte, un segundo eje quiebra este primero para posicionar la cabeza, o la extremidad en la que se encuentre el sentido utilizado, frente a lo recorrido; Y por un tercer eje el sentido utilizado moverá (paneará) el sentido utilizado.

Luego, en una dimensión social se rodea la comunicación, aquí se sostiene lo inmaterial, por lo que, siempre es un en torno al vacío. El cuerpo será ahora el encargado de moldear ese vacío disponiéndose sostenido en el espacio con una postura que permita la interacción directa (Frente a frente) o semi-directa (otorgando solo una parte del cuerpo a los interlocutores). Una vez moldeado el vacío central, el gesto comunicativo será un movimiento corporal, de atención, explicación, conversación, etcétera; que estará soportado por una postura “prolongadamente” estática ¿por qué los seres humanos necesitamos soportar ese vacío comunicativo estáticamente? ¿podríamos des-armar ese vacío y seguir sosteniendo la comunicación?

Obs 2 PG tdi AAC.jpg

En otro tipo de recorrido sensorial, en el que se pierde algún sentido, y/o están difusos además otros, el gesto adquiere un carácter navegante, como perdido o errático. Esta navegación busca el estímulo significante, como desencadenante del entendimiento sensitivo del espacio, de aquí en más, nuestro cuerpo tendrá un punto de partida para enlazar un sistema de relaciones que genere una imagen (lat. Imago: Imitación o copia) que le dé sentido a los sentidos...algo así como el movimiento de encontrar un orden o el movimiento des-ordenado que ordena.

Obs 4 PG tdi AAC.jpg

¿Qué rol desempeña la marca, o trazado “permanente” del gesto? Desde el alba del pensamiento humano, este se ha esmerado en dejar huella de su recorrido. Es decir, en este caso, se deja la marca del gesto de recorrer o se estampa la evidencia de que este tuvo lugar. Podríamos hablar entonces de superficies con un gesto sostenido.

Obs 3 PG tdi AAC.jpg

Se podría realizar entonces una disección de dimensiones del gesto: Dimensión temporal, o capacidad del gesto de sostenerse en el tiempo (efímero-permanente). Una dimensión física kinésica, relacionada directamente con los movimientos. Y una dimensión sensorial, como el vínculo entre el movimiento y la sensación, o la racionalización de lo que produce el movimiento.






V - Apertura y recogimiento articulado en continuidad

Surf - Apertura y Recogimiento

Apertura y Recogimiento - Cuerpo en movimiento

El estudio de observación comienza enfocándose en la búsqueda de gestualidad en torno a un espacio de trayectoria, por lo que aparece en una primera instancia el cuerpo humano en movimiento.

En este caso se muestra el cuerpo cómo un elemento en movimiento constante que se hace parte del entorno directamente completando un todo de “situación” o “acción”. el surf comprende un deporte en el cual el cuerpo se va adaptando a través de “aperturas y cierres” para poder generar el equilibrio y rapidez necesaria.

“El cuerpo se tensiona expectante frente a las condiciones que se presentan espontáneamente”

A partir de las condiciones en donde el cuerpo interactúa directamente con el entorno, podemos decir que salen a la luz ciertas expresiones gestuales corporales que van revelando la acción. Se encuentran casi todas las partes del cuerpo interactuando en el espacio, pero podemos destacar particularmente las extremidades y sus articulaciones; Brazos - Codos y Piernas - Rodillas.

“Los brazos bajan, las rodillas también. El cuerpo se cierra para un mayor equilibrio frente a la velocidad..”

“El cuerpo se abre. Abraza el vacío para subir la velocidad y encontrar el ritmo presente en el entorno; el agua.”

Es por esto que enfocamos el estudio a la particularidad abstracta del Abrir - Cerrar // Contraer - Soltar observada en el movimiento corporal continuo.


Yoga - Predominancia de extremidades articuladas

Apertura y Cierre - Extremidades articuladas como expresión gestual reveladora

Por otra parte, aparece un segundo elemento de estudio; él Yoga. Dentro de la práctica de yoga aparecen categorizaciones dentro de las posturas realizadas; las de apertura y las de cierre.

“Encuentro con él propio cuerpo, su flexibilidad y su constante articulación..”

Las posturas de apertura se enfocan principalmente en que la parte frontal del cuerpo se exponga hacia él cielo, revelando la entrega, él regalar, él abrirse al exterior. Mientras que la parte trasera va hacia la tierra. Cómo por ejemplo; Apertura de pecho, puente, cobra, apertura de cadera, etc.

Mientras que en las posturas de cierre buscan una introspección, en donde la parte frontal del cuerpo, en especifico él pecho, se dirige con fuerzas hacia la tierra. -Cerrar, mirar hacia adentro, recibir, cuidar-

“Él cuerpo se abre entregándose hacia él cielo.. Curvatura generada a partir de articulaciones.. él cuerpo en su totalidad expresa solo una curva..”

“Equilibrio con un punto de apoyo.. extremidades cómo soporte..”

Desde aqui, se buscan detalles particulares dentro de cada gestualidad en la práctica, llegando a la conclusión de la importancia de las extremidades. Nuevamente se presentan estos elementos cómo foco de atención frente a la expresión corporal. Estos se van mostrando de manera progresiva y muy predominantes dentro de cada postura y movimiento. Finalmente se exponen cómo soportes, gestores de lo que se busca hacer aparecer; la apertura y él cierre continuo.


Passiflora - Trayectoria, Unión y Encuentro

Espirales envolventes guías que permiten el encuentro en una trayectoria, distancia o recorrido..

Otro estudio presente nos habla de la trayectoria, de las uniones y los encuentros. La “passiflora” es un arbusto - enredadera, que dentro de su forma contiene ciertos “espirales” conectores entre tallos y raíces, los cuales permiten la estructura de enredadera y su adherencia frondosa a las superficies.

Estos espirales se muestran cómo conectores esenciales para su forma. Se van haciendo parte sutilmente de un nuevo tallo, hasta lograr atraparlo y unirlo con él que se encuentra en él otro extremo.

“las uniones que generan la frondosidad se van creando a través de encuentros entre curvas que van creando una trayectoria “uniones guías”...”

“...extensiones del tallo que aparecen para envolver de manera curva. Espiral envolvente que permite él encuentro en una trayectoria, distancia o recorrido..”

Unión de observaciones

Se conversó como grupo sobre las diversas observaciones y encuentros que tuvimos, llegando a una observación por cada uno, que guiará la propuesta final del totem. Se determinó el concepto de proximidad como uno de estos, por lo cual unos de los inputs del Tótem es un sensor de ultra sonido el cual mide la distancia de un objeto enviando y recibiendo señales sonoras. La segunda característica observada es lo errático, aquello es expresado el en el movimiento de dentro del Tótem, el cual se efectuará mediante un motor activado por los sensores ultrasónicos. Este movimiento será expresado por una tela al interior del objeto. Luz Flectada es aquello que se logró en la unión se estos conceptos.

Además se presentarán dos output con máximos y mínimos, la intensidad de las luces manejadas con botones ubicados en los laterales del Tótem y la altura en desplazamiento de estas. Esto ya que se dispondrán ocho botones en total, cada cara contará con dos, los cuales se podrán activar en pares o individualmente. Cara placa con los botones estará en distintas alturas, así se tendrá que disponer el cuerpo a estirarse o a recogerse para activarlos.

M2 - gesto MVA - integracion obs.jpg
M2 - gesto MVA - integracion obs 2.jpg

Acercamiento a la forma

Pruebas constructivas - Avances

Pruebas constructivas a escala menor
Construccion escala menor totem MVA pruebas constructivas (2).jpg
Totem escala real terminado.jpg

Partimos probando cilindros de tela que se van recogiendo mientras se proyecta la textura de estos mismos en contraluz. La luz central se va controlando manualmente en búsqueda de pruebas; subir y bajar, acercarse y alejarse, etc. A partir de estas pruebas van apareciendo distintas proyecciones en el espacio, de las cuales podemos rescatar algunas más interesantes que otras. La luz se hace parte relevante en la proyección cuando ambas telas se superponen en movimiento y la fuente luminica se va acercando a la "arruga".

Luz flectada mva 2.PNG Luz flectada MVA.PNG

Luego comenzamos a realizar las pruebas a escala real, en donde pudimos replicar de cierta manera lo descubierto en el movimiento de las telas, pero esta vez a través de hilos. En donde los hilos integrados a la tela arrugan esta misma para ir formando distintas texturas dentro del espacio en contraluz.

Pruebas constructivas a escala real

Tela - Hilos

Pruebas tela escala real mva (1).PNG Pruebas tela escala real mva (2).PNG

Mecanismo tela - hilos

Hilos tela mva 2.PNG Hilos tela mva.jpg Mecanismo tela hilos mva.jpg

Luz

Luz totem MVA (2).jpg Luz totem MVA (1).jpg Luz totem MVA (3).jpg Luz totem MVA (12.PNG

Mecanismos

Arduino

Motor Superior

Diagrama
Código

Motor Inferior

Diagrama
Código

Código del motor inferior, el cual mueve la caja de led por un eje vertical. Se controla cuanto sube y baja con botones ubicados en una de las caras del tótem.

#include <SoftwareSerial.h>
//Valores editables
int radio=10; // medida del radio del eje del motor en milimetros
int distancia= 100; // distancia de recorrido de la cuerda en milimetros
int duracion=10; // tiempo del recorrido en segundos, 10 para enrollar y 10 para desenrollar
const int stepPin = 5; // pin de conexión al arduino
const int dirPin = 11; // pin de conexión al arduino
const int enPin = 12; // pin de conexión al arduino
int unidadtiempo=(0.0455/radio); // constante dividida por el radio del eje del motor
int total= 50; // tiempo dividido por unidadtiempo
int perimetro=(2*PI*radio); // perímetro del espesor del eje del motor
int calculo1=(distancia/perimetro); // cálculo para saber cuantas vueltas debe dar el motor en una distancia determinada
int calculo2=(calculo1*1600); // cálculo 1 por 1600 (correspondiente a una vuelta del motor)
int aumentar = 7;  
int disminuir = 8; 
void setup() {
 Serial.begin(9600);
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
pinMode(enPin,OUTPUT);
digitalWrite(enPin,LOW);
pinMode(disminuir, OUTPUT);
 pinMode(aumentar, OUTPUT);
 digitalWrite(aumentar,LOW);
 digitalWrite(disminuir,LOW);
}
void loop() {
digitalWrite(dirPin,HIGH); // sentido de giro del motor a la derecha
if (digitalRead(aumentar) == HIGH)
{
 Serial.println("aumentar");
//for(int x = 0; x < calculo2; x++) { // ciclo for para mantener la duración del ciclo
digitalWrite(stepPin,HIGH);
delayMicroseconds(total);
digitalWrite(stepPin,LOW);
delayMicroseconds(total);
//}
}
//delay(10); // un segundo de retraso
digitalWrite(dirPin,LOW); // sentido de giro del motor a la izquierda
if (digitalRead(disminuir) == HIGH)
{
 Serial.println("disminuir");
//for(int x = 0; x < calculo2; x++) {
digitalWrite(stepPin,HIGH);
delayMicroseconds(total);
digitalWrite(stepPin,LOW);
delayMicroseconds(total);
//}
}
//delay(10); // un segundo de retraso
}


Luces

Código de una variante lumínica, para activar con una placa botón. Esta variante opera con un ciclo for el cual sube y baja la intensidad de las luces, pasando por los colores de manera separada.

 int r= 3;
 int g= 5;
 int b= 6;
 void setup() {
 // put your setup code here, to run once:
 Serial.begin(9600);
 pinMode(r, OUTPUT);
 pinMode(g, OUTPUT);
 pinMode(b, OUTPUT);
 }
 void loop() { 
 for (int i = 0 ; i < 256 ; i ++){ //rojo
 analogWrite(r,i);
 delay(10);
 }
 for (int i = 256 ; i > 0 ; i --){
 analogWrite(r,i);
 delay(10);
 }
 for (int i = 0 ; i < 256 ; i ++){ //verde
 analogWrite(g,i);
 delay(10);
 }
 for (int i = 256 ; i > 0 ; i --){
 analogWrite(g,i);
 delay(10);
 }
 for (int i = 0 ; i < 256 ; i ++){//azul
 analogWrite(b,i);
 delay(10);
 }
 for (int i = 256 ; i > 0 ; i --){
 analogWrite(b,i);
 delay(10);
 }
 }


Se realizan dos códigos para interactuar con los botones ya que el tiempo que demora un arduino en realizar cada acción es considerable ses decide separar en dos arduinos mini los input de las placas pres. Cada arduino tiene un código para operar cuatro botones cada uno y a su vez el motor


Arduino A los OUTPUT de estos botones tiene que ver con las cualidades de las luces led que se presentan en una caja suspendida y dirigida por un riel al interior del tótem. Las cualidades que se pueden manipular es el delay (aumentarlo y diminuirlo), la aparición random de un color y un loop que pasa por distintos colores cambiando su intensidad al hacerlo.

int r= 3;
int g= 5;
int b= 6;
int c1d= 2;
int c1i= 4;
int c2d= 7;
int c2i= 8; 
void setup() {
Serial.begin(9600);
pinMode(r, OUTPUT);
pinMode(g, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c1d, INPUT);
pinMode(c1i, INPUT);
pinMode(c2d, INPUT);
pinMode(c2i, INPUT);
/*digitalWrite(c1d,LOW);
digitalWrite(c1i,LOW);
digitalWrite(c2d,LOW);
digitalWrite(c2i,LOW);*/
 randomSeed(analogRead(c2d));

}

void loop() {
  if (digitalRead(c1d) == HIGH) //cambio de color por medio de subidas y bajadas de intencidad lumínica
{
 for (int i = 0 ; i < 256 ; i ++){ //rojo
 analogWrite(r,i);
 delay(10);
 }
 for (int i = 256 ; i > 0 ; i --){
 analogWrite(r,i);
 delay(10);
 }
 for (int i = 0 ; i < 256 ; i ++){ //verde
 analogWrite(g,i);
 delay(10);
 }
 for (int i = 256 ; i > 0 ; i --){
 analogWrite(g,i);
 delay(10);
 }
 for (int i = 0 ; i < 256 ; i ++){//azul
 analogWrite(b,i);
 delay(10);
 }
 for (int i = 256 ; i > 0 ; i --){
 analogWrite(b,i);
 delay(10);
 }
}
if(digitalRead(c1i) == HIGH){ //decrecer el delay al cambiar los colores
 for (int d = 1000 ; d > 10 ; d --){
   analogWrite(g,200);
   delay(d);
   analogWrite(r,200);
   delay(d);
   analogWrite(b,200);
   delay(d);
   analogWrite(g,200);
   delay(d);
 }
 }
int vf=0;
 vf = digitalRead(c2d); //cambio de color de manera azarosa cada vez que se activa
   if(vf){
     float col1= random(0,255);
     float col2= random(0,255);
     float col3= random(0,255);
   Serial.print("entro");   
   analogWrite(r, col1);
   analogWrite(g, col2);
   analogWrite(b, col3);
   delay(1000);   
     }
    else{
   analogWrite(r, 0);
   analogWrite(g, 0);
   analogWrite(b, 0);
   delay(100);  
 }
if (digitalRead(c2i) == HIGH){
  for (int d = 10 ; d < 1000 ; d ++){ //crecer el delay al cambiar los colores
  analogWrite(b,200);
   delay(d);
   analogWrite(g,200);
   delay(d);
   analogWrite(r,200);
   delay(d);
   analogWrite(b,200);
   delay(d);
  }
 }
}


Arduino B

Como OUTPUT se define al acenso y descenso de la caja de led por el riel, utilizando un sistema de poleas con motor. a la vez que baja se va intensificando el color rojo y cuando asciende se intensifica el color azul.

int r= 3;
int g= 5;
int b= 6;
int c3d= 2; //disminuir
int c3i= 4;
int c4d= 7; //aumentar
int c4i= 8;
int radio=10; // medida del radio del eje del motor en milimetros
int distancia= 100; // distancia de recorrido de la cuerda en milimetros
int duracion=10; // tiempo del recorrido en segundos, 10 para enrollar y 10 para desenrollar
const int stepPin = 5; // pin de conexión al arduino 
const int dirPin = 11; // pin de conexión al arduino
const int enPin = 12; // pin de conexión al arduino
int unidadtiempo=(0.0455/radio); // constante dividida por el radio del eje del motor
int total= 50; // tiempo dividido por unidadtiempo
int perimetro=(2*PI*radio); // perímetro del espesor del eje del motor
int calculo1=(distancia/perimetro); // cálculo para saber cuantas vueltas debe dar el motor en una distancia determinada
int calculo2=(calculo1*1600); // cálculo 1 por 1600 (correspondiente a una vuelta del motor)
void setup() {
Serial.begin(9600);
pinMode(r, OUTPUT);
pinMode(g, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c3d, OUTPUT); //disminuir
pinMode(c3i, INPUT);
pinMode(c4d, OUTPUT); //aumentar
pinMode(c4i, INPUT);
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
pinMode(enPin,OUTPUT);
digitalWrite(enPin,LOW);
digitalWrite(c3d,LOW); //disminuir
digitalWrite(c4d,LOW); //aumentar
}
void loop() {
digitalWrite(dirPin,HIGH); // sentido de giro del motor a la derecha
if (digitalRead(c4d) == HIGH)
{
 Serial.println("aumentar");
//for(int x = 0; x < calculo2; x++) { // ciclo for para mantener la duración del ciclo
digitalWrite(stepPin,HIGH);
delayMicroseconds(total);
digitalWrite(stepPin,LOW);
delayMicroseconds(total);
//}
}
//aumento del color azul
if (digitalRead(c4i) == HIGH) //cambio de color por medio de subidas y bajadas de intencidad lumínica
{
 for (int i = 0 ; i < 256 ; i ++){ //azul
 analogWrite(b,i);
 delay(100);
 }
}
//delay(10); // un segundo de retraso
 digitalWrite(dirPin,LOW); // sentido de giro del motor a la izquierda
if (digitalRead(c3d) == HIGH)
{
 Serial.println("disminuir");
//for(int x = 0; x < calculo2; x++) {
digitalWrite(stepPin,HIGH);
delayMicroseconds(total);
digitalWrite(stepPin,LOW);
delayMicroseconds(total);
//}
}
 //aumento del color rojo
if (digitalRead(c3i) == HIGH) //cambio de color por medio de subidas y bajadas de intencidad lumínica
{
 for (int i = 0 ; i < 256 ; i ++){ //rojo
 analogWrite(r,i);
 delay(100);
 }
}
//delay(10); // un segundo de retraso
}

Funcionamiento del mecanismo de seguimiento del recorrido

Se instalan cuatro sensores de proximidad en la parte inferior del totem. Estos sensores serán los encargados de informar al mecanismo qué cara es la que debe modificar, así, si estoy en la cara 1, el motor posicionará el mecanismo de acción en esa cara.

Código

Este código identifica la cara en la que esta ubicado el usuario y envía cierta cantidad de pasos (dependiendo de la cara C1:200, C2:600, C3:1000,C4:1400 *step ). una vez posicionado, hace presiones random dentro de esta cara, luego vuelve a su posición inicial


#include <Servo.h
int trigPin1 = 51;   // Elegimos el pin para Trig1
int echoPin1 = 50;    // Elegimos el pin para Echo1
long duration1, cm1; // Variables que utilizaremos
int trigPin2 = 47;   // Elegimos el pin para Trig1
int echoPin2 = 46;    // Elegimos el pin para Echo1
long duration2, cm2; // Variables que utilizaremos
int trigPin3 = 49;   // Elegimos el pin para Trig1
int echoPin3 = 48;    // Elegimos el pin para Echo1
long duration3, cm3; // Variables que utilizaremos
int trigPin4 = 53;   // Elegimos el pin para Trig1
int echoPin4 = 52;    // Elegimos el pin para Echo1
long duration4, cm4; // Variables que utilizaremos
Servo servo1;
const int stepPin = 5; // pin de conexión al arduino
const int dirPin = 11; // pin de conexión al arduino
const int enPin = 12; // pin de conexión al arduino
int pos = 0;
int C1 = 200;
int C2 = 1000;
int C3 = 600;
int C4 = 1400;
int pasos;
 boolean di;//booleano qUe controla el sentido de giro
 void setup() {
 Serial.begin(9600);
 servo1.attach(2);
 pinMode(stepPin, OUTPUT);
 pinMode(dirPin, OUTPUT);
 pinMode(enPin, OUTPUT);
 digitalWrite(enPin, LOW);
 pinMode(trigPin1, OUTPUT);  //Definimos inputs y outputs
 pinMode(echoPin1, INPUT);
 pinMode(trigPin2, OUTPUT);  //Definimos inputs y outputs
 pinMode(echoPin2, INPUT);
 pinMode(trigPin3, OUTPUT);  //Definimos inputs y outputs
 pinMode(echoPin3, INPUT);
 pinMode(trigPin4, OUTPUT);  //Definimos inputs y outputs
 pinMode(echoPin4, INPUT);
 }
void loop() {
 analogWrite (A1, 2.5);
 lectura(trigPin1,echoPin1,duration1, cm1);
 lectura(trigPin2,echoPin2,duration2, cm2);
 lectura(trigPin3,echoPin3,duration3, cm3);
 lectura(trigPin4,echoPin4,duration4, cm4);
 if (cm1 < 20) {
   analogWrite (A1, 0);
   Serial.println ("CCCaARa 11111111111");
   posicionate(pos, C1);
   Serial.println (pos);
   posicion1(C1);
 }
 if (cm2 < 20) {
   posicionate(pos, C2);
   Serial.println("CaaaRa 22222222");
   posicion1(C2);
 }
 if (cm3 < 20) {
   analogWrite (A1, 5);
   posicionate(pos, C3);
   Serial.println ("CCCaARa 33333333");
   posicion1(C3);
 }
 if (cm4 < 20) {
   posicionate(pos, C4);
   Serial.println ("CCCaARa 44444444");
   posicion1(C4);
 }
 }


void lectura (int trig, int echo, long duration, long cm) {
 digitalWrite(trig, LOW);
 delayMicroseconds(5);
 digitalWrite(trig, HIGH);
 delayMicroseconds(10);
 digitalWrite(trig, LOW);
 // La duración es el tiempo, en microsegundos que tarda la señal
 pinMode(echo, INPUT);
 duration = pulseIn(echo, HIGH);
 // Convertimos el tiempo en distancia
 cm = (duration / 2) * 0.0344;
  }
void posicion1(int cara) {
 int as = random(5);
 int t = 1;
 digitalWrite(dirPin, HIGH);    // sentido de giro del motor a la derecha
 //envío de posición al servo
 servo1.write(45);
 delay(100);
 for (int x = 0; x < cara; x++) { // ciclo for para llegar a la posicion random mov (X,Z)
   digitalWrite(stepPin, HIGH);
   delay(t);
   pos = pos + 1;
   digitalWrite(stepPin, LOW);
   delay(t);
 }
 float locura = random (400); //búsqueda random, movimiento en la cara
 int tiemDloc = 10; //tiempo para alcanzar a posicionar el servo
 int angLoc = int (random(5, 30)); //ángulo random del servo en la cara que corresponde.
 digitalWrite (dirPin, HIGH);
 for (int x = 0; x < locura ; x++) { // ciclo for para llegar a la posicion random mov (X,Z)
   digitalWrite(stepPin, HIGH);
   servo1.write(angLoc);
   delay(tiemDloc);
   pos = pos + 1;
   digitalWrite(stepPin, LOW);
   servo1.write(45);
   delay(tiemDloc);
 }
 digitalWrite (dirPin, LOW);
 for (int x = locura; x > 0; x--) { // ciclo for para llegar a la posicion random mov (X,Z)
   digitalWrite(stepPin, HIGH);
   servo1.write(angLoc);
   delay(tiemDloc);
   pos = pos + 1;
   digitalWrite(stepPin, LOW);
   servo1.write(45);
   delay(tiemDloc);
 }
 servo1.write(45);
 delay (100);
 digitalWrite (dirPin, LOW);
 for (int x = cara; x > 0; x--) { // ciclo for para llegar a la posicion random mov (X,Z)
   digitalWrite(stepPin, HIGH);
   delay(t);
   pos = pos + 1;
   digitalWrite(stepPin, LOW);
   delay(t);
 }
 /* delay(10); // 1/1000*10seg de retraso //  1/100 segundos
   //i = random(100);
   as = random(5);
   digitalWrite(dirPin, LOW); // sentido de giro del motor a la izquierda
   for (int x = 0; x < A; x++) {
    digitalWrite(stepPin, HIGH);
    servo1.write(as);
    delay(t);
    pos = pos - 1;
    digitalWrite(stepPin, LOW);
    servo1.write(45);
    delay(t);
   }
   delay(10); // un segundo de retraso}*/

}

  void posicionate (int Cpos, int cara ) { // Cpos= current posición, es decir la posicion que el motor tiene en este momento; 
  cara= al lugar que debe llegar.
 if (Cpos < 0) {
   di = false;
 }
 if (Cpos > 1600) {
   di = true ;
 }
 pasos =  cara - Cpos ;
 //if (di==false){digitalWrite(dirPin, HIGH);}
 // if (di==true){digitalWrite(dirPin, LOW);}}
//Fin del Código

Construcción Totem

load PDF

GitHub

Página web

https://matildecu.github.io/Luminosidad-flectada-erraticamente-en-proximidad/

Repositorio

https://github.com/MatildeCU/Luminosidad-flectada-erraticamente-en-proximidad