Clases presenciales – 2º semestre 2021
. 14 de octubre 2021 – 14:30h a 17:30h – Sala 1A (Impresoras 3D)
. 08 de noviembre 2021 – 14:30h a 17:30h – Sala 1A (Impresoras 3D)
. 02 de diciembre 2021 – 14:30h a 17:30h – Sala 1A (Impresoras 3D)

Calendario: https://docs.google.com/spreadsheets/d/1mH11Q5sTu8wKTQmTdjaeZBmlCn0OXu64U9DlDzant1s/edit?usp=sharing
Registro clases: https://drive.google.com/drive/folders/1_tvvlpvFuZL2ambbVX-UKk151PmzMbvR?usp=sharing
Links bitácoras: https://docs.google.com/document/d/1gOnrY8e6C4C2BlVirZb88_ORw9xTHeTQ5Qj5F5YXxrM/edit?usp=sharing
Programa: https://www.u-cursos.cl/artes/2021/2/TCOM121-820/11/datos_curso/
Bibliografía:https://drive.google.com/drive/folders/1kORqK07tlXhZKaQRr0ExKN_p6mxPS3Xy?usp=sharing

Materiales necesarios para el curso: https://docs.google.com/document/d/1SNax06rH-hr_6cOrecuyOuC5trWjVew1gi0Gxx7EBJs/edit?usp=sharing
Descarga Arduino: https://www.arduino.cc/en/software
Driver Arduino – CH340: https://electrocrea.com/blogs/tutoriales/como-instalar-driver-ch340-para-arduinos-genericos
Descarga Processing: https://processing.org/download

Processing
Processing es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java, de fácil utilización, y que sirve como medio para la enseñanza y producción de proyectos multimedia e interactivos de diseño digital. Fue iniciado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics and Computation Group del MIT Media Lab dirigido por John Maeda Ref.: Wikipedia: Processing
– Design by numbers
– Sitio web oficial de Processing

Fexibilidad
Processing consiste en muchas herramientas que trabajan juntas en diferentes combinaciones. Como resultado, puede ser usado para programación rápida, o bien para una investigación acuciosa.
Debido a que un programa desarrollado en Processing puede ser tan corto como una línea de código, o tan largo como miles de líneas, hay espacio para el crecimiento y la variación. Más de 100 librerías pueden extender Processing a dominios más alejados, incluyendo sonido, computer vision o fabricación digital.

Otros recursos sugeridos
Github: sitio de comunidad de programadores – Github
Gist de Github: Documento tutorial para publicar en Gist.. Seguir hasta el punto d solamente, lo que sigue sólo es útil si se quiere publicar el código en un sitio desarrollado en WordPress.
Openprocessing: Sitio comunitario de sketches de Processing
Daniel Shiffman: Sitio personal, The coding train, learningprocessing.com/
Tutoriales: en Processing.org
Curso en video: Hello Processing
En Español: Tutorial Processing

Sesión nº1

Contenidos vistos en la clase de hoy: Pg. 1 a 36
Libro: Hola Mundo con Processing

Ambiente de programación:
IDE (integrated development environment).

Funciones: las funciones son líneas de código pre-escritas en Processing (o cualquier otro lenguaje de programación) y que tienen la “función” de ejecutar una instrucción específica para que, quien esté programando, no tenga que escribir todo desde cero. Cualquier programador podrá desarrollar sus propias funciones según lo vaya necesitando. Por ejemplo, la función “rect” incluida en Processing tiene la función de dibujar un rectángulo según las instrucciones dadas.
Sintaxis: término que viene de la lingüística y que se refiere a las reglas y orden en la escritura de determinado lenguaje. En el caso de Processing por ejemplo, la sintaxis define la cantidad de parámetros que debe tener una función y el orden en que van escritos. También define que Processing sea ‘case-sensitive’, lo que quiere decir que el programa sí discrimina entre mayúsculas y minúsculas, por lo que hay que poner cuidado de usarlas correctamente.
Parámetros/Argumentos: son los valores que se indican luego de una función. Por ejemplo:
. rect(10, 10, 50, 60):
En esta función, todos los números que van dentro de los paréntesis, son sus parámetros.
Ayuda para uso de funciones / sintaxis / parámetros en Processing:
Para acceder a la ayuda de Processing (también llamada Referencias), se debe escribir una función en el IDE y luego hacer click derecho sobre la palabra (por ejemplo: “rect();”)
Selector de color en Processing
Se encuentra en el Menú: Herramientas –> Selector de Color

