Friday, December 5, 2014

VIDEO ENTREGA FINAL

La relación constante entre el hombre y sus acciones se queda en lo instantáneo. No son muchas las reflexiones conscientes sobre lo que sucede en la inmediatez de nuestra realidad y las consecuencias que genera en nuestro alrededor. Somos y seremos esclavos de nuestro tiempo, y acostumbrados a esto, olvidamos como pasa frente a nosotros en cada momento. La memoria a corto plazo nos engaña constantemente; accionamos de ciertas maneras que fácilmente olvidamos. Hacemos y decimos cosas que al instante olvidamos, pero, ¿Qué pasa cuando nos enfrentamos al olvido inmediato?.


La entrega constó en 4 pantallas que encerraban al espectador, en cada una había un delay temporal diferente que llegaba de camaras ubicadas en el salón. La intención fue encerrar al espectador para que se preguntara ¿En qué momento mi pasado es mi presente?... la distorsión temporal nos bloquea en nuestro presente y nos hace pensar en el pasado que vemos en tiempo real.


Proyecto realizado por


SANTIAGO RODRÍGUEZ

VANESSA MIRANDA


https://www.youtube.com/watch?v=L2jdi7QD1Tw&feature=youtu.be

Thursday, December 4, 2014

Re: El respondedor


El 4 de diciembre de 2014, 4:11 p. m., Nicole Rodriguez<madnicky23@gmail.com> escribió:
Reenvio el video arreglado. Ayer no me había dado cuenta, pero no se subió completo a youtube. 

2014-12-03 21:21 GMT-05:00 Nicole Rodriguez <madnicky23@gmail.com>:


--
Nicole Rodríguez Sánchez
Cel: 311 211 3161



--
Nicole Rodríguez Sánchez
Cel: 311 211 3161



--
Nicole Rodríguez Sánchez
Cel: 311 211 3161

Wednesday, December 3, 2014

Corrección de video Paradigma


Hola Hamilton, te paso un nuevo link del video. Esta corregido. El otro no me parecio bueno. Este esta mejor.





Muchas gracias,

Saludos

Esteban Millán Pinzón

RV: Entrega Circuitos Dibujados



De: Karen Juliette Angulo Tobar
Enviado: miércoles, 03 de diciembre de 2014 2:45 p. m.
Para: thingco1.artetech@blogger.com
Asunto: Entrega Circuitos Dibujados
 

http://youtu.be/FxYrrd1QwJQ

Circuitos Dibujados - YouTube
Exploraciones. Integrando dibujos y circuitos básicos sobre distintos soportes.


Karen Angulo Tobar 

Re: Video Proyecto



2014-12-03 15:24 GMT-05:00 Esteban Millan Pinzon <estebanmillanpinzon@gmail.com>:

generador de notas "final"

int notamin =  30;
int notamax = 50;

void setup(){
  size(500,200);
 textSize(32);
text("generador de notas", 150, 100);  
}

void mousePressed(){
 
for(int i=0;i<3;i++){
  float notafinal= random(notamin, notamax);
println(notafinal);
background(random(255),random(255),random(255));
 textSize(32);
  text("generador de notas", 150, 100);
   text(notafinal, 150, 130);
  }
}

void draw(){

  
}

void keyPressed(){
  if (key == 'a'){
  for(int i=0;i<3;i++){
  float notafinal= random(notamin, notamax);
println(notafinal);
  }
  } 
  }

Proyecto final Alejandra López

El proyecto consiste en una instalación que posibilita una "interacción física" con una serie de imágenes que se ven animadas por la cantidad de luz que recibe una fotocelda.

Para lograr lo anterior se integraron las plataformas de Arduino y Processing. 
La primera controla los parámetros por lo cuales se regirá la fotocelda y la segunda estará encargada de la animación.

Los códigos son los siguientes:

ARDUINO

int photoRPin = 0; 
int minLight;
int maxLight;
int lightLevel;
int adjustedLightLevel;
int oldLightLevel;

void setup() {
  Serial.begin(9600);
  
  //Setup the starting light level limits
  lightLevel=analogRead(photoRPin);
  minLight=lightLevel-20;
  maxLight=lightLevel;
  oldLightLevel=lightLevel;
}

