magdalenagpaz - Tumblr blog

magdalenagpaz · 5 years

Text

Obligatorio

Consigna elegida: ¿Como podemos integrar un producto interactivo para hacer la difusión de un cortometraje o película?

El proyecto que vamos a realizar se trata de un póster interactivo, el cual tendría sonido y se va armando la imagen con el sonido de la canción principal de la película.

En cuanto a la accesibilidad las personas sin visión quedarían por fuera de la interacción visual, aunque lo pueden escuchar a través de una audiodescripción del afiche. Las personas sordas pueden ver la interacción visual, aunque no puedan escuchar la música, pero a través de las vibraciones del parlante pueden sentir los beats. Por lo tanto, va dirigido a todas las personas.

La finalidad del proyecto es lograr es que al usuario le llame la atención para que vea la película/corto, que le genere intriga. Esta instalación estaría en los pasillos de un shopping o cerca de algún lugar donde haya un cine.

Lo que usaríamos para realizarlo es Processing3, una pantalla, un micrófono y parlantes con buen buffer.

Para que la persona entienda cómo funciona y que la misma le llame la atención, queremos colocar un sensor de movimiento (ultrasónico) para que cuando la persona pase por delante le “diga” algo (es decir, que en los parlantes al pasar una persona se escuche a alguien hablando, tratando de llamar su atencion diciendole algo como: “Ey! vos que acabas de pasar, acércate a ver!) y así llamar la atención de la misma. Esto lo realizaríamos conectando Arduino con Processing3.

Lo primero que hicimos al juntarnos fue definir la idea que teníamos en mente, para ello, elegimos la película que usaríamos como ejemplo y la canción que la musicalizaría. La película elegida fue la película uruguaya “Los Tiburones” de Lucía Garibaldi y la canción fue “Arenas Negras” de Mux que es la canción principal de la película. Luego, buscando ejemplos en internet, empezamos a escribir el código para lograr que la imagen fuera apareciendo con pinceladas a medida que avanzaba la canción. Lo que estuvimos intentando fue que a partir de los cambios musicales cambiara la velocidad y el grosor de las pinceladas, que el beat de la canción el que marcara el ritmo de la pincelada, pero no pudimos. Lo que sí pudimos, fue lograr que con la amplitud de la canción las pinceladas cambiaran y fueran cada vez más pequeñas para poder ver los detalles del poster.

El siguiente jueves, en clase, nos juntamos para poder seguir agregándole ideas al proyecto. Para asegurarnos que la persona se diera cuenta que la interacción era con ella, pensamos en utilizar arduino para que, con un sensor en la pantalla se detecte el movimiento de las personas que pasan por delante y prenda luces y a su vez comience la interacción.

(conectamos el sensor ultrasónico con el arduino)

Además se nos ocurrió conectar un micrófono para que la persona pudiera interactuar con el mismo, ya que al generar más sonido, se acelerarían las pinceladas.

Luego de volvernos a juntar, para conectar una tira de leds al arduino y lograr que, colocando algo a cierta distancia del sensor, la tira de leds prendiera. Esto lo vamos a usar para que alrededor de la pantalla esté pegada la tira y se prenda a partir de la distancia de la persona, llamando la atención de quien pasa por ahí y le llame la atencion el póster.

Primero, conectamos la tira al arduino sin el sensor y logramos prender una sola luz. Luego pudimos hacer que prendiera todos los leds.

Y finalmente, logramos que a cierta distancia del sensor, prendiera 60 leds de color verde.

Por último, nos juntamos para conectar el arduino con Processing y que lo que detectara Arduino con el sensor se viera en la consola de Processing, pero no pudimos hacer que la distancia que registra el sensor fuera determinante para el inicio de la interacción en Processing.

En la última instancia, logramos que Arduino le mande los datos de distancia a Processing, pero al ser una string, Processing no podía procesarlo, entonces lo que hicimos fue convertirlo en un entero. A su vez colocamos un Try and Catch en el código ya que al iniciar el programa, a veces el sensor fallaba y daba números negativos los cuales “rompían” el programa; esto lo hicimos para capturar el error.