En esta herramienta del programa Processing podrán identificar los colores y sus códigos/valores
según distintos modos de color, para luego aplicar esos valores en sus códigos:
[H, S, B] Modo de color de tres canales Hue/Tono, Saturation/Saturación, Brightness/Brillo
[R,G,B] Modo de color de tres canales Red/Rojo, Green/Verde, Blue/Azul
[HEX] Valor hexadecimal. Ej.- #CCCCCC
Más sobre modos de color …
Color en Processing:Link

Primer Sketch realizado en clases (para ver el resultado de este código, copiar y pegar en Processing)
Comenzamos dibujando una línea situada al centro del lienzo de Processing.

De esta manera, pudimos revisar la manera en que Processing dibuja: a partir de un plano cartesiano que sirve como base para indicarle en qué coordenadas dibujar pixeles. Vimos también cómo Processing “lee” las instrucciones (algoritmo) que uno le entrega en el sketch (programa); esto es de arriba a abajo, aspecto que luego se ver reflejado en el orden en que aparecen los dibujos en el plano (como si fueran capas de Photoshop, las líneas de código que aparecen primero aparecerán en el dibujo como si estuvieran debajo de los dibujos que se programan en las líneas posteriores de código).

Ejemplo 1 – Desarrollado durante la clase

size(350, 350);
background(12, 25, 240);
line(width/2, height/2, 500, 509);
fill(237, 19, 45);
strokeWeight(10);
stroke(5, 255, 90);
rect(width/2, height/2, 200, 200);
stroke(255, 176, 3);
fill(254, 255, 0);
ellipse(width/2, height/2, 200, 200);

/*
ESTO ES UN COMENTARIO
kjahlsakjhl
alkjhslfdkjahskl
askdfhakjshdfla
*/
//ajkshlfkajhsdlfkjhaslk

1er Ejercicio: A partir de las funciones revisadas en el código desarrollado en clases, proponer tres imágenes que puedan funcionar como tríptico. Usar solamente esas funciones de manera de enfocarse en la composición a partir de formas simples.

Sesión nº2

Ejemplo 2

size(500, 500); //función “tamaño” (ubicación X, ubicación Y); correspondiendo la x a la horizontal, y la Y a la posición vertical
background(125); //256 el rango va de 0 a 255;
/*
// RGB = rojo verde azul
// HSB = Hue saturation brightness
// HEX = hexadecimal
rectMode(CORNER);
rect(30, 30, 50, 200);
rectMode(CENTER);
rect(30, 30, 50, 200);
ellipse(30, 80, 40, 40); //ellipse(x, y, ancho, alto);
stroke(217, 15, 245);
line(0, 0, 500, 500);
triangle(30, 75, 40, 20, 500, 500);
*/
beginShape();
translate(200, 150);
vertex(50+200, 120+150);
vertex(100, 90);
vertex(110, 60);
vertex(80, 20);
vertex(210, 60);
vertex(50, 120);
endShape();

ellipse(100,100, 40, 40);
translate(50, 0);
ellipse(100,100, 40, 40);

rotate();

/* configuración de color
background();
fill();
noFill();
stroke();
noStroke();
*/

/*
Operadores aritméticos

+
–
*
/

*
*/

Antes de programar, bocetear y prototipar
Bocetear puede ser definido como una manera de pensar. El objetivo básico es explorar la mayor cantidad de ideas en poco tiempo. Cuando se programa, es muy común que se hagan bocetos iniciales para luego llevarlos a código. Ideas para la animación y la interacción se bocetean normalmente como si fueran un storyboard con anotaciones. Luego de hacer algunos sketches de programación, se seleccionan las mejores ideas y son combinadas en prototipos. Es un proceso cíclico de hacer, probar y mejorar … y que se combina entre papel y pantalla.

Ejercicio a realizar para la próxima semana
Dibujar un helado de cono a partir de las funciones de dibujo que hemos revisado hasta ahora.

Referencias de Funciones en Processing de las funciones vistas en clase: 2DPrimitives y Color
https://processing.org/reference/https://processing.org/reference/

Video de apoyo clase 1
Video de apoyo clase 2

Sesión nº3

En esta sesión, revisamos los avances en sus bitácoras en los procesos de programación para el ejercicio de tríptico y luego el dibujo de un helado en cono.

. Ejemplo con modificadores (rotate, translate, scale)

Diagrama radianes

Variables y tipos de datos
Una variable guarda un valor en la memoria del computador para que luego pueda ser usada en el programa. La variable puede ser usada durante todo un programa y tiene la propiedad de que su valor puede ser cambiado fácilmente mientras el programa esté corriendo.

Hasta ahora, dibujaríamos la siguiente imagen, con el código que sigue …

—————inicio código——————
size (480, 120);
ellipseMode(CORNER);
ellipse(20, 40, 60, 60);
ellipse(120, 40, 60, 60);
ellipse(220, 40, 60, 60);
——————fin código——————-