void loop(){
   lightLevel=analogRead(photoRPin);
   delay(10);
  
  //auto-adjust the minimum and maximum limits in real time   
   if(minLight>lightLevel){
     minLight=lightLevel;
   }
   if(maxLight<lightLevel){
     maxLight=lightLevel;
   }
   
   //Map the light level to produce a result between 1 and 28.
   adjustedLightLevel = map(lightLevel, (minLight+20), (maxLight-20), 1, 124); 
   adjustedLightLevel = constrain (adjustedLightLevel, 1, 124);
   
   /*Only send a new value to the Serial Port if the 
     adjustedLightLevel value changes.*/
   if(oldLightLevel==adjustedLightLevel){
     //do nothing if the old value and the new value are the same.
   }else{
     //Update the oldLightLevel value for the next round
     oldLightLevel=adjustedLightLevel;
     
     /*Send the adjusted Light level result 
       to Serial port (processing)*/
     Serial.println(adjustedLightLevel);
   } 
}     


PROCESSING

import processing.serial.*;
Serial myPort;
String sensorReading="";

PImage[] movieImage = new PImage[124];

/* The frame variable is  used to control which 
 image is displayed */
int frame = 1;



/* Setup the size of the window. Initialise serial communication with Arduino
 and pre-load the images to be displayed later on. This is done only once.
 I am using COM6 on my computer, you may need replace this value with your
 active COM port being used by the Arduino.*/

void setup() 
{
  size(700, 600);
  background(0);

  myPort = new Serial(this, "COM4", 9600);
  myPort.bufferUntil('\n');

  for (int i=0; i<122; i++) 
  {
    movieImage[i] = loadImage((i+3) + ".jpg");
  }
}




// The draw function controls the animation sequence.

void draw() 
{

  image(movieImage[frame-1],0,0,width,height);  

}

void serialEvent (Serial myPort) {
  sensorReading = myPort.readStringUntil('\n');
  if (sensorReading != null) {
    sensorReading=trim(sensorReading);
    if (sensorReading.length()<2) {
      frame = integerFromChar(sensorReading.charAt(0));
    } else {
      frame = integerFromChar(sensorReading.charAt(0))*10;
      frame += integerFromChar(sensorReading.charAt(1));
    }
  }
}



/* This function used to convert the character received from the
 serial port (Arduino), and converts it to a number */

int integerFromChar(char myChar) {
  if (myChar < '0' || myChar > '9') {
    return -1;
  } else {
    return myChar - '0';
  }
}


Entrega Circuitos Dibujados

http://youtu.be/FxYrrd1QwJQ

Circuitos Dibujados - YouTube
Exploraciones. Integrando dibujos y circuitos básicos sobre distintos soportes.


Karen Angulo Tobar 

Instalación Interactiva



Juan Felipe Martinez
Fabio Beltrán 
Sara Toro

Galeria de proyectos

El siguiente link es la galería virtual de los proyectos del taller:

http://librepensante.org/hotglue/?taller-arteytech/

Tuesday, December 2, 2014

TRABAJO FINAL ILANIT LITMAN

VIDEO DEL PROYECTO Y RESUMEN:



CODIGO DE PROGRAMACION DE ARDUINO ILANIT LITMAN
/*
Proyecto sensor ultrasonido para Arduino
 */


#define echoPin 7 // Echo Pin
#define trigPin 8 // Trigger Pin
#define LEDPin 13 // Onboard LED

int maximumRange = 200; // Rango máximo 
int minimumRange = 0; // Rango mínimo 
long duration, distance; // Duración utilizada para calcular distancia

void setup() {
 Serial.begin (9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(LEDPin, OUTPUT); // 
}

void loop() {
/* Este ciclo determina la distancia del objeto más cercano rebotando ondas contra él 
*/ 
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); 

 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH);
 
 //Calcular distancia (en cm) basada en velocidad del sonido.
 distance = duration/58.2;
 
 if (distance >= maximumRange || distance <= minimumRange){
 Serial.println("-1");
 digitalWrite(LEDPin, HIGH); 
 }
 else {
 /* Enviar distancia al computador utilizando protocolo serial, y apagar LED para indicar lectura apropiada. */
 Serial.println(distance);
 digitalWrite(LEDPin, LOW); 
 }
 
 //Delay 20ms before next reading.
 delay(20);
}

