Physical Computing - DDIT

Se trata de un trabajo grupal, a partir de una problemática definida por el propio grupo de trabajo, y para la cual se se requiere proponer una solución que integre el uso de la placa Arduino UNO, debidamente programada, en un dispositivo, artefacto u objeto de diseño, también propuesto y desarrollado por el mismo grupo de trabajo.

El grupo 6

El grupo de trabajo estuvo constituido por las siguientes personas:

Fernanda Bisbal

Carolina D’Agostino

Sergio Hernández

Michel Jure

El problema propuesto

El problema se trata de proveer a un terapeuta de Biomagnetismo de un dispositivo que permita medir, en forma automatizada, las diferencias transitorias de longitud entre las piernas del paciente, quien se encuentra tendido en una camilla, pues esta medición, recurrente durante la sesión terapéutica, constituye el indicador fundamental para la detección de desequilibrios fisiológicos en 300 puntos claves del cuerpo, y que determinan la aplicación de imanes de diferentes polaridades y potencias en los puntos detectados como críticos, para restablecer su equilibrio, el cual se verá reflejado en el emparejamiento de la longitud de las piernas.

La solución propuesta 

La solución se basa en una plataforma vertical, dispuesta a los pies de la camilla en la que se encuentra el paciente, y en la que se soportan dos sensores de distancia ultrasónicos, uno para cada pie, ajustables en su posición, de acuerdo a las medidas corporales del paciente, y que, mediante un código de lectura escrito para Arduino, detectan la diferencia de medida de longitud entre ambas piernas, entregando una salida por display de dichas diferencias, y encendiendo un LED rojo cuando esta supera el máximo admisible de 2cm, y un LED verde cuando se alcanza la condición de emparejamiento.

El código

El código se diseñó, y testeó en una simulación en Tinkercad, realizando varias iteraciones, antes de pasar a la fabricación del circuito.

La versión definitiva se encuentra completamente documentada en español, y se transcribe a continuación, como es habitual en este blog, con las líneas activas en negrita, y los comentarios en cursiva:

/*  Sensores_biomagnetismo

 Este código ha sido desarrollado para el módulo Physical Computing del Diplomado en Diseño, Innovación y Tecnología  de la Universidad Adolfo Ibáñez, bajo la guía de la profesora Carolina Pino.  El desarrollo del código ha estado a cargo del grupo de trabajo formado por:

 Fernanda Bisbal  Carolina D'Agostino  Sergio Hernández  Michel Jure

 El objetivo del código es utilizar dos sensores ultrasónicos, para determinar la diferencia de distancia entre dos superficies paralelas,  y encender un indicador LED rojo cuando esta diferencia supera un mínimo admisible de 2cm., y uno verde cuando esta diferencia es igual a cero.  Tanto las distancias como las diferencias de distancia se imprimen en un display de visualización.

 Para su implementación se requiere de:  Una placa Arduino UNO  Dos sensores de distancia ultrasónicos HC-SR04  Un pulsador de encendido para ejecutar la medición  Un LED rojo  Un LED verde  Una resistencia de 10 Kohmios  Una resistencia de 220 ohmios

 La aplicación de este código y este circuito, está pensado en las terapias de biomagnetismo, en las que el terapeuta detecta desequilibrios  fisiológicos mediante diferencias transitorias de longitud entre las dos piernas del paciente, quien se encuentra tendido en una camilla  con los pies enfrentados a los sensores ultrasónicos.

 Las conexiones de los dispositivos a la placa Arduino UNO son las siguientes:  Las entradas VCC de los sensores ultrasónicos van conectados al pin de 5v de la placa  Las entradas GND de los sensores ultrasónicos van conectados al pin de GND de la placa  El Trigger del sensor izquierdo va conectado a la salida digital 2 de la placa  La entrada Echo del sensor izquierdo, va conectado a la salida digital 3 de la placa  El Trigger del sensor derecho va conectado a la salida digital 4 de la placa  La entrada Echo del sensor derecho, va conectado a la salida digital 5 de la placa  El ánodo del LED rojo, va conectado a la salida digital 6 de la placa  El ánodo del LED verde, va conectado a la salida digital 7 de la placa  Los cátodos de ambos LEDs van conectados a la salida GND de la placa, pasando por una resistencia de 220 ohmios  Uno de los polos del pulsador va conectado a la salida 5v de la placa  El otro polo del pulsador va conectado a la salida GND de la placa, a través de una resistencia de 10 Kohmios, y conecta en el lado opuesto a la salida digital 8 de la placa

 V01 15-10-2020  */

// Constantes que no deben cambiarse. Usadas para definir las variables y los respectvos pines a utilizar: const int Trigger1 = 2;   //Pin digital 2 para el Trigger del sensor 1 const int Echo1 = 3;     //Pin digital 3 para el Echo del sensor 1

const int Trigger2 = 4;   //Pin digital 4 para el Trigger del sensor 2 const int Echo2 = 5;     //Pin digital 5 para el Echo del sensor 2

const int buttonPin = 8;     //Pin digital 8 para iniciar el proceso de medida de los detectores const int ledPin = 13;      //Sólo informativo en este caso para chequear el boton

const int LedRojo = 6;       //Pin digital 6 para el encendido del LED rojo const int LedVerde = 7;     //Pin digital 7 para el encendido del LED verde

// Variables que se modificarán: int buttonState =0;        //Variable para la lectura del estado del pulsador