Cuando hay elementos que se repiten en un código, es preferible usar variables (… que es el 99% de las veces).
—————–inicio código——————–
size (480, 120);
int y = 60;
int d = 80;
ellipse(75, y, d, d);
ellipse(175, y, d, d);
ellipse(275, y, d, d);
—————–fin código——————–

En este código se puede ver cómo a la variable ‘y’ que es un entero, se le asigna el valor 60 y a ‘d’ el valor 80. Si se cambia el valor de cualquiera de estas variables, cambiará el tamaño de todas las elipses, porque todas tienen el mismo valor en ‘y’; y en ancho y alto ‘d’.
Las variables deben nombrarse de manera que se pueda entender a qué se refieren. En el ejemplo anterior, se utilizó el nombre ‘d’ para la variable diámetro.
Además, al definir una variable, se debe indicar qué de qué tipo es:
int(un valor entero): por ejemplo 7; 7; 20; 100
float(decimales): por ejemplo 5,1; 6,6; 8,2
Otros tipos de datos: boolean, byte, char, color, double, float, long

b) Variable de sistema: width, height
Con las variables de Processing width y height, podemos relacionar todo lo que se dibuje en relación al ancho y alto de la ventana en donde se visualiza el programa.

—————–inicio código——————–
size (480, 120);
line (0, 0, width, height);
line (width, 0, 0, height);
ellipse (width/2, height/2, 60, 60);
—————–fin código——————–

Video de apoyo:
Funciones beginShape y endShape; vertex,rotate, translate, pushMatrix, popMatrix

Referencia histórico-artística: Cybernetic Cerendipity
1era exposición de arte y tecnología https://monoskop.org/images/2/2a/Reichardt_Jasia_ed_Cybernetic_Serendipidity_The_Computer_and_the_Arts_1969.pdf

Ciclo for
Guía ciclo for: http://etab.cl/clases/uchile/obj-tec/pdfs/clase_ciclo-for_processing.pdf

Códigos desarrollados en clases:
//Tipos de variables
// int es una abreviación de integer (entero)
// float se refiere a los números de coma flotante, es decir números decimales (2,2)
// boolean: dos números, 0 ó 1
// char: abreviación de character (caracter)
// string: frases
// long: para variables grandes

/*
Código inicial, sin “ciclo for”
size(480, 120);
strokeWeight(8);
line(20, 40, 80, 80);
line(80, 40, 140, 80);
line(140, 40, 200, 80);
line(200, 40, 260, 80);
line(260, 40, 320, 80);
line(320, 40, 380, 80);
line(380, 40, 440, 80);
*/

/* EJEMPLO CICLO FOR
size (480, 120);
strokeWeight(8);

for(int i=20; i<400; i+=60){
line(i, 40, i+60, 80);
}
/*

/* OPERADORES RELACIONALES
// < // >
// ==
// !=
*/

/*
CICLO FOR GRADIENTE
size(480, 120);
for( int i=0; i<480; i++){
stroke(i/2, i/2, i/2); //stroke(4, 4, 4);
line(i, 0, i, 120);
}
*/

size(480, 120);
background(0);
//noStroke();

for (int y = 0; y<= height; y +=40) {
fill (255, 30, 70);
ellipse(0, y, 40, 40);
}

**** Ejercicio a resolver: desarrolla el código para la siguientes imagen, utilizando ciclo for: *****

Otras referencias para esta clase:
http://etab.cl/clases/uchile/obj-tec/?page_id=852
http://etab.cl/clases/uchile/obj-tec/pdfs/clase_ciclo-for_processing.pdf
https://www.u-cursos.cl/artes/2020/1/TCOM121-720/10/material_docente/bajar?id_material=3131612 (pg.61 a 67 del pdf (pg. 40 a 46 en la numeración del libro físico).*

Ejercicio para la próxima semana:
Processing: Pg.40 a Pg.46 (numeración del libro y no del pdf)

size(400, 400);
background(0);
strokeWeight(2);
stroke(255);

int x = 0;
while (x <width){
line(x, 0, x, height);
x = x+20;
}

Computadores, historia
https://es.wikipedia.org/wiki/Computadoras_de_Harvard
https://www.youtube.com/watch?v=-L5RoBMKOdM

Referencia códigos para iteraciones. While, For: https://drive.google.com/drive/folders/1Ti3NZqz0N26IbJungoQ5JZEpw35kVFGP
https://www.processing.org/reference/while.html

Referentes

Objetivos de la clase:
El curso está organizado para nivelar a los estudiantes con los conceptos y destrezas básicas para la inclusión de recursos electrónicos y digitales (microcontrolador) en proyectos creativos.