_________________________________

CODIGO DE PROCESSING ILANIT LITMAN

/*  processing sensor ultrasonido-representación gráfica 
 
*/
import processing.serial.*;


int numOfShapes = 60; // Número de cuadrados a representar en pantalla
int shapeSpeed = 2; // Velocidad en que los cuadrados se mueven a su nueva posición
 // 2 = Más rápido, Números mayores mas lentos

//Variables Globales
Square[] mySquares = new Square[numOfShapes];
int shapeSize, distance;
String comPortString;
Serial myPort;

/* -----------------------Setup ---------------------------*/
void setup(){
 size(displayWidth,displayHeight); //Utilizar toda la pantalla.
 smooth(); // Dibuja todas la figuras con bordes suavizados.
 
 /* Calcular el tamaño de los cuadrados e iniciar variedad de cuadrados */
 shapeSize = (width/numOfShapes); 
 for(int i = 0; i<numOfShapes; i++){
 mySquares[i]=new Square(int(shapeSize*i),height-40);
 }
 
 /*Abrir puerto para comunicación con Arduino*/
 myPort = new Serial(this, "/dev/tty.usbmodem411", 9600);
 myPort.bufferUntil('\n'); // Disparar nuevo evento serial en una nueva linea
}

/* ------------------------Draw -----------------------------*/
void draw(){
 background(0); //Fondo negro
 delay(50); //Delay de pantala
 drawSquares(); //Dibujar patrón de cuadros
}


/* ---------------------serialEvent ---------------------------*/
void serialEvent(Serial cPort){
 comPortString = cPort.readStringUntil('\n');
 if(comPortString != null) {
 comPortString=trim(comPortString);
 
 /* Utilizar la distancia recibida por Arduino para modificar la posición Y
 del primer cuadro (Los demás le siguen). 200 es la máxima distancia esperada. 
 Las distancia es luego asignada a un valor entre 1 y la altura de la pantalla.*/
 distance = int(map(Integer.parseInt(comPortString),1,200,1,height));
 if(distance<0){

 distance = 0;
 }
 }
}


/* ---------------------drawSquares ---------------------------*/
void drawSquares(){
 int oldY, newY, targetY, redVal, blueVal;
 
 /* Posición Y del primer cuadro basada en el valor recibido por el sensor */
 mySquares[0].setY((height-shapeSize)-distance);
 
 /* Refrescar la posición y el color de cada cuadrado */
 for(int i = numOfShapes-1; i>0; i--){
 /* Usar posición de cuadro anterior como objetivo */
 targetY=mySquares[i-1].getY();
 oldY=mySquares[i].getY();
 
 if(abs(oldY-targetY)<2){
 newY=targetY; //alineación
 }else{
 //caluclar nueva posición de cuadro
 newY=oldY-((oldY-targetY)/shapeSpeed);
 }
 //Ajustar nueva posición de cuadro
 mySquares[i].setY(newY);
 
 /*Calcular color de cuadro basado en posición en pantalla*/
 blueVal = int(map(newY,0,height,0,255));
 redVal = 255-blueVal;
 fill(redVal,0,blueVal);
 
 /* Dibujar cuadro en pantalla*/
 rect(mySquares[i].getX(), mySquares[i].getY(),shapeSize,shapeSize);
 }
}

/* ---------------------sketchFullScreen---------------------------*/
// Entrar en pantalla completa
boolean sketchFullScreen() {
 return true;
}

/* ---------------------CLASS: Square ---------------------------*/
class Square{
 int xPosition, yPosition;
 
 Square(int xPos, int yPos){
 xPosition = xPos;
 yPosition = yPos;
 }
 
 int getX(){
 return xPosition;
 }
 
 int getY(){
 return yPosition;
 }
 
 void setY(int yPos){
 yPosition = yPos;
 }
}

Monday, December 1, 2014