void setup() {  Serial.begin(9600);                //Inicializamos la comunicación

 pinMode(Trigger1, OUTPUT);        //Definimos el pin del Trigger1 como salida del sensor 1  pinMode(Echo1, INPUT);           //Definimos el pin Echo1 como entrada del sensor 1  digitalWrite(Trigger1, LOW);    //Inicializamos el pin Trigger1 con 0 (apagado)

 pinMode(Trigger2, OUTPUT);        //Definimos el pin del Trigger2 como salida del sensor 2  pinMode(Echo2, INPUT);           //Definimos el pin Echo2 como entrada del sensor 2  digitalWrite(Trigger2, LOW);    //Inicializamos el pin Trigger2 con 0 (apagado)

 // Inicializamos el LED pin como salida:  pinMode(ledPin, OUTPUT);  // Inicializamos el pin del pulsador como entrada:  pinMode(buttonPin, INPUT);

 // Inicializamos los LED Verde y Rojo como salida:  pinMode(LedVerde,OUTPUT);  pinMode(LedRojo,OUTPUT);

} void loop() {

 // Definimos variables para el loop  long t1;                    //Tiempo que demora en llegar el eco al sensor 1  long d1;                   //Distancia en centimetros desde el pié hasta el sensor 1

 long t2;                    //Tiempo que demora en llegar el eco al sensor 2  long d2;                   //Distancia en centimetros desde el pié hasta el sensor 2

 long diferencia;          //Diferencia entre las dos medidas

 // El loop es el siguiente:  // Lee el valor del Pin8 del pulsador, si el valor es HIGH (encendido), pasa a la subrutina de medición, si el valor es LOW (apagado),  // espere1 segundo y siga leyendo, hasta que el terapeuta aprete el botón pulsador

 // Lee el estado del botón pulsador:  buttonState = digitalRead(buttonPin);  // Seteamos la diferencia de medida entre los sensores en 0 para inicializar  diferencia = 0;  // Seteamos los dos LEDs en estado apagado para inicializar  digitalWrite(LedRojo,LOW);  digitalWrite(LedVerde,LOW);

 // Iniciamos el loop de medición: if (buttonState == HIGH) {   digitalWrite(ledPin, HIGH);      //Si el botón pulsador ha sido activado por el terapeuta, se enciende el LED incorporado en la placa

  digitalWrite(Trigger1, HIGH);   delayMicroseconds(10);          //Enviamos un pulso de 10 milisegundos desde el sensor 1   digitalWrite(Trigger1, LOW);

  t1 = pulseIn(Echo1, HIGH);      //Obtenemos el ancho del pulso en el sensor 1   d1 = t1/59;                     //Escalamos el tiempo del pulso del sensor 1 a una distancia en cm

 digitalWrite(Trigger2, HIGH);  delayMicroseconds(10);          //Enviamos un pulso de 10 milisegundos desde el sensor 2  digitalWrite(Trigger2, LOW);

 t2 = pulseIn(Echo2, HIGH);      //Obtenemos el ancho del pulso en el sensor 2  d2 = t2/59;                    //Escalamos el tiempo del pulso del sensor 2 a una distancia en cm

  diferencia = d2-d1;            //Obtenemos la diferencia en centímetros entre la distancia del pié 1 al sensor 1 y la distancia del pié 2 al sensor 2   abs(diferencia); if (abs(diferencia) > 2) digitalWrite(LedRojo,HIGH);     //Si la diferencia en centímetros es > 2 enciende el LED Rojo if (abs(diferencia) == 0) digitalWrite(LedVerde,HIGH);  //Si la diferencia es cero se enciende el led Verde, está alineado

 // Inicializamos la salida de los datos de distancias y diferencias a un display  Serial.print("Distancia Uno: ");  Serial.print(d1);                //Enviamos serialmente el valor de la distancia en cm del sensor 1  Serial.print("cm");  Serial.println();

 Serial.print("Distancia Dos: ");  Serial.print(d2);               //Enviamos serialmente el valor de la distancia en cm del sensor 2  Serial.print("cm");  Serial.println();

 Serial.print("Diferencia: ");  Serial.print(abs(diferencia));  //Enviamos serialmente el valor en cm de la diferencia entre las distancias de los sensores 1 y 2  Serial.print("cm");  Serial.println();

 delay(5000);                   //Hacemos una pausa de 5 Segundos } else { delay (1000);            //Si no hay lectura, hacemos una pausa de 1 segundo, y se reinicia el loop principal } }

La simulación en Tinkercad

El diseño del soporte

El diseño del soporte se realizó en AutoCAD 3D, como de muestra en el screenshot siguiente:

La presentación del proyecto

La presentación del proyecto se realizó en forma grupal, y se muestra a continuación:

El interruptor de presión DIY, es un dispositivo de entrada análogo bastante sencillo, basado en dos placas pequeñas de cartón, con superficies conductoras adheridas a ellas, y separadas por un elemento elástico como una esponja o un material similar, como se muestra en las fotografías:

El interruptor de presión se utilizará con dos códigos de los que vienen como ejemplo en el programa de Arduino: AnalogInput y Smoothing

AnalogInput

El código AnalogInput, como ya lo habíamos visto en un post anterior, enciende y apaga un LED con diferente frecuencia, dependiendo de la lectura que hace Arduino desde un dispositivo análogo, como es el de la resistencia variable de un potenciómetro.

En este caso, esa misma lectura variable se realiza desde el interruptor de presión DIY, como se muestra en el video:

Smoothing

El código Smoothing, que también forma parte de los ejemplos del programa de Arduino, se diferencia del anterior porque no tiene una salida física, como una luz LED o un dispositivo de audio.

La salida del código es una salida digital, por medio de un display o ventana gráfica, que muestra los valores de interrupción de la conexión.

La entrada, en cambio, es análoga, al igual que en el caso anterior, de modo que la placa lee la resistencia del interruptor, y la muestra en valores numéricos en pantalla.

El código lo podemos ver a continuación, debidamente comentado, y como es habitual, con las secciones activas en negrita, y los comentarios en cursiva:

/*  Smoothing

 Reads repeatedly from an analog input, calculating a running average and  printing it to the computer. Keeps ten readings in an array and continually  averages them.

 The circuit:  - analog sensor (potentiometer will do) attached to analog input 0

 created 22 Apr 2007  by David A. Mellis  <[email protected]>  modified 9 Apr 2012  by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/Smoothing */

// Define the number of samples to keep track of. The higher the number, the // more the readings will be smoothed, but the slower the output will respond to // the input. Using a constant rather than a normal variable lets us use this // value to determine the size of the readings array. const int numReadings = 10;

int readings[numReadings];      // the readings from the analog input int readIndex = 0;              // the index of the current reading int total = 0;                  // the running total int average = 0;                // the average

int inputPin = A0;

void setup() {  // initialize serial communication with computer:  Serial.begin(9600);  // initialize all the readings to 0:  for (int thisReading = 0; thisReading < numReadings; thisReading++) {    readings[thisReading] = 0;  } }

void loop() {  // subtract the last reading:  total = total - readings[readIndex];  // read from the sensor:  readings[readIndex] = analogRead(inputPin);  // add the reading to the total:  total = total + readings[readIndex];  // advance to the next position in the array:  readIndex = readIndex + 1;

 // if we're at the end of the array...  if (readIndex >= numReadings) {    // ...wrap around to the beginning:    readIndex = 0;  }

 // calculate the average:  average = total / numReadings;  // send it to the computer as ASCII digits  Serial.println(average);  delay(1);        // delay in between reads for stability }

El resultado del uso de este código, con el mismo interruptor digital DIY, se puede ver en en siguiente video:

Me he tomado la libertad de realizar una variante a la tarea encomendada en el contexto del módulo “Physical Computing” del Diplomado en Diseño, Innovación y Tecnología de la Universidad Adolfo Ibáñez, la que consistía originalmente en realizar una variante al uso del código “Analog Input”, que es parte de los ejemplos que vienen incluidos en el programa de la placa Arduino UNO.

En lugar de ello, he realizado una variante al uso del código “Button”, también incluido dentro de los mismos ejemplos básicos. Esto con el propósito de crear un interruptor sensible al calor, que emita una alarma auditiva cuando se encuentre expuesto directamente al fuego.

El código utilizado fue el mismo utilizado para encender y apagar un LED con un botón:

/*  Button

 Turns on and off a light emitting diode(LED) connected to digital pin 13,  when pressing a pushbutton attached to pin 2.

 The circuit:  - LED attached from pin 13 to ground  - pushbutton attached to pin 2 from +5V  - 10K resistor attached to pin 2 from ground

 - Note: on most Arduinos there is already an LED on the board    attached to pin 13.

 created 2005  by DojoDave <http://www.0j0.org>  modified 30 Aug 2011  by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/Button */

// constants won't change. They're used here to set pin numbers: const int buttonPin = 2;     // the number of the pushbutton pin const int ledPin =  13;      // the number of the LED pin

// variables will change: int buttonState = 0;         // variable for reading the pushbutton status

void setup() {  // initialize the LED pin as an output:  pinMode(ledPin, OUTPUT);  // initialize the pushbutton pin as an input:  pinMode(buttonPin, INPUT); }

void loop() {  // read the state of the pushbutton value:  buttonState = digitalRead(buttonPin);

 // check if the pushbutton is pressed. If it is, the buttonState is HIGH:  if (buttonState == HIGH) {    // turn LED on:    digitalWrite(ledPin, HIGH);  } else {    // turn LED off:    digitalWrite(ledPin, LOW);  } }

Como ya es usual, se han destacado en negrita las partes activas del código, y en cursiva los comentarios.

Las variantes se han introducido en el dispositivo de salida, en que se ha reemplazado el LED por un Buzzer piezoeléctrico, y el dispositivo de entrada, en que se ha reemplazado el botón por un dispositivo fabbricado a partir de piezas de otros elementos:

Una pinza de un pendrive

Huincha aislante

Dos chinches metálicos

Las conexiones se han mantenido de acuerdo al código original.

El resultado lo podemos apreciar en el siguiente video:

Como veíamos en el post anterior, la sección del código randomLED del proyecto de control de 8 LEDs mediante Arduino, nos permitía encender y apagar los LEDs de acuerdo a una secuencia aleatoria, utilizando la función random(), con un tiempo de encendido fijo definido por la variable delayTime=100, según se muestra en el siguiente video:

 Aceptando el desafío, he definido una nueva función, y he realizado la variación al código, de modo de cumplir con  lo solicitado: Encendido aleatorio de LEDs entre 1 y 8, y por un tiempo aleatorio entre 0 y 1000 milisegundos, utilizando la función random().

Copio la sección de código a continuación, con el respectivo video demostrativo:

/* randomLEDAndTime()

Esta función Enciende y apaga los LEDs en forma aleatoria y por una cantidad de tiempo también aleatoria */

void randomLEDAndTime() {  int index;  int delayTime;

 // The random() function will return a semi-random number each  // time it is called. See http://arduino.cc/en/Reference/Random  // for tips on how to make random() even more random.

 index = random(8);    // pick a random number between 0 and 7  delayTime = random(1000); // elige un número aleatorio entre 0 y 1000

 digitalWrite(ledPins[index], HIGH);  // turn LED on  delay(delayTime);                    // pause to slow down  digitalWrite(ledPins[index], LOW);   // turn LED off }

En el contexto del módulo “Physical Computing” del Diplomado en Diseño, Innovación y Tecnología de la Universidad Adolfo Ibáñez, la profesora del módulo, y directora del Centro de Interfaces Emergentes de la misma Universidad, Carolina Pino, me instó a explorar posibilidades más allá de las vistas en el breve tiempo asignado al módulo, y con este objetivo, me envió un enlace a un sitio web en el que se encuentran muchos proyectos ya desarrollados.

En este post, documentaré el proyecto “Driving Multiple LEDs”, proyecto interesante porque, si bien su resultado es simple, en el sentido de que permite el manejo del encendido y apagado de 8 leds en una protoboard, tiene el interés de que se trata de un código extenso, con varias alternativas de uso, lo que permite entender, sin ser especialista en programación, la estructuración y operación del código escrito en C++

Desarrollaré el post copiando y explicando las partes relevantes del código, y sus variantes:

Driving Multiple LEDs

Materiales necesarios:

1 Breadboard

1 Arduino Uno

8 LEDs

8 resistencias de 330Ω

9 cables jumper

La conexión inicial:

Como se aprecia en la imagen, los cátodos, o polos negativos de los LEDs, están conectados as GND de la placa Arduino, pasando a través de las resistencias de 330Ω. Los ánodos, o polos positivos de los LEDs están conectados a los pines 2 al 9 de la placa Arduino.

El código... por partes: 

/* SparkFun Inventor's Kit Example sketch 04

MULTIPLE LEDs

 Make eight LEDs dance. Dance LEDs, dance!

Hardware connections:

 You'll need eight LEDs, and eight 330 Ohm resistors  (orange-orange-brown).

   For each LED, connect the negative side (shorter leg)    to a 330 Ohm resistor.

   Connect the other side of the resistors to GND.

   Connect the positive side (longer leg) of the LEDs    to Arduino digital pins 2 through 9.

This sketch was written by SparkFun Electronics, with lots of help from the Arduino community. This code is completely free for any use. Visit http://learn.sparkfun.com/products/2 for SIK information. Visit http://www.arduino.cc to learn about the Arduino.

Version 2.0 6/2012 MDG */

// To keep track of all the LED pins, we'll use an "array". // An array lets you store a group of variables, and refer to them // by their position, or "index". Here we're creating an array of // eight integers, and initializing them to a set of values:

int ledPins[] = {2,3,4,5,6,7,8,9};

// The first element of an array is index 0. // We've put the value "2" in index 0, "3" in index 1, etc. // The final index in the above array is 7, which contains // the value "9".

// We're using the values in this array to specify the pin numbers // that the eight LEDs are connected to. LED 0 is connected to // pin 2, LED 1 is connected to pin 3, etc.

Como es habitual, el código propiamente tal está en negrita, mientras que los comentarios están en cursiva.

En la sección inicial se explica el resultado final que tendrá la realización del proyecto: “Make eight LEDs dance. Dance LEDs, dance!“, y las conexiones que deben realizarse.

Además se explica que se realizará la definición de las variables mediante un “array”, lo que resulta más cómodo para su control, y más breve en cuanto a la escritura de código, que definir las variables una a una.

Un array indexa las variables declaradas contando desde el 0, de modo que el elemento 0 del array corresponde al pin N°2, el elemento 1 al pin N°3, y así sucesivamente, lo que es relevante para entender las siguientes partes del código.

VOID(): Primera parte

void setup() {  int index;

 // In this sketch, we'll use "for() loops" to step variables from  // one value to another, and perform a set of instructions for  // each step. For() loops are a very handy way to get numbers to  // count up or down.

 // Every for() loop has three statements separated by  // semicolons (;):

 //   1. Something to do before starting  //   2. A test to perform; as long as it's true, keep looping  //   3. Something to do after each loop (increase a variable)

 // For the for() loop below, these are the three statements:

 //   1. index = 0;    Before starting, make index = 0.  //   2. index <= 7;   If index is less or equal to 7,  //                    run the following code.  //            (When index = 8, continue with the sketch.)  //   3. index++   Putting "++" after a variable means  //                    "add one to it".  //            (You can also use "index = index + 1".)

 // Every time you go through the loop, the statements following  // the for() (within the brackets) will run.

 // When the test in statement 2 is finally false, the sketch  // will continue.

 // Here we'll use a for() loop to initialize all the LED pins  // to outputs. This is much easier than writing eight separate  // statements to do the same thing.

 // This for() loop will make index = 0, then run the pinMode()  // statement within the brackets. It will then do the same thing  // for index = 2, index = 3, etc. all the way to index = 7.

 for(index = 0; index <= 7; index++)  {    pinMode(ledPins[index],OUTPUT);    // ledPins[index] is replaced by the value in the array.    // For example, ledPins[0] is 2  } }

En esta sección se explica que se utilizará la secuencia for() loop para asignar sucesivamente distintos valores a las variables y realizar secuencias de instrucciones en forma más fácil.

Se indica también que la secuencia for() loop debe explicitar tres estados, separados por un punto y coma cada uno: 

1. El estado antes del inicio de la secuencia 2. Lo que ocurre durante la secuencia de repetición 3. Lo que ocurre después de cada repetición (incrementar la variable)

De este modo, cuando la variable alcanza un límite establecido, continúa la siguiente parte del código.

Se explica también que el array alude sucesivamente a las variables indexadas de acuerdo a lo explicado anteriormente: 0 = pin 2, 1 = pin 3, y así sucesivamente.

La secuencia for() loop inicia en el index=0 (pin 2), se mantiene activa mientras el index es <=7 (pin 2 al 9), y se reinicia cuando el index llega a 8 (pin 9)

VOID(): Las diferentes secuencias 

void loop() {  // This loop() calls functions that we've written further below.  // We've disabled some of these by commenting them out (putting  // "//" in front of them). To try different LED displays, remove  // the "//" in front of the ones you'd like to run, and add "//"  // in front of those you don't to comment out (and disable) those  // lines.

 oneAfterAnotherNoLoop();  // Light up all the LEDs in turn

 //oneAfterAnotherLoop();  // Same as oneAfterAnotherNoLoop,                            // but with much less typing

 //oneOnAtATime();         // Turn on one LED at a time,                            // scrolling down the line

 //pingPong();             // Light the LEDs middle to the edges

 //marquee();              // Chase lights like you see on signs

 //randomLED();            // Blink LEDs randomly }

Esta sección llama a la función de secuencia de encendido y apagado de LEDs que se va a ejecutar.

En forma predeterminada está activada la secuencia  oneAfterAnotherNoLoop(); , que como se explica, enciende las luces LED por turno y luego las apaga en el mismo orden. Las otras funciones, al estar encabezadas por un doble slash, están desactivadas, pero se pueden ir alternando, “descomentándolas”, es decir, quitándoles el doble slash, y comentando la función activa, que es lo que iremos viendo a continuación en sucesivos videos.

Secuencia 1:  oneAfterAnotherNoLoop  

/* oneAfterAnotherNoLoop()

This function will light one LED, delay for delayTime, then light the next LED, and repeat until all the LEDs are on. It will then turn them off in the reverse order.

This function does NOT use a for() loop. We've done it the hard way to show you how much easier life can be when you use for() loops. Take a look at oneAfterAnotherLoop() further down, which does exactly the same thing with much less typing. */

void oneAfterAnotherNoLoop() {  int delayTime = 100; // time (milliseconds) to pause between LEDs                       // make this smaller for faster switching

 // turn all the LEDs on:

 digitalWrite(ledPins[0], HIGH);  //Turns on LED #0 (pin 2)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[1], HIGH);  //Turns on LED #1 (pin 3)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[2], HIGH);  //Turns on LED #2 (pin 4)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[3], HIGH);  //Turns on LED #3 (pin 5)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[4], HIGH);  //Turns on LED #4 (pin 6)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[5], HIGH);  //Turns on LED #5 (pin 7)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[6], HIGH);  //Turns on LED #6 (pin 8)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[7], HIGH);  //Turns on LED #7 (pin 9)  delay(delayTime);                //wait delayTime milliseconds  

 // turn all the LEDs off:

 digitalWrite(ledPins[7], LOW);   //Turn off LED #7 (pin 9)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[6], LOW);   //Turn off LED #6 (pin 8)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[5], LOW);   //Turn off LED #5 (pin 7)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[4], LOW);   //Turn off LED #4 (pin 6)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[3], LOW);   //Turn off LED #3 (pin 5)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[2], LOW);   //Turn off LED #2 (pin 4)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[1], LOW);   //Turn off LED #1 (pin 3)  delay(delayTime);                //wait delayTime milliseconds  digitalWrite(ledPins[0], LOW);   //Turn off LED #0 (pin 2)  delay(delayTime);                //wait delayTime milliseconds   }

La secuencia establece el encendido de los LEDs en forma sucesiva, con un tiempo de espera de 100 milisegundos y luego su apagado sucesivo, con el mismo tiempo de espera, como se muestra en el video:

Secuencia 2: oneAfterAnotherLoop

/* oneAfterAnotherLoop()

This function does exactly the same thing as oneAfterAnotherNoLoop(), but it takes advantage of for() loops and the array to do it with much less typing. */

void oneAfterAnotherLoop() {  int index;  int delayTime = 100; // milliseconds to pause between LEDs                       // make this smaller for faster switching

 // Turn all the LEDs on:

 // This for() loop will step index from 0 to 7  // (putting "++" after a variable means add one to it)  // and will then use digitalWrite() to turn that LED on.

 for(index = 0; index <= 7; index++)  {    digitalWrite(ledPins[index], HIGH);    delay(delayTime);                  }                                  

 // Turn all the LEDs off:

 // This for() loop will step index from 7 to 0  // (putting "--" after a variable means subtract one from it)  // and will then use digitalWrite() to turn that LED off.

 for(index = 7; index >= 0; index--)  {    digitalWrite(ledPins[index], LOW);    delay(delayTime);  }               }

La secuencia ejecuta el mismo orden de encendido y apagado de la sección de código anterior, pero con menos líneas de escritura, pues en lugar de asignar la acción de encendido y apagado a cada LED individualmente, se basa en la secuencia for() loop para ello, primero en un sentido  for(index = 0; index <= 7; index++), para la orden de encendido (HIGH) y delayTime, y luego en sentido inverso for(index = 7; index >= 0; index--) , como se aprecia en el video:

Secuencia 3: oneOnAtATime

/* oneOnAtATime()

This function will step through the LEDs, lighting only one at at time. */

void oneOnAtATime() {  int index;  int delayTime = 100; // milliseconds to pause between LEDs                       // make this smaller for faster switching

 // step through the LEDs, from 0 to 7

 for(index = 0; index <= 7; index++)  {    digitalWrite(ledPins[index], HIGH);  // turn LED on    delay(delayTime);                    // pause to slow down    digitalWrite(ledPins[index], LOW);   // turn LED off  } }

Esta parte del código enciende y apaga un LED a la vez, basándose en la secuencia for() loop, con un delayTime de 100 milisegundos, como se muestra y explica en el video:

Secuencia 4: pingPong

/* pingPong()

This function will step through the LEDs, lighting one at at time in both directions. */

void pingPong() {  int index;  int delayTime = 100; // milliseconds to pause between LEDs                       // make this smaller for faster switching

 // step through the LEDs, from 0 to 7

 for(index = 0; index <= 7; index++)  {    digitalWrite(ledPins[index], HIGH);  // turn LED on    delay(delayTime);                    // pause to slow down    digitalWrite(ledPins[index], LOW);   // turn LED off  }

 // step through the LEDs, from 7 to 0

 for(index = 7; index >= 0; index--)  {    digitalWrite(ledPins[index], HIGH);  // turn LED on    delay(delayTime);                    // pause to slow down    digitalWrite(ledPins[index], LOW);   // turn LED off  } }

Esta sección del código establece una secuencia de encendido y apagado en un sentido, del pin 2 al pin 9, y luego invierte el sentido de la secuencia, desde el pin 9 hasta el pin 2, haciendo un juego de ida y vuelta, como en el ping pong, basándose para ello, como en los otros casos, en la secuencia for() loop. La sección de código está claramente dividida en dos partes, con las órdenes de encendido (HIGH), espera (delayTime), y apagado (LOW), en primer lugar siguiendo el Array de 0 a 7,  for(index = 0; index <= 7; index++), y en segundo lugar, invirtiendo la secuencia, de 7 a 0  for(index = 7; index >= 0; index--), como se muestra en el video:

Secuencia 5: marquee

/* marquee()

This function will mimic "chase lights" like those around signs. */

void marquee() {  int index;  int delayTime = 200; // milliseconds to pause between LEDs                       // Make this smaller for faster switching

 // Step through the first four LEDs  // (We'll light up one in the lower 4 and one in the upper 4)

 for(index = 0; index <= 3; index++) // Step from 0 to 3  {    digitalWrite(ledPins[index], HIGH);    // Turn a LED on    digitalWrite(ledPins[index+4], HIGH);  // Skip four, and turn that LED on    delay(delayTime);                      // Pause to slow down the sequence    digitalWrite(ledPins[index], LOW);     // Turn the LED off    digitalWrite(ledPins[index+4], LOW);   // Skip four, and turn that LED off  } }

Esta sección del código imita a las luces que se persiguen, como en una marquesina comercial.

Para ello utiliza una vez más la secuencia for() loop, pero la limita al index=0 (pin2) hasta el index=3 (pin4), y establece un salto al index+4, de modo que al mismo tiempo que se enciende el LED 2, se enciende el LED 6, para luego apagarse, y dar paso sucesivamente a las parejas 3 y 7, 4 y 8, y finalmente 5 y 9, tal como se muestra y explica en el video:

Secuencia 6: randomLED

/* randomLED()

This function will turn on random LEDs. Can you modify it so it also lights them for random times? */

void randomLED() {  int index;  int delayTime;

 // The random() function will return a semi-random number each  // time it is called. See http://arduino.cc/en/Reference/Random  // for tips on how to make random() even more random.

 index = random(8);    // pick a random number between 0 and 7  delayTime = 100;

 digitalWrite(ledPins[index], HIGH);  // turn LED on  delay(delayTime);                    // pause to slow down  digitalWrite(ledPins[index], LOW);   // turn LED off }

Esta sección del código enciende y apaga los LEDs en una secuencia aleatoria, utilizando la función random() para escoger un número al azar dentro del array de 8 posibilidades, función que está documentada en http://arduino.cc/en/Reference/Random

El tiempo de encendido/apagado, está definido por un delayTime fijo de 100 milisegundos. Sin embargo, los propios comentarios al código planean una pregunta:

¿Es posible modificar también el tiempo de encendido/apagado, de modo que este también sea aleatorio?

El código ANALOG INPUT es uno de los ejemplos que vienen incluidos en el programa de Arduino, en el apartado “Analog”, pues define un input análogo, o de operación manual, para el accionamiento del LED incorporado en la placa, y que se puede conducir a lun LED externo.

ANALOG INPUT hace que un diodo o luz led se encienda y apague gradualmente, accionando un potenciómetro conectado a los pines de entrada o input análogos de la placa.

Copio el código a continuación:

/*  Analog Input

 Demonstrates analog input by reading an analog sensor on analog pin 0 and  turning on and off a light emitting diode(LED) connected to digital pin 13.  The amount of time the LED will be on and off depends on the value obtained  by analogRead().

 The circuit:  - potentiometer    center pin of the potentiometer to the analog input 0    one side pin (either one) to ground    the other side pin to +5V  - LED    anode (long leg) attached to digital output 13    cathode (short leg) attached to ground

 - Note: because most Arduinos have a built-in LED attached to pin 13 on the    board, the LED is optional.

 created by David Cuartielles  modified 30 Aug 2011  By Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/AnalogInput */

int sensorPin = A0;    // select the input pin for the potentiometer int ledPin = 13;      // select the pin for the LED int sensorValue = 0;  // variable to store the value coming from the sensor

void setup() {  // declare the ledPin as an OUTPUT:  pinMode(ledPin, OUTPUT); }

void loop() {  // read the value from the sensor:  sensorValue = analogRead(sensorPin);  // turn the ledPin on  digitalWrite(ledPin, HIGH);  // stop the program for <sensorValue> milliseconds:  delay(sensorValue);  // turn the ledPin off:  digitalWrite(ledPin, LOW);  // stop the program for for <sensorValue> milliseconds:  delay(sensorValue); }

El código propiamente tal está en negrita, y los comentarios explicativos en cursiva.

En el video se explica en detalle el código, y se muestra su funcionamiento una vez cargado en la placa Arduino UNO, y conectado a la protoboard.

VARIANTE DEL OUTPUT

Adicionalmente se realizó una variante del OUTPUT o salida, conectándolo  un dispositivo de audio (parlante), como se muestra en el video:

El código BUTTON es uno de los ejemplos que vienen incluidos en el programa de Arduino, en el apartado “Digital”, pues define un input digital para el accionamiento del LED incorporado en la placa, y que se puede conducir a lun LED externo.

BUTTON hace que un diodo o luz led se encienda y apague accionando un botón conectado a los pines de entrada o input digitales de la placa.

Copio el código a continuación:

/*  Button

 Turns on and off a light emitting diode(LED) connected to digital pin 13,  when pressing a pushbutton attached to pin 2.

 The circuit:  - LED attached from pin 13 to ground  - pushbutton attached to pin 2 from +5V  - 10K resistor attached to pin 2 from ground

 - Note: on most Arduinos there is already an LED on the board    attached to pin 13.

 created 2005  by DojoDave <http://www.0j0.org>  modified 30 Aug 2011  by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/Button */

// constants won't change. They're used here to set pin numbers: const int buttonPin = 2;     // the number of the pushbutton pin const int ledPin =  13;      // the number of the LED pin

// variables will change: int buttonState = 0;         // variable for reading the pushbutton status

void setup() {  // initialize the LED pin as an output:  pinMode(ledPin, OUTPUT);  // initialize the pushbutton pin as an input:  pinMode(buttonPin, INPUT); }

void loop() {  // read the state of the pushbutton value:  buttonState = digitalRead(buttonPin);

 // check if the pushbutton is pressed. If it is, the buttonState is HIGH:  if (buttonState == HIGH) {    // turn LED on:    digitalWrite(ledPin, HIGH);  } else {    // turn LED off:    digitalWrite(ledPin, LOW);  } }

El código propiamente tal está en negrita, y los comentarios explicativos en cursiva.

En el video se explica en detalle el código, y se muestra su funcionamiento una vez cargado en la placa Arduino UNO, y conectado a la protoboard.

El código FADE es uno de los ejemplos básicos que viene incluido en el programa de Arduino.

FADE hace que un diodo o luz led se encienda y apague aumentando y disminuyendo su intensidad gradualmente.

Copio el código a continuación:

/*  Fade

 This example shows how to fade an LED on pin 9 using the analogWrite()  function.

 The analogWrite() function uses PWM, so if you want to change the pin you're  using, be sure to use another PWM capable pin. On most Arduino, the PWM pins  are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/Fade */

int led = 9;           // the PWM pin the LED is attached to int brightness = 0;    // how bright the LED is int fadeAmount = 5;    // how many points to fade the LED by

// the setup routine runs once when you press reset: void setup() {  // declare pin 9 to be an output:  pinMode(led, OUTPUT); }

// the loop routine runs over and over again forever: void loop() {  // set the brightness of pin 9:  analogWrite(led, brightness);

 // change the brightness for next time through the loop:  brightness = brightness + fadeAmount;

 // reverse the direction of the fading at the ends of the fade:  if (brightness <= 0 || brightness >= 255) {    fadeAmount = -fadeAmount;  }  // wait for 30 milliseconds to see the dimming effect  delay(30); }

El código propiamente tal está en negrita, y los comentarios explicativos en cursiva.

En el video se explica en detalle el código, y se muestra su funcionamiento una vez cargado en la placa Arduino UNO, y conectado a la protoboard.

El código BLINK es uno de los ejemplos básicos que viene incluido en el programa de Arduino.

BLINK hace un loop de encendido y apagado de un LED en intervalos definidos en milisegundos.

Copio el código a continuación:

/*  Blink

 Turns an LED on for one second, then off for one second, repeatedly.

 Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to  the correct LED pin independent of which board is used.  If you want to know what pin the on-board LED is connected to on your Arduino  model, check the Technical Specs of your board at:  https://www.arduino.cc/en/Main/Products

 modified 8 May 2014  by Scott Fitzgerald  modified 2 Sep 2016  by Arturo Guadalupi  modified 8 Sep 2016  by Colby Newman

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/Blink */

// the setup function runs once when you press reset or power the board void setup() {  // initialize digital pin LED_BUILTIN as an output.  pinMode(LED_BUILTIN, OUTPUT); }

// the loop function runs over and over again forever void loop() {  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)  delay(1000);                       // wait for a second  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW  delay(1000);                       // wait for a second }

El código propiamente tal, está en negrita, y los comentarios explicativos en cursiva.

En el video se explica en detalle el código, y se muestra su funcionamiento una vez cargado en la placa Arduino UNO, y conectado a la protoboard.

La plasticina conductiva es una mezcla de harina, agua y sal, cocidas. La presencia de sal es la que le otorga las propiedades de conductividad, de modo que puede actuar como un borne de conexión.

La receta para su fabricación es la siguiente:

PLASTICINA CONDUCTIVA

1 taza de agua de la llave 1 1/2 taza de harina (con o sin polvos) 1/4 taza de sal 1 cucharada de aceite vegetal. Colorantes (opcional) 9 cucharaditas de jugo de limón

Preparación: Mezcla el agua con la taza de harina, la sal, el aceite y el colorante en un bol mediano. Cocínalo en 1 olla mediana a fuego medio, revolviendo constantemente. La mezcla comenzará a calentarse y ponerse más sólida. Sigue revolviendo la mezcla, hasta que se forme una bola al centro de la olla. Una vez que se haga la bola, sácala hacia una superficie que tenga un poco de harina esparcida. Amasa hasta darle una consistencia tipo plasticina.

Entre las masas de plasticina conductiva se puede utilizar plasticina aislante, cuya preparación es similar, pero contiene azúcar, lo que le otorga la propiedad de aislación eléctrica, sin embargo, si las masas se plasticina conductiva se mantienen separadas entre la conectada al polo positivo de la alimentación eléctrica y la conectada al polo negativo de la misma, el resultado es el mismo.

En cualquier caso, la receta para la fabricación de la plasticina aislante es la siguiente:

PLASTICINA AISLANTE

1 1/2 taza de harina (con o sin polvos) ½ taza de azúcar 3 cucharadas de aceite vegetal ½ taza de agua de la llave

Preparación: Mezcla los ingredientes sólidos y aceite en un bol grande, poniendo a un lado ½ taza de harina que usaremos más tarde. Poner agua a la mezcla (aprox. 1 cda.) y bate. Repite este paso hasta que el agua se absorba por la masa. Una vez que la mezcla tenga la consistencia tipo plasticina, echa más agua a la masa hasta que quede pegajosa. Agrega harina en la superficie y pon tu mezcla, amasa hasta que quede con buena consistencia.

Al conectar los polos de una batería de 9v a las masas aisladas de plasticina conductiva, podemos usarlas de bornes para cerrar circuitos eléctricos con una impedancia alta, como la que se necesita para el funcionamiento del Drawdio.

De este modo, podemos, por ejemplo, encender una luz led, como se muestra en la fotografía:

Si le damos más espacio, moldeando la plasticina en forma de cilindros, podemos conectar varias luces:

Finalmente, este mismo circuito a través de las masas de plasticina conductiva, nos permite experimentar con el DRAWDIO, como se muestra en el video:

Ya tenemos a disposición los materiales para la fabricación del DRAWDIO:

De modo que podemos pasa a la etapa de materialización de este dispositivo.

Lo primero es insertar el Circuito Integrado 555 en la ProtoBoard:

Luego de ello, insertamos los condensadores y resistencias, siguiendo el esquema original, que ya habíamos publicado con anterioridad:

Y realizamos las conexiones de acuerdo a ese mismo esquema:

En último lugar, conectamos las salidas al parlante, a la lámina conductora, y al grafito del lápiz, y finalmente alimentamos el circuito con una batería de 9v:

De este modo, pasamos de la modelación en Tinkercad a la fabricación del dispositivo, y aquí tenemos la demostración del resultado en video:

Nikola Tesla, El Amo del Relámpago. (Subtítulos en Español)

Este documental acerca de la vida de Nikola Tesla, es muy recomendable por su objetividad, en cuanto a que no está dramatizado con objetivos cinematográficos, ni cae en especulaciones conspirativas. Presenta en forma clara los hechos de la vida de un hombre extraordinario, un auténtico Da Vinci de la electricidad y de la energía.

Tesla tenía rasgos de carácter muy peculiares, que lo llevaron a ser una especie de devoto consagrado a su propia genialidad. Si bien disfrutó, cuando lo tuvo, del éxito comercial de sus invenciones, nunca fue éste el centro y objetivo de su quehacer. Tenía muy pocas habilidades en los negocios, y muy poca visión comercial, era un inocente polluelo en un mundo de zorros de la empresa, de modo que, si bien sus propuestas se impusieron por su propio peso en la millonaria industria de la energía eléctrica en el mundo entero, él mismo nunca recibió el justo pago por ello, terminando sus días en la misma pobreza con la que arribó al “país de las oportunidades”, Estados Unidos.

Por otra parte sacrificó por entero su vida afectiva en beneficio de su trabajo. Renunció voluntariamente a la unión de pareja y a la construcción de una familia, a pesar de que tuvo connotadas pretendientes.

Pero más allá de sus rasgos de carácter, la excepcionalidad de Nikola Tesla se centra en que nunca puso límites a su pensamiento, nunca prejuzgó una idea, por descabellada que esta pudiera parecer, y siempre empujó los límites más allá de lo que a su alrededor se admitía como racionalmente posible. Esto lo condujo a descubrimientos sin precedentes, y también a desastres estrepitosos.

Pero tanto sus grandes aciertos como sus grandes errores experimentales, han dado pie a un desarrollo tecnológico que ni el mismo imaginó. La transmisión de electricidad por el método de corriente alterna es, sin duda, su logro referencial. Pero detrás de muchas otras tecnologías de las que hacemos uso diariamente hoy en día, está el genio de Tesla: Los controles inalámbricos, la transmisión de datos física e inalámbrica.

El Drawdio es un circuito electrónico destinado a que un lápiz emita sonidos, a través de un parlante, cuando dibuja sobre un papel, y que estos sonidos varíen según se imprime mayor o menor intensidad al trazo, actuando entonces el contacto entre el grafito y el papel como una resistencia variable que estimula al parlante.

El Drawdio se puede fabricar con diferentes grados de complejidad, dependiendo de los componentes que se utilicen, y del resultado que se quiera obtener.

En este caso, se trata de fabricar el circuito en una versión muy simple, utilizando como base el conocido Circuito Integrado 555.

En la primera parte de este trabajo, realizaremos la simulación del circuito, utilizando el programa online de simulación Tinkercad de Autodesk. Considerando que se trata de una simulación, se conducirán las salidas a lápiz y a papel a un potenciómetro, que actúa también como una resistencia variable. En una segunda etapa, teniendo los materiales a disposición, fabricaremos el circuito en forma real, y podremos probar su funcionamiento.

Ya sea que fabriquemos el circuito en forma simulada o real, necesitamos disponer de los componentes, los que se listan a continuación:

1 protoboard (no es imprescindible, pero facilita mucho el trabajo)

1 parlante de 8Ω (se puede sacar de un juguete viejo)

1 batería de 9v con portabatería

1 resistencia de 1KΩ

1 resistencia de 320Ω

1 condensador cerámico de 0.1uF (microfaradios)

1 condensador cerámico de 680pF (picofaradios)

1 condensador electrolítico de 100uF/10v

1 CI 555

1 potenciómetro de 5MΩ (para la simulación)

Además de lo ya listado, para la fabricación física del dispositivo, necesitaremos:

1 lápiz de grafito blando, 4B a 8B, para tener una variación importante en la intensidad del trazo

cables de colores, para diferenciar la polaridad

1 lámina conductora de aluminio o cobre

1 chinche metálico, para hacer el contacto con el grafito del lápiz

si no se va a usar protoboard, para hacer el circuito más pequeño y fácilmente montable sobre el lápiz, se necesitará un cautín, y soldadura de estaño

cinta adhesiva

Diagrama

El diagrama del circuito se ilustra a continuación:

Simulación en Tinkercad

De acuerdo a este diagrama, se simuló el circuito utilizando el programa de simulación online Tinkercad de Autodesk, y como ya se indicó anteriomente, se dirigieroan las salidas a grafito y a lámina, a un potenciómetro que actúa como resistencia variable.

De este modo el resultado fué el siguiente:

Para probar el funcionamiento, se puede acceder al siguiente enlace:

Drawdio Sergio Hernández

Video con la simulación, en el que se demuestra cómo el cambio de voltaje de salida al parlante, cambia el tono del sonido:

La película, que trata de la rivalidad entre dos jóvenes magos prestidigitadores en la Inglaterra de fines del siglo XIX, está hábilmente estructurada sobre la afirmación introductoria de Cutter (Michael Caine), quien señala que todo truco mágico consta de tres actos: En el primero, “la promesa”, se nos muestra un objeto común, sin nada especial. En el segundo acto, “la transformación”, el mago toma el objeto común y lo convierte en algo extraordinario, pero aún nadie aplaude, pues  no es suficiente hacer desaparecer algo, hay que aparecerlo nuevamente, lo que constituye el tercer acto, “la prestidigitación”, que es el acto de magia propiamente tal. Ahí reside el secreto que asombra, pero que el público no quiere descubrir realmente. El público disfruta de que lo engañen.

Así mismo la película nos muestra los tres actos de la magia, en una complicada serie de engaños, traiciones, y saltos temporales, que se inician con “la promesa”, los dos jóvenes prestidigitadores colaborando en un truco exitoso, pero común, a partir del cual se empieza a fraguar la rivalidad que a la larga será irreconciliable, entre ambos. La perseverancia racional, pero conservadora, de la búsqueda del truco perfecto del uno, contra la audacia experimental del otro, rivalidad en la que la ausencia de escrúpulos es factor común, pues las traiciones, espionajes, sabotajes, y manipulación de personas, abundan, en un ambiente cargado de la fatídica soledad y egoísmo de cada uno de ellos, y en el que el daño a terceras personas no pasa de ser u efecto colateral necesario, como el de la muerte del pajarillo aplastado en el mecanismo de la jaula que lo hace “desaparecer”, para luego ser reemplazado por otro, que el público prefiere ver como “el mismo”, más allá de reparos sentimentales o éticos.

El segundo acto, “la transformación”, nos presenta el acto extraordinario que se transformará en el leit-motiv de la truculenta trama, y el resorte de una seguidilla de actos inescrupulosos con el objeto de apropiarse del “mejor truco jamás visto”: el hombre transportado, manipulación, traiciones, robos, y víctimas inocentes de la obsesión del uno, y la megalomanía desmedida del otro, conduce el desarrollo de los hechos al punto en el que la ciencia, muy hermanada con la magia en el contexto de una sociedad muy ignorante, entre en escena, en la forma de un chantaje que recibe un pago falso pero decisivo para la trama: el código que, supuestamente, descifra el libro de trucos del uno, es ni más ni menos que el apellido del gran genio de la corriente alterna: Tesla, una especie de alquimista ante los ojos del público, y de los propios protagonistas, que maneja las fuerzas desconocidas de la naturaleza, haciéndolas ver como una forma de magia superior, que puede hacer de la prestidigitación un hecho real. Tesla sabe que su “ciencia mágica” tiene el potencial de revolucionar el mundo, y aunque se percata de que el ambicioso peticionario ha llegado a él por una pista falsa, acepta el desafío de hacer de la teletransportación una realidad.

El tercer acto, “la prestidigitación”, nos muestra a la ciencia haciendo realidad lo imposible. Mientras Tesla pone en manos del ambicioso racional una ficticia para la historia, pero verosímil para la película, máquina de teletransportación, y de paso deja atrás, destruida, toda huella de su trabajo, para esconderla de una segunda rivalidad irreconciliable que corre en paralelo a la principal de la trama, la rivalidad histórica Edison vs Tesla, el audaz inescrupuloso, que ante la derrota de lo inalcanzable, la “magia real” contra la burda prestidigitación, asesina a su rival.

La prestidigitación, finalmente queda al descubierto ante los asombrados ojos del espectador, pues son los “dobles”, instrumentos de la manipulación de los protagonistas, quienes develan el truco burdo, mientras se quedan con los frutos de quienes lo sacrificaron todo, hasta su vida y la de sus seres queridos, por el aplauso y los laureles.

Y no diré más para no caer en el “spoiler”.

La película, producción de Netflix, es un documental divulgativo de segundo nivel, en cuanto a que pone a disposición del público general los entretelones comerciales de las redes sociales, y lo hace a partir de la entrevista a expertos, en este caso a personas que trabajaron en el desarrollo de algún aspecto de las numerosas redes sociales que hoy dominan el mercado.

Es un documental estructurado en base a fragmentos de entrevistas alternadas a personas que ocuparon cargos de importancia en Facebook, Instagram, Twitter, Pinterest, Snapchat, Reddit, y otras redes similares, fragmentos de entrevistas que se alternan, y se pretenden ilustrar, con la historia de una familia pretendidamente típica con hijos adolescentes que presentan una adicción a las redes sociales, y de la cual se pone el foco en uno de los hijos en particular, para ilustrar la manipulación, a partir del control de datos personales, que las redes sociales ejercen sobre él. Las redes sociales aparecen en este caso personificadas por un holograma de ser humano con varios clones, que actúan coordinadamente detrás de grandes pantallas de computador, lanzando estímulos, publicidad, alertas, y recursos similares, para mantener capturada la atención del joven, durante la mayor parte del tiempo posible, en la pantalla de su smartphone.

La película, en términos de valor cinematográfico, es de muy bajo nivel, la ficción de los hologramas humanos que lanzan estímulos y publicidad en el momento preciso a un individuo en particular, resulta muy poco creíble, y no está a la altura de la problemática de fondo que el documental pretende abordar.

El problema de fondo, sin embargo, no es trivial, y se trata del completo, complejo y enorme almacenamiento de datos personales de los usuarios de redes sociales, de su manejo mediante inteligencia artificial, y su utilización para diversos fines, desde la publicidad orientada, hasta el control de la información y las decisiones políticas.

La posición del documental respecto de este tema es un poco paranoide, en cuanto pone el acento, por una parte, en el problema de la dependencia patológica de las redes sociales, y de la obtención de aprobación social, y consecuentemente de autoafirmación, a partir de estas, y por otra, en la difusión masiva de información falsa o tendenciosa que se produce a través de éstas, y que ha conducido a la radicalización de las posiciones políticas en distintos lugares del mundo, y proyecta a partir de esto una visión apocalíptica de la organización social mundial, a no ser de que reaccionemos a tiempo.

Es posible que en países altamente urbanizados, con complejos urbanos gigantescos, en los que las familias tienen escasa convivencia, los hijos se educan en el colegio, con los amigos, y en la calle, y en segmentos sociales culturalmente muy depauperados, lo que presenta el documental constituya un riesgo real.

Sin embargo, mi posición es tender a ver el vaso medio lleno.

Creo que el poner nuestros datos, en una medida controlada, a disposición de programas que utilizan inteligencia artificial, nos facilita, y nos puede facilitar mucho tareas diarias de diversa complejidad.

Ejemplo de esto es la posibilidad de desplazarse en una ciudad desconocida como si uno hubiera vivido toda su vida en ella, solo con el auxilio del smatphone.