Metodología:
Las sesiones son mayormente de carácter práctico a partir de la exploración, a través de ejercicios guiados, de herramientas y componentes electrónicos, así como también del uso de microcontroladores compatibles con Arduino.
Al finalizar el curso, cada estudiante deberá haber realizado una serie de ejercicios a partir de los conocimientos adquiridos durante las clases. Este proceso, regitrado en una bitácora en línea dará lugar a una evaluación coeficiente uno.

Bitácora
Cada estudiante deberá llevar una bitácora en donde anotará de forma sostenida los procesos que emerjan a partir de los contenidos del curso. La idea es incluir, anotaciones reflexivas acerca del proceso o de posibles proyectos, anotaciones técnicas acerca del circuito o sistema que se esté desarrollando, referencias artísticas o de otro tipo que puedan aportar o tengan relación con el desarrollo de proyectos y ejercicios que se desarrollen en la clase.
Se sugiere usar Google drive en vinculación con youtube/vimeo, soundcloud, flickr u otras plataformas de publicación de contenido.

Materiales:
Cada estudiante deberá contar con los materiales y herramientas enviados para cada sesión.

Bibliografía y web de referencia
www.arduino.cc
Libro Arduino Starter Kit
Libro Getting started with Arduino
Libro Smil Vaclav-Energy

Tabla de ejercicios prácticos a desarrollar en cada clase
https://docs.google.com/spreadsheets/d/1TYin6G1jFwluIOKyYqQgcEKi7vCttCqpfoQLiZxXq2c/edit?usp=sharing

ELECTRÓNICA DIGITAL

Dónde comprar los componentes y herramientas
Lo marcado con asteriscos** son tiendas que están haciendo reparto a domicilio durante la contingencia COVID.
http://www.victronics.cl/**
http://www.olimex.cl/**
http://www.casaroyal.cl/**
— Digitel Electrónica: San Antonio 32 (subterráneo), Stgo. Centro. F: 226324511
– Ibarra: Calle San Diego 928 Santiago – Santiago, Chile, F: 2 672 39 63 / 2 672 94 05
– Electrónica Orfali: San Diego 955, Santiago, F: 2 698 83 76-
– https://cl.rsdelivers.com/**
– AFEL: https://afel.cl**
– http://cm2.cl/**
– https://electronicahobby.cl/**
– https://maxelectronica.cl/**
– https://tectronix.cl/**

Pdfs de apoyo:
Electricidad Intro: Pdf
Herramientas: Pdf

Conceptos introductorios
. energía, transducción, electricidad, circuito, hif-i, low-fi

Imagen del libro Energy, Vaclav Smil, Editorial Oneworld Publications, 2009.Libro Smil Vaclav-Energy

Physical Computing y microcontroladores
Esta es la imagen que inicia el primer libro dedicado a la computación física o Physical Computing. Su primera edición fue publicada en 2004 y fue una respuesta a la inquietud de profesores y estudiantes de distintas áreas interesados en el trabajo creativo que implicaba una respuesta física ante rutinas digitales o vice/versa.

En el libro se hace referencia a esta imagen para explicar el cómo nos relacionamos con los computadores, específicamente en cómo somos percibidos por estos. Hasta ese entonces la forma casi única para una persona de comunicarse con un computador era a partir del mouse y el teclado y por otro lado a través de la vista y los oídos.

Se comenzó a usar microcontroladores de fácil programación para expandir las posibles formas de interacción con la máquina: Basic Stamp, Pic y otros, eran los microcontroladores más utilizados, sin embargo en 2003 en el instituto Ivrea en Italia quisieron hacer aún más fácil el uso de estos dispositivos, así como también más económicos para los estudiantes.

Fue así entonces como comenzó a desarrollarse la placa Arduino y su software en el contexto de una tesis de Magister en el mismo instituto Ivrea por el colombiano Hernando Barragán, quien en ese momento inició su proyecto Wiring en el que luego se basó el proyecto Arduino conducido por un grupo constituido por Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis. También hubo directa influencia del proyecto Processing iniciado por Casey Reas y Ben Fryhttps://player.vimeo.com/video/18390711?color=c9ff23&title=0&byline=0&portrait=0

Luego de Arduino (que es un proyecto Open Source) comenzaron a aparecer distintas placas basadas en ella como RBBB o Makey Makey entre otras.

Otra característica que vale la pena mencionar es que gracias a las características de Arduino, es bastante fácil aumentar sus capacidades de fábrica gracias a los shields que son placas adosables a Arduino para por ejemplo, usar de manera más fácil motores, aplicaciones con sonido, acceder a internet, etc.