Codigo utilizado para el triciclo sonoro

#include <VirtualWire.h>

void setup()
{
Serial.begin(4800);
Serial.println("setup");
vw_setup(2000);
vw_set_tx_pin(1);
pinMode(8,INPUT);
}

void loop()
{
if (digitalRead(8)==HIGH)
{
char *msg = "2";
digitalWrite(13, true);
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
digitalWrite(13, false);
}
else
{
char *msg = "1";
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
}
}
ese es el código del emisor
manda un pulso vía radio frecuencia cuando se está espichando el botón
es decir, un 1 cuando se espicha y un 0 cuando se suelta
bueno...para cosas prácticas en este caso manda un 2 cuando se espicha y un 1 cuando se suelta...el segundo código es el del receptor:
#include <VirtualWire.h>
int acc=0;
int cont=2;
int val=1;
void setup()
{
Serial.begin(4800);
vw_set_ptt_inverted(true);
vw_setup(2000);
vw_set_rx_pin(2);
vw_rx_start();
}

void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
digitalWrite(13, true);
for (i = 0; i < buflen; i++)
{
if(buf[i] == '2')
{
if (acc== 0)
{
acc = 1;
Serial.write(val);
}
digitalWrite(13, true);
delay(5);
}
else
{
if (acc==1)
{
Serial.write(cont);
}
acc = 0;
digitalWrite(13, false);
}
}
digitalWrite(13, false);
}
}
este código agarra el dato recibido y dependiendo de lo que reciba envía un 1 o un 2 por puerto serial...
luego, en pD (puredata) se agarra ese valor del puerto serial y se convierte a una nota midi, si es 1 la manda por el canal midi 1 y respectivamente si recibe un 2 la manda por el canal 2...
por último, en algun programa de manejo de clips en vivo (como lo es Ableton Live, AudioMulch o el que usamos en este caso que fue Resolume) se le da trigger a un clip con el bombo (boom) cuando se presiona el botón, y un hihat cuando se suelta (tsszt)

Artes Electronicas - DANIELA GALLO

https://vimeo.com/113251009

Tras un análisis sobre los sistemas y las posibles forma de afectarlos se nos ocurrió utilizar el sonido y la acción como método para activar cuestionamientos sobre prácticas ordinarias como caminar o el uso de la bicicletas.

El proyecto consiste en una bicicleta anclada a una carretilla construida por el grupo.
La acción se activa siempre y cuando haya pedaleo, la caretilla es la encargada de sostener todos los equipos necesarios y además proporcionar una plataforma para diversificar los resultados de la acción sonora, según quien esté sobre ella y la segunda acción que éste decida realizar.  

Es un proyecto que sólo funciona si hay un usuario que lo active, parte de sonidos básicos de percusión que van marcando a través del audio el ritmo de la persona, el ritmo de vida. 


Saturday, November 22, 2014

RV: Prueba #1 Proyecto final

RePost


Hice la prueba con la tinta conductiva y esta vez, baterías de reloj de 3W, olvidé llevar los cables y no pude hacer las conexiones positivo y negativo con las baterías para luego unir esos cables a la tinta y encender el led. Así que por esta vez tuve que conectar directamente los LEDs a la baterías para al menos tener una idea general de cómo se va a ver.

 

Planeo hacer más conexiones y tomar un registro más detallado en mi próxima prueba, también poder cerrar los circuitos poniendo un dedo con tinta conductiva para encender las luces, y que así tenga más movimiento y sea más controlado. 


Link al video de prueba:  https://www.youtube.com/watch?v=z6E93u6f8_o

Artes Electrónicas: Prueba - YouTube

Wednesday, November 19, 2014

Ejercicio Arduino

En este ejercicio usé dos potenciometros para cambiar la potencia en dos extremos . El ejercicio fue muy instructivo, porque también pude visualizar el cambio de potencia en la pantalla gracias al código.

El mayor aprendizaje estuvo en mostrar el cambio en la pantalla, pues en mi proyecto debo proyectar cierta información sobre números y valores tonales.



​Santiago Rodríguez

Adelantos proyecto final

Imagen de como se vería la máquina una vez terminada.