Tiempo estimado de trabajo para el proyecto: 6 horas semanales x 4 semanas = 24 horas en total aproximadamente.

Finalmente así fue como quedó el proyecto:

Código Arduino:

#include <FastLED.h> //incluir libreria fastLED

const int Trigger = 2; //Pin digital 2 para el Trigger del sensor

const int Echo = 3; //Pin digital 3 para el Echo del sensor

#define NUM_LEDS 60

// For led chips like Neopixels, which have a data line, ground, and power, you just

// need to define DATA_PIN. For led chipsets that are SPI based (four wires - data, clock,

// ground, and power), like the LPD8806 define both DATA_PIN and CLOCK_PIN

#define DATA_PIN 6

#define CLOCK_PIN 13

// define arreglo de leds

CRGB leds[NUM_LEDS];

void setup() {

Serial.begin(9600);//inicializamos la comunicación

pinMode(Trigger, OUTPUT); //pin como salida

pinMode(Echo, INPUT); //pin como entrada

digitalWrite(Trigger, LOW);//Inicializamos el pin con 0

FastLED.addLeds<WS2812B, DATA_PIN, RGB>(leds, NUM_LEDS);

}

void loop()

{

long t; //tiempo que demora en llegar el eco

long d; //distancia en centímetros

digitalWrite(Trigger, HIGH);

delayMicroseconds(10); //Enviamos un pulso de 10us

digitalWrite(Trigger, LOW);

t = pulseIn(Echo, HIGH); //obtenemos el ancho del pulso

d = t / 59; //escalamos el tiempo a una distancia en cm

// Serial.print("Distancia: ");

Serial.println(d); //Enviamos serialmente el valor de la distancia

//Serial.print("cm");

//Serial.println();

delay(100); //Hacemos una pausa de 100ms

if (d < 40) {

for (int i = 0; i <= 60; i++) {

leds[i] = CRGB::Red

FastLED.show();;

}

else {

for (int i = 0; i <= 60; i++) {

leds[i] = CRGB::Black;

FastLED.show();;

}

Código Processing:

//Se importa libreria

import ddf.minim.*;

//Se definen variables de audio

AudioInput in;

Minim minim;

AudioInput input;

AudioPlayer player;

String[] imgNames = {"portrait1.jpg"};

PImage img;

int imgIndex = 0;

String play = "60";

// Cosas de arduino

//Se importa serial para el adruino

import processing.serial.*;

// boolean que habilita el programa

Boolean distancia = false ;

// d comienza en 1 por si las moscas, sera donde se guarde la string del port

String d = "1";

// dist sera la distancia ya convertida a entero

int dist = 0;

//Se define la variable de puerto

Serial myPort;

String data="" ;

//Variable qe registra el frame en el que comienza el juego

int frameCountC = 0;

void nextImage() {

background(255);

loop();

frameCount = 0;

//carga imagenes y los pixeles de cada imagen para luego tomar el color y formar la imagen con los trazps

img = loadImage(imgNames[imgIndex]);

img.loadPixels();

imgIndex += 1;

if (imgIndex >= imgNames.length) {

imgIndex = 0;

}

//trazos

void paintStroke(float strokeLength, color strokeColor, int strokeThickness) {

float stepLength = strokeLength/4.0;

// curva del trazo, linea recta seria 0

float tangent1 = 0;

float tangent2 = 0;

float odds = random(1.0);

if (odds < 0.7) {

tangent1 = random(-strokeLength, strokeLength);

tangent2 = random(-strokeLength, strokeLength);

}

// dibuja un trazo grande

noFill();

stroke(strokeColor);

strokeWeight(strokeThickness);

curve(tangent1, -stepLength*2, 0, -stepLength, 0, stepLength, tangent2, stepLength*2);

int z = 1;

// Dibuja trazos chicos

for (int num = strokeThickness; num > 0; num --) {

float offset = random(-50, 25);

color newColor = color(red(strokeColor)+offset, green(strokeColor)+offset, blue(strokeColor)+offset, random(100, 255));

stroke(newColor);

strokeWeight((int)random(0, 3));

curve(tangent1, -stepLength*2, z-strokeThickness/2, -stepLength*random(0.9, 1.1), z-strokeThickness/2, stepLength*random(0.9, 1.1), tangent2, stepLength*2);

z += 1;

}

void setup() {

//Se define El tamano de la pantalla

size(437, 650);

minim = new Minim(this);

nextImage();

//Se carga la cancion en player

player = minim.loadFile("ArenasNegras.mp3");

//Se carga el mircofono

in = minim.getLineIn(Minim.STEREO, 512);

//Se setean los datos del Arduino

myPort = new Serial(this, "COM4", 9600);

myPort.bufferUntil('\n');

}

void serialEvent(Serial myPort)

{

// Se verifica que el puerto este disponible para que no haya errores

if (myPort.available() > 0) {

d=myPort.readStringUntil('\n');

//Se verifica que la distancia no llegue null o vacia para que no genere errores

if ( d != null && d.equals("") == false ) {

// Se coloca dentro de try and catch porque al iniciar da un error el sessor ultra sonico, pasando todo los controles atenriores.

// Da un error al convertir la string en entero , dejando de funcionar el programa.

// Lo que se hizo fue capturar ese error y asumir que no hay nadie a dicha distancia dada

try {

// Se convierte de string a entero

// trim elimina especios blancos tanto al comienzo como al final

dist = Integer.parseInt( d.trim());

}

catch (NumberFormatException e) {

dist = 100000;

}

// Control de distancia

// println(dist + "Distancia Convertida");

}

// Simpre y cuando la distancia sea mayor a 0(Que es cuando da errores), que sea menor a 50 (Que esta cerca) y que la distancia sea false ya que al ponerla true

// Arranca el programa

if (0< dist && dist <=50 && distancia == false) {

// Ya que los frame corren desde el principio debemos registrar el frame cuando comienza el programa , para restarle a los frame que vayan corriendo.

// Y asi obtener los frame que va corriendo el programa en si

frameCountC = frameCount;

//Se pasa a true la variable que permite el comienzo del juego

distancia = true;

}

void draw() {

// se llama a la funcion serial event y se le pasa el port para que se fije la distancia y habilite que comience el programa en si

serialEvent(myPort);

// Como el voy draw se repite todo el tiempo, controlamos que la distancia sea la correcta para comenzar el programa.

if (distancia == true) {

//la cancion empieza a sonar cuando el programa empieza (es decir cuando la persona se acerca)

player.play();

float amplitud = 0;

for (int i = 0; i < player.bufferSize (); i++) {

//amplitud de la cancion

amplitud += abs(player.left.get(i));

}

amplitud /= player.bufferSize();

// ACA ESTA amplitud microfono EL MICROFONO

float amplitudeLeft = 0;

for (int i = 0; i < in.bufferSize(); i++)

{

amplitudeLeft += abs(in.left.get(i));

}

amplitudeLeft /= in.bufferSize();

if (amplitud < amplitudeLeft) {

amplitud = amplitudeLeft;

amplitud += 0.3;

}

//println (amplitudeLeft, "--->", amplitud);

translate(width/2, height/2);

int index = 1;

for (int y = 0; y < img.height; y+=1) {

for (int x = 0; x < img.width; x+=1) {

int odds = (int)random(20000);

if (odds < 1) {

color pixelColor = img.pixels[index];

pixelColor = color(red(pixelColor), green(pixelColor), blue(pixelColor), 100);

//usamos push y pop ya que si actualizabamos el fondo (background) los trazos ya dibujados desparecian, lo cual nunca lograba a formar ninguna imagen

pushMatrix();

translate(x-img.width/2, y-img.height/2);

rotate(radians(random(-90, 90)));

println((frameCount-frameCountC));

// empiza a dibujar cada vez siento un trazo mas fino hasta llegar a puntos

if (amplitud < 0.2 && (frameCount-frameCountC) < 200) {

//Trazos grandes

paintStroke(random(150, 200), pixelColor, (int)random(20, 40));

} else if (amplitud< 0.22 && (frameCount-frameCountC) < 240) {

// trazos medianos

paintStroke(random(75, 100), pixelColor, (int)random(8, 12));

} else if (amplitud < 0.27 && (frameCount-frameCountC) <280) {

// trazos medianos

paintStroke(random(50, 75), pixelColor, (int)random(8, 12));

} else if (amplitud < 0.3 && (frameCount-frameCountC) <320) {

// trazos chicos

paintStroke(random(30, 50), pixelColor, (int)random(1, 15));

} else if (amplitud < 0.32 && (frameCount-frameCountC) < 360) {

// puntos grandes

paintStroke(random(5, 10), pixelColor, (int)random(1, 8));

} else if (amplitud < 0.35 && (frameCount-frameCountC) < 400) {

// dibuja punots

paintStroke(random(1, 7), pixelColor, (int)random(1, 8));

} else if (amplitud < 0.37) {

// punots

paintStroke(random(1, 5), pixelColor, (int)random(1, 7));

} else if (amplitud < 0.4) {

// punots

paintStroke(random(1, 2), pixelColor, (int)random(1, 7));

} else if (amplitud < 0.41) {

// dibuja punots

paintStroke(random(0.7, 0.7), pixelColor, (int)random(1, 5));

} else if (amplitud < 0.42) {

// dibujos puntos

paintStroke(random(0.1, 0.1), pixelColor, (int)random(1, 5));

}

popMatrix();

}

index += 1;

}

0 notes

magdalenagpaz · 5 years

Text

About Face

Voy a resumir y comentar el capítulo 1 de About Face: “Goal-Directed Design“, la primera sección titulada “Digital Products Need Better Design Methods”.

La premisa con la que empieza el capítulo indica que si diseñamos y construímos un producto de forma tal que quienes lo usan se sienten satisfechos, felices y creen que el producto es efectivo, éstas personas pagarán por él y se lo recomendarán a otras para que hagan lo mismo. Si logramos que ésto se pueda realizar de manera económica, se traduce en un negocio exitoso.

Pero entonces, ¿por qué hay tantos productos digitales que son difíciles o desagradables de usar? Ésto se debe a que los desarrolladores en vez de planear y ejecutar pensando en satisfacer las necesidades de los usuarios que compran y usan sus productos, están creando soluciones enfocadas meramente en la tecnología, que resulta en productos difíciles de usar y controlar. Éstos desarrolladores no están creando productos pensando de manera “humana”.

El diseño es el esfuerzo consciente e intuitivo de imponer un orden que tiene un significado. El diseño de productos digitales para personas tiene 4 premisas fundamentales:

El entendimiento de los deseos, necesidades, motivaciones y contextos de los usuarios.

El entendimiento de los negocios, técnicas, requisitos y el dominio de oportunidades de los mismos.

Usar el conocimiento como base para crear productos cuya forma, contenido y comportamiento es útil, usable y deseable para los usuarios, además de ser económicamente viable.

Hoy en día, la creación de productos digitales tiene dos aristas, que comúnmente son opuestas: los vendedores y los desarrolladores.

Los vendedores se dedican a entender y cuantificar una oportunidad de mercado y a introducir en ése mercado al producto. Su rol en el diseño de producto es prácticamente nulo, ya que no deberían tener voz y voto a la hora de diseñar un producto, dado que no es su área de conocimiento. Un ejemplo de ésto es que en lo que los vendedores están pensando no es en las necesidades reales del usuario ni lo que éstos desean de un producto, si no que lo que buscan es una oportunidad de mercado, tener menos competencia y manejar bien los recursos tecnológicos que poseen.

Por otro lado, están los desarrolladores. Al ser quienes están a cargo de la construcción del producto, son quienes deciden exactamente qué es lo que se va a construir o desarrollar. Los buenos desarrolladores están enfocados en resolver problemas técnicos y normalmente están a cargo de tomar importantes decisiones acerca de la experiencia de usuario sin saber a fondo de qué se trata ésta, ya que no es su área de estudio. En mi opinión, es un poco contradictorio que los desarrolladores, que no tienen en cuenta las necesidades, metas, motivaciones del usuario a la hora de desarrollar, sean quienes, a veces, toman las responsabilidades más importantes a la hora de crear un producto digital.

Esto resulta en productos que carecen de una experiencia de usuario coherente y amigable. Los productos que se crean de esta forma resultan ser irritantes para el usuario, no mejoran la productividad y tampoco alcanzan a resolver las necesidades del mismo.

Esta es una imagen muy interesante que se muestra en el capítulo:

Habla sobre la evolución del proceso de desarrollo de un producto a lo largo de la historia y el rol del diseño en este proceso.

Como se ve, en los últimos tiempos muchas compañías comenzaron a enfocarse en las necesidades reales del usuario, y empezaron a gastar tiempo y dinero en el diseño de producto.

Sin embargo, son más las compañías que no tienen en cuenta el diseño y desarrollan productos que, como usuarios, despreciamos. Algunas de las características que se mencionan acerca de estos productos son:

Los productos digitales son groseros con el usuario, “culpandolo” de errores que no son propios del usuario sino del producto. Éstos productos y softwares frecuentemente interrogan al usuario con preguntas que éste no sabe o no está preparado para responder, entre ellas la pregunta “Dónde guardo usted este archivo?”. Además, muchas veces olvidan información que le brindamos y no anticipan correctamente nuestras necesidades.

Otro error de estos productos es que esperan que el usuario piense como una computadora, por ejemplo en Microsoft Word, si el usuario quiere renombrar un documento que está editando debe saber que tiene que o cerrar ese documento o utilizar la opción “Guardar como”. Ésta manera de actuar es propia de una computadora y no se corresponde con el pensamiento humano.

Para finalizar, las razones por las cuales éstos productos son malos y no cumplen su función de “ayudar” al usuario son:

Se ignora al usuario y sus necesidades, no se trata de comprenderlo y así poder desarrollar productos atractivos para éste.

Las personas encargadas de diseñar el producto no deben ser las mismas que lo desarrollan, es imposible que un programador pueda completar todas las tareas y desarrollar un producto amigable y útil.

Falta un proceso sólido. Casi siempre, a la hora de crear un producto digital, falta un proceso analítico para transformar el entendimiento que se posee de los usuarios en productos que cumplan con esas metas y necesidades de los mismos.

A modo de conclusión, me pareció muy interesante el capítulo. Me parece que el proceso de diseñar un producto está cambiando y para los usuarios es un cambio muy importante. Si bien me he enfrentado a estos errores en los productos, nunca me había puesto a pensar en cuáles son las causas de estos “errores” o estas molestias a la hora de utilizar un producto digital. Fue muy interesante y me obligó a seguir investigando y leyendo el resto del libro “About Face”.

0 notes

magdalenagpaz · 5 years

Text

Accesibilidad

El jueves 26 de septiembre tuvimos la visita de Florencia Fascioli en la clase. Florencia es profesora y responsable del Programa de Accesibilidad Audiovisual del Departamento de Comunicación en la Universidad Católica.

Tuvimos una charla muy interesante que comenzó con una breve presentación sobre la discapacidad.

La discapacidad se puede entender utilizando la siguiente fórmula:

discapacidad = limitación funcional x el ambiente.

Antes, existía el paradigma médico que estaba basado en la idea de la institucionalidad, la idea de que hay que parecerse “al resto de la población normal”.

Luego, en el transcurso de la Historia, surgió el paradigma social, que defendía que las causas de la discapacidad están en el entorno. Es el modelo actual en el que se estudia la discapacidad y supone ser un modelo de inclusión.

Luego, continuamos hablando sobre la accesibilidad. El primer punto a tener en cuenta es que desde el momento en que creamos un producto se debe pensar que todos y todas puedan usarlo a pesar de su discapacidad, supone un diseño para todas las personas.

Hay 7 principios básicos del diseño para tod@s:

Igualdad de uso

Flexibilidad de uso

Simple e intuitivo

Información fácil de percibir

Tolerante a errores humanos

Que requiera escaso esfuerzo

Dimensiones apropiadas

Luego de hablar sobre ésto, hicimos un pequeño ejercicio. Nos sentamos de a dos para mirar un video, una de las dos se colocó una venda en los ojos mientras la otra (yo) le hacía una audio descripción del video.

La audio-descripción de un video tiene que ir en momentos en que no haya diálogo, y eso es lo que más me complicó a la hora de describir, ya que no encontraba el momento de hacerlo sin que mi compañera se perdiera del diálogo o sonidos que fueran importantes para comprender.

Luego del ejercicio, hablamos un poco acerca de las etapas de la audio-descripción y sus características.

Primero debe haber un análisis previo de la obra, tiene que estar guionado y debe constar de una revisión y corrección. Una vez realizado ésto se hace la locución y finalmente se hace el montaje con la banda sonora.

Las características son:

Debe ser una voz neutra, no se deben dar puntos de vista subjetivos.

Lo principal es la trama, luego datos plásticos y estéticos.

Información adecuada al tipo de obra y público.

Estilo de escritura sencillo.

Evitar cansancio o ansiedad.

No adelantar sucesos, tiene que acompañar la narrativa.

No interpretar ni explica más de lo que se ve en pantalla.

No ser demasiado literario ni didáctico.

Identificar bien a los personajes.

Evitar redundancia, respetar silencios y describir de lo general a lo particular.

Luego, en la segunda hora de clase tuvimos la visita de Alejandro. Alejandro es compañero de trabajo de Florencia, trabaja en Accesibilidad audiovisual, es psicólogo y además, es ciego. El propósito de su visita era que nos contará acerca de los problemas diarios que enfrenta por su discapacidad y buscar, en equipos, soluciones para dichos problemas.

Alejandro comenzó a contarnos de su día a día. Algunas de las cosas que nos contó fueron:

Utiliza un bastón blanco para andar por la calle y se toma el ómnibus diariamente para ir a trabajar en 18 de julio entre Yaguarón y Yí. El recorrido de su casa al ómnibus lo recuerda y es autónomo en ese tramo, pero cuando llega a la parada pierde esa autonomía y debe pedir ayuda a la gente que está ahí. Luego, al subirse al ómnibus empieza a contar las paradas o la cantidad de segundos/minutos que faltan para llegar a su destino. Aclara que preferiría más autonomía dentro del ómnibus, ya que nunca puede descansar o pensar en otra cosa más que estar atento a no pasarse de parada o bajarse antes.

Uno de los obstáculos que menciona es el estado de las veredas en la ciudad y el poco reconocimiento que tiene de la luz que indica el semáforo, que lo complica diariamente.

Trabaja en Rivera y Pablo di Maria, cuando se baja allí para hallar la puerta de su trabajo desarrolló su propia referencia que hace que todos los días la encuentre.

También, reconoce que obtuvo un gran desarrollo auditivo cuando perdió la vista.

Luego de charlar con él, empezamos a desarrollar nuestra solución. En mi equipo, tuvimos varias ideas entre las cuales elegir:

Parada interactiva.

Dentro de los ómnibus, que cada asiento cuente con un parlante que indique el nombre de la calle y parada en la que se encuentra el ómnibus.

Parlantes en las paradas que indiquen qué ómnibus está en camino.

Parlantes dentro del ómnibus que vaya indicando las paradas próximas y pantallas para visualizarlas también.

Bastón inteligente.

Finalmente, decidimos desarrollar la idea de la parada interactiva. Básicamente, la parada de ómnibus constaría de una pantalla que indique qué ómnibus están por llegar y que el usuario pueda seleccionar cual es el que quiere tomarse, para que el ómnibus sea notificado y pare en esa parada. La lista de ómnibus que están llegando constaría de un sistema de lectura braille.

Deberá pasar por el lector la tarjeta STM y así el ómnibus será notificado. Al subirse, vuelve a pasar la tarjeta por el lector, para que así, si selecciono varios ómnibus para tomarse, los demás sean notificados con que no deben parar en esa parada y para que se cobre el boleto.

También, pensamos en modelos nuevos de ómnibus. Que éstos tengan parlantes que indiquen el recorrido y mapas para visualizar el mismo. Ésto ayudaría a personas ciegas y sordas a orientarse en el transporte público y al resto de la población también.

Éste es el prototipo que hicimos en clase:

A modo de conclusión, la actividad me gustó mucho porque éste tipo de visitas me parecen muy enriquecedoras ya que enfrentarnos en primera persona con alguien con una discapacidad nos hace pensar en ésta problemática de otra manera. Además, buscar soluciones y empezar a prototipar las mismas habiendo tenido la charla sobre diseño para tod@s, hace que las soluciones sean más innovadoras y busquen realmente ayudar a quienes tienen estos problemas.

0 notes

magdalenagpaz · 5 years

Text

Proyecto ElectrizApp

El jueves 12 de septiembre, nos juntamos en grupos para empezar a desarrollar un proyecto. Mi grupo lo formaron Rodrigo Llofriu, Martín Méndez, Federico Machado y Franco Brignoli.

Comenzamos pensando en problemas reales que teníamos nosotros o que veíamos que tenía la población en general.

Después de estar unos minutos desarrollando una lluvia de ideas, el problema que encontramos más importante fue el gasto de energía eléctrica que existe en nuestros hogares.

Luego, comenzamos a pensar en una solución para este problema. El problema que se nos ocurrió fue conectar sensores a los dispositivos eléctricos y mediante una app, enlazar los sensores y poder mostrar la información correspondiente al gasto de cada dispositivo y lograr controlarlos desde el celular.

Para eso, utilizamos Arduino y sensores de campo magnético. Teníamos dos tipos de sensores, uno lineal y uno analógico. A partir de esto, comenzamos a prototipar y a probar el código hasta lograr que funcione.

La idea que teníamos era lograr que a partir de la detección de un sensor, se prendiera una luz led que detecta la presencia de este campo.

Probamos varias veces hacer funcionara el sensor analógico, pero no logramos que este funcione cuando le acercábamos un imán al sensor. Por eso, utilizamos el sensor lineal.

El código final de arduino que hicimos fue:

int ledRojo = 13 ; // LED on arduino int ledVerde = 12; int digitalPin = 3; // linear Hall magnetic sensor digital interface int analogPin = A0; // linear Hall magnetic sensor analog interface int digitalVal ; // digital readings int analogVal; // analog readings

void setup () { pinMode (ledRojo, OUTPUT); pinMode (ledVerde, OUTPUT); pinMode (digitalPin, INPUT); //pinMode(analogPin, INPUT); Serial.begin(9600); }

void loop () { // Read the digital interface analogVal = analogRead(analogPin) ; digitalVal = digitalRead(digitalPin) ; //Serial.println(digitalVal); if (analogVal < 510 and analogVal > 460) // When magnetic field is present, Arduino LED is on { digitalWrite (ledVerde, HIGH);

} else if (analogVal<490 and analogVal > 400) { digitalWrite (ledRojo, HIGH); digitalWrite(ledVerde,LOW); } else { digitalWrite (ledRojo, LOW); digitalWrite (ledVerde, LOW); } // Read the analog interface

Serial.println(analogVal); // print analog value

delay(300); }

Logramos que mediante la cercanía de un imán al sensor, se prendiera una luz led.

Luego, para mejorar el proyecto, colocamos dos luces led, una roja y una verde.

Cuando el iman estaba muy próximo al iman, prendía la luz roja, cuando estaba a una distancia media prendía la luz roja y la luz verde, y cuando estaba a una distancia superior prendía la luz verde únicamente.

Luego, desarrollamos un diseño para la aplicación:

Y así, concluímos nuestro proyecto.

0 notes