También cabe mencionar que hace algunos años se han desarrollado otras placas como Raspberry Pi, Beagle Bone y más recientemente Arduino Galileo (entre otras) que entran dentro de la categoría de pequeños computadores por lo que tienen más capacidad de procesamiento de datos, se les puede instalar un sistema operativo, programas y aceptan periféricos como monitor, teclado, mouse, etc, así como también conexión a Internet sin necesidad de enchufarlos a un shield.

Esta reseña es para contextualizar brevemente en qué situación se generan las herramientas que presentaré las próximas clases. Lo que da para pensar es el rol de estas en las posibilidades de uno generar herramientas propias, que pueden ser personalizadas según las propias necesidades y concepto de un proyecto. Al igual que aprender programación, se generan libertades que no se dan al ocupar máquinas y softwares que no pueden ser modificados.

Links de instalación y proyecto Arduino
Sitio oficial Arduino: http://arduino.cc
Placas Arduino: https://www.arduino.cc/en/Main/Products
IDE Arduino online: https://create.arduino.cc/editor

Conceptos ejercicio #1
. Electrónica: led, resistencia, jumper wire, protoboard, placa arduino.
. Lenguaje Arduino: comentario, función, parámetros, digitalWrite, HIGH, LOW, delay, pinMode, LED_BUILTIN (corresponde a pin Digital 13)

Ejercicio desarrollado en clases:
Hello World / Hola mundo
1) File –> Examples –> Basics —> Blink
Referencia en línea: https://www.arduino.cc/en/Tutorial/Blink

C2 – 15/6/2021

If
La instrucción if () es la más básica de todas las estructuras de control de programación. Permite hacer que algo suceda o no, dependiendo de si una condición dada es verdadera o no. Se parece a esto:

if (unaCondición) {
   // ejecuta algo, si la condición es verdadera
}

Existe también una variación común llamada if-else que se ve así:

if (unaCondición) {
   // ejecuta algo, si la condición es verdadera
} else {
   // ejecuta algo, si la condición es falsa
}

También existe una tercera instrucción: else-if, con la que se puede verificar una segunda condición si la primera es falsa:

if (unaCondición) { 
// ejecuta algo, si la condición es verdadera 
} else if (otraCondición) { 
// ejecuta algo, sólo si la pimera condición es falsa
// y la segunda condición es verdadera
}

Operadores
https://www.arduino.cc/reference/en/#structure
En la programación Arduino, los operadores se utilizan para realizar operaciones como asignación, lógica, incremental, etc. El conocimiento de estos operadores es importante para realizar el cálculo matemático y lógico en Arduino. Básicamente, un operador es responsable de operar con datos. Por ejemplo, si tenemos que realizar la suma de dos números, usaremos el operador de suma, ya que es responsable de realizar la operación de suma en los datos. En la programación de Arduino, todos estos operadores se agrupan en cinco categorías diferentes según sus operaciones

. Arithmetic Operators / Operadores aritméticos
. Comparison Operators / Operadores de comparación o Comparadores
. Boolean Operators / Operadores booleanos
. Compound Operators / Operadores compuestos
. Bitwise Operators / Operadores bitwise (bit a bit)

Links de referencias proyectos de creación
Golan Levin – Messa di Voce
Golan Levin – Interstitial Fragment Processor
Reactable
Chaos Computer Club – Blinkenlights
Mariela Yeregui – Proxemia
Ken Goldberg & Joseph Santarromana – Telegarden
Lisa Park – Eunoia
Medialab Prado
Autómatas (victorianos)
Proyecto Realnsailmail
NIME

Ejercicio a desarrollar en casa:
A partir del circuito desarrollado en clases (Spaceship Interface, pg.33), desarrollar un botón DYI (“Hazlo tú mismx”) a partir de materiales conductivos, recordando cuál es el fundamento o principio de un pulsador o push button.
El objetivo de este ejercicio es el de explorar las características de un botón, proponer un objeto (sensor, pulsador, compuerta eléctrica) que sirva como compuerta para el circuito eléctrico, tomando el lugar del pulsador original.
Por otra parte, desarrollar una interfaz propia, obliga a ejercitar la observación y creación del objeto tecnológico.xRef. pulsadores, interruptores: https://youtu.be/eN-Itoia-Hk

C3 – 24/6/2021

Referente
Tristan Perich en el Museo de Arte Contemporáneo de la Universidad de Chile

Texto curatorial
Compositor y matemático Tristan Perich (Estados Unidos, 1982), es considerado uno de los artistas sonoros más innovadores de la actualidad, según el Museo de Arte Moderno de Nueva York (MOMA)