El sensor de color TCS3200 puede detectar y medir una gama casi ilimitada de colores, usando. También recupera el color en código RGB para hacer los intervalos en la programación.


Santiago Rodríguez

Grabadora - experimentación (Fotos)

https://drive.google.com/open?id=0B9rgtXLChRYCcnh6U29ydHQydmFCYTBGdEVhem40WF9oX0FJ&authuser=0

https://drive.google.com/open?id=0B9rgtXLChRYCeVA1RF85d1FnSzI5a2dwN2huV1QyMUtnd2Fv&authuser=0

https://drive.google.com/open?id=0B9rgtXLChRYCUDBCdkF2VTBsNXlueXlOeHBiVU9QanFlUWNj&authuser=0

https://drive.google.com/open?id=0B9rgtXLChRYCWUR3V0xLbmtMUHZneVlaZzVwZGo2dUVDVXh3&authuser=0

https://drive.google.com/open?id=0B9rgtXLChRYCQ2Z0MmZ4S0ZVOHJ5QWJwU25Td3h6ZV9hUk53&authuser=0

Maria Camila Pinzón

Grabadora - experimentación

https://drive.google.com/open?id=0B9rgtXLChRYCVUk5Z0RyUHlWMTA2dU9Ucm50SWx3V0dleXg0&authuser=0

https://drive.google.com/open?id=0B9rgtXLChRYCWFJ4dDFZV01xN29jdFZGMDlteXJkTWZBazhN&authuser=0

https://drive.google.com/open?id=0B9rgtXLChRYCTGpGd19SWXFIWkFqOEh5VWRmNmM3c2tKYmdJ&authuser=0

Adelantos de experimentación
Maria Camila Pinzón

Proyecto Final

Mi proyecto esta inspirado en el trabajo museológico de Fred Wilson sobre la historia de los negros en Estados Unidos. (Mining the museum). En este caso, buscaré insertar los problemas de la discriminación en nuestro país a partir de una máquina.


Con un sensor de color RGB, esta máquina buscará interpelar al público con la manera en la que se nomina un color de piel. Rangos de colores diferenciados en escala RGB nos darán nuestra "raza" al acercar nuestra mano al sensor.

 



Santiago Rodríguez


SCISTARTER: Ciencia Comunitaria

Scistarter es una espacio en el cual se puede encontrar, compartir y contribuir con proyectos científicos, promoviendo la creación colectiva,
 reuniendo a varias personas al rededor del mundo. Esta plataforma online se interesa por proyectos de ciudadanos que se motiven por la ciencia 
y su contribución en nuevas tecnologias y formas de interactuar con su entorno. 

Scistarter no solo se abre como plataforma de intercambio de conocimientos
sino que tambien permite que nuevos proyectos jóvenes salgan a flote; del mismo modo, esta plataforma funciona como mediador entre los creadores 
del proyecto y quienes quieren ser parte de el, la mayoría son personas no cientificas pero que buscan hacer parte de esta comunidad cientifica comunitaria.

Por ejemplo, nos encontramos con este proyecto llamado, AIRCASTING donde a partir de una serie de elementos se busca que las personas sean mas concientes 
del grado de contaminación que hay en el ambiente. Es una aplicación de android que se conecta con un sensor en la ropa y por medio de un arduino recibe aire 
para asi procesarlo y poder enviar esta informacion globalmente para ver que tan contaminado se encuentra el espacio que habita dicha persona.

Sara Toro
Felipe Martinez

Pruebas circuitos simples con tinta conductiva y pintura corporal

Apliqué una capa de pintura, vinilo fluorescente y luego dibujé el circuito con la tinta conductiva, el led se secó junto con ésta, manteniéndolo fijo en la piel. Usé un porta baterías AA, para eso había que mantener los cables en contacto con el circuito, pero la idea es usar pilas de reloj y que se enciendan los LEDs cerrando el circuito, sea que la modelo tenga tinta en sus dedos y por contacto los encienda o acercando las baterías de reloj a la tinta para encender la luces. 