Esta muestra reúne tres piezas que dan cuenta de distintas interfaces entre tecnologías análogas y digitales. Con elogiosas críticas del New York Press y el Wall Street Journal, el primer caso corresponde a 1-Bit Symphony (2010) composición electrónica en cinco movimientos desarrollada mediante programación y circuito integrado. Aunque se aloja en un CD, no se trata de una grabación en el sentido tradicional, sino de una activación en tiempo real del código desarrollado por el artista. La obra requiere de la intervención del público que podrá escucharla con audífonos cada vez que la encienda.

El segundo caso corresponde a 0.01s. La primera centésima de segundo de 1 – Bit Symphony (2014), un libro de 695 páginas, que evidencia la programación oculta que da vida la composición orquestal.

La tercera pieza corresponde a Machine Wall Drawing 2015-03-19 7:00PM to 2015-04-24 7:00PM, dibujo sobre muro ejecutado aleatoriamente por una máquina, cuya acción que no se detendrá mientras dure la muestra.

Las tres piezas conviven en un mismo espacio, en una instalación que parte de la poética del código para tomar curso hacia la visualidad, la música y la objetualidad.

La muestra forma parte del programa Cruces Sonoros. Residencias Colaborativas desarrollado por Anilla Cultural MAC con el aporte de FONDART 2014 y será exhibida hasta el 24 de mayo de 2015.

MAC Parque Forestal
Santiago 2015https://player.vimeo.com/video/116989271?dnt=1&app_id=122963https://player.vimeo.com/video/129105570?dnt=1&app_id=122963

Sitio personal del artista: http://www.tristanperich.com/
Canal de Vimeo del artista: https://vimeo.com/tristanperich/videos/page:2/sort:date

*********Ejemplo desarrollado en clases: Fading***********

	// http://arduino.cc/en/Tutorial/Fading

	int ledPin = 9; // LED connected to digital pin 9

	void setup() {
	// nothing happens in setup
	}

	void loop() {
	// fade in from min to max in increments of 5 points:
	for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
	// sets the value (range from 0 to 255):
	analogWrite(ledPin, fadeValue);
	// wait for 30 milliseconds to see the dimming effect
	delay(30);
	}

	// fade out from max to min in increments of 5 points:
	for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
	// sets the value (range from 0 to 255):
	analogWrite(ledPin, fadeValue);
	// wait for 30 milliseconds to see the dimming effect
	delay(30);
	}
	}

view raw gistfile1.txt hosted with by GitHub

Material de apoyo ciclo for: http://etab.cl/clases/uchile/obj-tec/pdfs/clase_ciclo-for_processing.pdf

analogWrite() y Pulse Width Modulation (PWM) o Modulación por ancho de pulso:

El ejemplo “Fading” del programa Arduino demuestra el uso de salida analógica (PWM) para atenuar un LED. Está disponible en el menú Archivo-> Sketchbook-> Ejemplos-> Analógico del software Arduino.

La modulación de ancho de pulso, o PWM, es una técnica para obtener resultados analógicos con medios digitales. El control digital se utiliza para crear una onda cuadrada, una señal que se activa y desactiva. Este patrón de encendido y apagado puede simular voltajes entre encendido total (5 voltios) y apagado (0 voltios) al cambiar la parte del tiempo que la señal permanece encendida frente al tiempo que pasa la señal apagada. La duración del tiempo en modo encendido, se denomina ancho de pulso. Para obtener valores analógicos variables, se debe cambiar o modular ese ancho de pulso. Si repite este patrón de encendido y apagado lo suficientemente rápido con un LED, por ejemplo, el resultado es como si la señal fuera un voltaje constante entre 0 y 5v controlando el brillo del LED.

En el gráfico siguiente, las líneas verdes representan un período de tiempo regular. Esta duración o período es el inverso de la frecuencia PWM. En otras palabras, con la frecuencia PWM de Arduino a aproximadamente 500Hz, las líneas verdes medirían 2 milisegundos cada una. Una llamada a analogWrite () está en una escala de 0 a 255, de modo que analogWrite (255) solicita un ciclo de trabajo del 100% (siempre encendido), y analogWrite (127) es un ciclo de trabajo del 50% (en la mitad del tiempo) por ejemplo.

+ v/s +=
+ es un operador aritmético.
+= es una abreviación a partir de la combinación de un operador aritmético (+) con uno de asignación (=) que es usada solamente si es que hay una variable común a la izquierda y derecha del signo igual.

Por ejemplo:
int x = 1;
x += 5 // Esto es equivalente a x = x + 5
El resultado de esto es 6

Si decimos lo siguiente:
x+5, no estamos dando al instrucción de asignar el valor a la variable. Por esto en un ciclo for habrá que incluir el (=) en la actualización final:

for (int i=20; i<400; i+=60){
line(i, 40, i+60, 80);
}
// lo destacado en negrita entonces, no es lo mismo que i+60, ya que con esta expresión.

1024 v/s 256
Los pines analógicos (analogRead) manejan valores que van de 0 a 1023, es decir 1024 valores.
Los pines digitales (analogWrite) manejan valores que van de 0 a 255, es decir 256 valores.

Esto es porque los computadores trabajan en base al código binario (0 y 1), con un esquema de numeración de base dos, que quiere decir que se compone de dos dígitos que luego se van combinando (lo que usamos de manera cotidiana es base 10, es decir números 0 a 9).

Entendiéndolo desde la lógica de Arduino y no olvidando que opera en base 2, podríamos traducir los números 1 y 0 de la siguiente manera:

1 = High / On / Encendido
0 = Low / Off /Apagado

El que se ocupe base 2 para operar los computadores, tiene que ver entonces con su construcción en base a transistores que básicamente son interruptores que sólo tienen dos estados: encendido o apagado; es decir un estado que deja pasar la corriente y otro que no.
La vinculación entre el Hardware y Software de los computadores o de los microcontroladores (circuito integrado programable), se da a través de la analogía entre esos transistores que operan en los dos estados mencionados anteriormente y la unidad mínima de información se llama bit. Esta puede ser 0 o 1.
De esta manera, podemos “hablar” con la máquina física a partir de un código que se adapta a sus restricción de sólo dos estados.
Los microcontroladores tienen dentro un registro (shift register) compuesto por flip-flops o biestable (que a su vez se componen de transistores), por lo que la combinación de estados de estos, es lo que los habilita para conseguir resultados más complejos que sólo un encendido y un apagado.
Esto se manifiesta en la capacidad de bits de operación de una máquina (Arduino opera con un microcontrolador Atmega328 de 8bits y un Conversor analógico-digital / Analog to digital converter (ADC) de 10 bits).

Es por esto que cuando se usa, por ejemplo, un potenciómetro conectado a A0, esta señal eléctrica pasa por el ADC que se traduce a 1024 valores (10 bits); y por otro lado, un led conectado a D9 puede variar su brillo en valores que van de 0 a 255 (256 valores / 8bits).
Por lo tanto, para ajustar esos 1024 valores de entrada (resultantes de girar el potenciómetro) a los 256 de salida (variaciones de brillo de led), dividimos por 4 en el código, como en este ejemplo:

sensorValue = analogRead(pote)/4;
analogWrite(led, sensorValue);

Referencias:
Atmega328
Microcontrolador
Flip flop o biestable
Shift register
Registro
Bit
8 bits
Arduino 8bits and 10bits .

C4 – 1/7/2021

*********Ejemplo desarrollado en clases: Analog Read Serial*********

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

	int sensorPin = A0; // select the input pin for the potentiometer
	int ledPin = 9; // 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);
	Serial.begin(9600);
	}

	void loop() {
	// read the value from the sensor:
	sensorValue = analogRead(sensorPin)/4;
	analogWrite(ledPin, sensorValue);
	delay(1000);
	Serial.println(sensorValue);
	}

	//revisar los valores en el monitor serie o monitor serial

view raw gistfile1.txt hosted with by GitHub

Código revisado en clases: map(), constrain()

	// variable global
	int led = 9;
	int input = A0;

	void setup() {
	Serial.begin(9600);
	pinMode(led, OUTPUT);
	}

	void loop() {
	// variable local
	int ldr = analogRead(input);
	int potMap = map(ldr, 253, 912, 0, 255);
	int constMap = constrain(potMap, 0, 255);
	analogWrite(led, constMap);
	Serial.print(“ldr:”);
	Serial.print(ldr);
	Serial.print(“\|\|”);
	Serial.print(“potMap:”);
	Serial.print(potMap);
	Serial.print(“\|\|”);
	Serial.print(“constMap:”);
	Serial.println(constMap);
	delay(5);
	}

view raw gistfile1.txt hosted with by GitHub

**************************************************************
Ejercicio para desarrollar en casa: pgs.:42 a 51
Datasheet / Hoja de datos sensor de temperatura TMP36: https://www.arduino.cc/en/uploads/Main/TemperatureSensor.pdf

Componentes: Led, resistencia 220, sensor de temperatura TMP36, potenciómetro.

Código: monitor serial, Serial.begin, Serial.print, Serial.println, ciclo for, operadores, if, else if, += v/s +
**************************************************************

Referente visto en esta clase:
Peter Vogel
The Sound of Shadows website: http://vogelexhibition.weebly.com/
The Sound of Shadows video: https://vimeo.com/59829961
Página personal: http://www.petervogel-objekte.dehttps://player.vimeo.com/video/59829961?dnt=1&app_id=122963

C5 – 8/7/2021

https://youtube.com/watch?v=JisYOweWHLw%3Ffeature%3Doembed