​La pintura fluorescente reacciona a la luz negra, y deja ver el diseño del circuito, además actúa como aislante de la tinta conductiva con la piel, para prevenir,  ya que desconozco el nivel de toxicidad que pueda tener.


Tuesday, November 18, 2014

Proyecto

Mi proyecto esta pensado para ilustrar los paradigmas mencionados anteriormente. Para ello voy a hacer un robot, capaz de moverse cuando algo se le aproxima.
El Robot constara de tres funciones básicas: Moverse hacia delante, atrás, y generar un sonido .


Primero es indispensable utilizar la estructura y el funcionamiento de un caro a control remoto. A este se le instalaran dos sensores ultrasonido HC Sr 04, en la parte posterior y anterior de este, con el fin de permitirle al robot movilizarse cuando alguien se le aproxima. La resonancia es aproximadamente de 60 cm para que el robot se movilice. 


El robot solo se movilizará si algo esta detrás de él Pero si hay dos objetos  entre este , generará un sonido insoportable para el oído humano. .Así el Robot tendrá la función{on de moverse en linea recta, de tal manera que cuando llegue al final de su camina, la función{on de movilidad se revierta y esta pueda regresar, y así sucesivamente. 
Posiblemente la coraza del robot tenga una forma especifica, me gustaría hacerlo en forma de animal, o sino con materiales reciclados. 



Este es el código que voy a utilizar: 

Adelantos proyecto final - Camilo Díez

El código que comparto aquí es basado en la librería Minim, en la que se basa el proyecto de Carolina Sierra, y en el código de Ben Farahmand. Modifiqué la estructura para poder adaptarla a los cambios en Processing 2xx. Este código les permitirá visualizar en un espacio de 3 dimensiones cualquier audio que pase por el input de audio (micrófono).

import ddf.minim.analysis.*;
import ddf.minim.*;
Minim minim;
AudioPlayer jingle;
FFT fft;
AudioInput in;
float[] angle;
float[] y, x;
 
void setup()
{
  size(600, 600, P3D);
  //  size(1280,768,P3D);
  minim = new Minim(this);
  //STERERO in
  //in = minim.getLineIn(Minim.STEREO, 2048, 192000.0);
  //MONO in
  in = minim.getLineIn(Minim.MONO, 2048);
  fft = new FFT(in.bufferSize(), in.sampleRate());
  y = new float[fft.specSize()];
  x = new float[fft.specSize()];
  angle = new float[fft.specSize()];
  frameRate(1000);
}
 
void draw()
{
  background(0);
  fft.forward(in.mix);
  doubleAtomicSprocket();
}
 
void doubleAtomicSprocket() {
  noStroke();
  pushMatrix();
  translate(width/2, height/2);
  for (int i = 0; i < fft.specSize() ; i++) {
    y[i] = y[i] + fft.getBand(i)/100;
    x[i] = x[i] + fft.getFreq(i)/100;
    angle[i] = angle[i] + fft.getFreq(i)/2000;
    rotateX(sin(angle[i]/2));
    rotateY(cos(angle[i]/2));
    //    stroke(fft.getFreq(i)*2,0,fft.getBand(i)*2);
    fill(fft.getFreq(i)*2, 0, fft.getBand(i)*2);
    pushMatrix();
    translate((x[i]+50)%width/3, (y[i]+50)%height/3);
    box(fft.getBand(i)/20+fft.getFreq(i)/15);
    popMatrix();
  }
  popMatrix();
  pushMatrix();
  translate(width/2, height/2, 0);
  for (int i = 0; i < fft.specSize() ; i++) {
    y[i] = y[i] + fft.getBand(i)/1000;
    x[i] = x[i] + fft.getFreq(i)/1000;
    angle[i] = angle[i] + fft.getFreq(i)/100000;
    rotateX(sin(angle[i]/2));
    rotateY(cos(angle[i]/2));
    //    stroke(fft.getFreq(i)*2,0,fft.getBand(i)*2);
    fill(0, 255-fft.getFreq(i)*2, 255-fft.getBand(i)*2);
    pushMatrix();
    translate((x[i]+250)%width, (y[i]+250)%height);
    box(fft.getBand(i)/20+fft.getFreq(i)/15);
    popMatrix();
  }
  popMatrix();
}
 
void stop()
{
  // always close Minim audio classes when you finish with them
  jingle.close();
  minim.stop();
 
  super.stop();
}

//Cortesía de Caro Sierra y Ben Farahmand

Un poco de inspiración para el proyecto

Mi proyecto se basa en estos dos paradigmas:
El primero propuesto por Zeron, en su conocido paradigma de Aquiles y la tortuga.

https://www.youtube.com/watch?v=skM37PcZmWE




El siguiente paradigma es ilustrado en la Mr Nobody(2009), con el Zugzwang en donde la única posibilidad que uno tiene es no moverse, puesto que todo esta perdido sin importar el movimiento realizado.

Espero crear un Robot que pueda mostrar estos paradigmas. mostrando una"adaptación a estos dos paradigmas, sonde el espectador es parte importante para la existencias de estos. 


Esteban Millán Pinzón

Wednesday, November 12, 2014

Re: Arduino-Esteban Millán Pinzon



El 5 de noviembre de 2014, 8:42, Esteban Millan Pinzon <estebanmillanpinzon@gmail.com> escribió:
En este ejercicio utilizamos los botones y foto celdas para prender un let. El ejercicio fue muy interesante, más cuando con la fotocelda se puede medir una cantidad de luz especifica, generando así una cantidad infinita de posibilidades. En cambio el boton al tener solo dos funciones es muy limitante.

Aunque mi proyecto se va más con la manipulación de los botones al no requerir distintas variaciones de una acción.









Experimentación Proyecto

Experimenté con la tinta conductiva, haciendo circuitos sencillos sobre la piel, buscando encender un led a partir de dos baterías doble AA.

La tinta no logró conducir la electricidad, incluso con varias capas, no llegaba a encender la luz. 

Sólo se puede encendiendo directamente el led con las baterías.​

Grua.

Sara Toro

Maquina de Burbujas

Sara Toro

RE: Códigos Arduino-Nicolas Niño, Felipe Martinez y Sara Toro



sensor luz:

int fotocelda=3;
int estado=0;

void setup(){
Serial.begin(9600);

}

void loop(){

estado=analogRead(fotocelda);
//Serial.println(estado);
//delay(100);

if(estado>0&&estado<50){
Serial.println("oscuro");
delay(100);
  
}


if(estado>51&&estado<100){
Serial.println("medio oscuro");
delay(100);
  
}
if(estado>101&&estado<150){
Serial.println("medio claro");
delay(100);
  
}
if(estado>151&&estado<200){
Serial.println("claro");
delay(100);
  
}//else{Serial.println("mucha luz");
if(estado>200){
Serial.println("claro");
delay(100);
 
}
}

Boton:

int boton=9;
int estado=0;


void setup (){
pinMode(boton,INPUT);
Serial.begin(9600);
}
void loop (){
  estado=digitalRead(boton);
  if(estado==1){
    Serial.print(" :");
      delay(100);
  
  }else{
    Serial.print(") ");
  
  //Serial.println(estado);
  delay(100);

}
}

Códigos Arduino

sensor luz:

int fotocelda=3;
int estado=0;

void setup(){
Serial.begin(9600);

}

void loop(){

estado=analogRead(fotocelda);
//Serial.println(estado);
//delay(100);

if(estado>0&&estado<50){
Serial.println("oscuro");
delay(100);
  
}


if(estado>51&&estado<100){
Serial.println("medio oscuro");
delay(100);
  
}
if(estado>101&&estado<150){
Serial.println("medio claro");
delay(100);
  
}
if(estado>151&&estado<200){
Serial.println("claro");
delay(100);
  
}//else{Serial.println("mucha luz");
if(estado>200){
Serial.println("claro");
delay(100);
 
}
}

Boton:

int boton=9;
int estado=0;


void setup (){
pinMode(boton,INPUT);
Serial.begin(9600);
}
void loop (){
  estado=digitalRead(boton);
  if(estado==1){
    Serial.print(" :");
      delay(100);
  
  }else{
    Serial.print(") ");
  
  //Serial.println(estado);
  delay(100);

}
}