Sensores: pdf
Desarrollo autónomo de ejercicios propuestos: https://docs.google.com/spreadsheets/d/1TYin6G1jFwluIOKyYqQgcEKi7vCttCqpfoQLiZxXq2c/edit?usp=sharing

C6 y C7 – 15/7/2021 y 17/7/2021

Multitasking en Arduino: https://learn.adafruit.com/multi-tasking-the-arduino-part-1/using-millis-for-timing

Desarrollo autónomo de ejercicios propuestos: https://docs.google.com/spreadsheets/d/1TYin6G1jFwluIOKyYqQgcEKi7vCttCqpfoQLiZxXq2c/edit?usp=sharing

Referencia Fundamentos Arduino:
https://www.arduino.cc/en/Tutorial/Foundationshttps://amormunoz.net/2019/11/13/maquila-region-4/embed/#?secret=Iz2rPvR3Sthttps://player.vimeo.com/video/196499725?dnt=1&app_id=122963Sandra de Berducci – Aruma: https://sandradeberduccy.com

.

Evaluación final

La evaluación final para este curso se hará a partir de la revisión de las bitácoras personales de cada estudiante (proceso). Estas deberán contener una detallada y organizada documentación de los ejercicios llevados en clase según lo establecido más abajo en “Características de contenidos”.

1) Características de contenidos:
– Documentación fotográfica, audiovisual y/o sonora de los ejercicios desarrollados en clase y en casa.
– Referentes artísticos o de otro tipo en formato escrito, fotográfico y/o con links que lleven a contenido en línea. Al citar referentes es importante considerar anotaciones que dejen ver cuál es el interés por la referencia en particular, así como también qué vinculaciones se pueden hacer con el propio trabajo.
– Escritos de distinta extensión que manifiesten los procesos seguidos, aspectos formales y conceptuales que puedan emerger de los ejercicios (por muy iniciales que sean).
– Documentación en detalle del ejercicio final.

2) Se evaluará lo siguiente:
– Calidad y organización del contenido según lo establecido en el punto (1) : 1.5 pts.
– Cantidad del contenido según lo establecido en el punto (1): 1.5 pts.
– Ejercicio final según la calidad y cantidad documentada de este proceso en particular 3 pts.
– +1 pt base

3) Fecha de entrega:
Lunes 16 de Agosto, 2021 hasta las 23:59.

Lista de referentes artísticos

Tristan Perich
1bit Music: 1 bit Music
1bit Symphony: http://www.1bitsymphony.com/
1bit Symphony video: https://vimeo.com/12244413
Breathing Potraits: https://vimeo.com/15259734
Microtonal Wall: http://tristanperich.com/#Artwork/Microtonal_Wall
Microtonal Wall: https://vimeo.com/45225412
Interval Studies: https://vimeo.com/9218458

Peter Vogel
The Sound of Shadows website: http://vogelexhibition.weebly.com/
The Sound of Shadows video: https://vimeo.com/59829961
Página personal: http://www.petervogel-objekte.de

Christina Kubisch
https://vimeo.com/54846163

Zimoun
http://www.zimoun.net/2013-329.html
http://www.zimoun.net/2014-20.html
http://www.zimoun.net/2009-25.html

Otros/as
Joseph Beuys: Capri Battery
Walter de Maria: Lightning Field
Golan Levin
Daniel Rozin
Lev Manovich
Manovich Lev, El lenguaje de los nuevos medios de comunicación (The Language of New Media)
Real Snail Mail Project
Jie Qi
Bare Conductive
Makey Makey
High-Low Tech Lab
Botanicalls
Bitforms Gallery
Yuri Suzuki
Exposición Talk to Me – MOMA
Nicole L’Hullier
Sofía Balbontín
Amor Muñoz
Makey Makey
Bare Conductive Board
Emovere: Intersecciones Frágiles, video documental
Rain Room

Referencias técnicas
Potenciómetros

Clases

Sitio de apoyo para clases en arte y tecnología.

Complementario IV – 2021

Sesión nº1

Sesión nº2

+
–
*
/

Sesión nº3

Referentes

ELECTRÓNICA DIGITAL

C2 – 15/6/2021

C3 – 24/6/2021

C4 – 1/7/2021

C5 – 8/7/2021

C6 y C7 – 15/7/2021 y 17/7/2021

.

Evaluación final

Lista de referentes artísticos

Sesión nº1

Sesión nº2

+–*/

Sesión nº3

Referentes

ELECTRÓNICA DIGITAL

C2 – 15/6/2021

C3 – 24/6/2021

C4 – 1/7/2021

C5 – 8/7/2021

C6 y C7 – 15/7/2021 y 17/7/2021

.

Evaluación final

Lista de referentes artísticos

+
–
*
/