Afina tu Arduino con una escala igualmente temperada eligiendo tu propia entonación

¡Liberate del La a 440 Hz!

¡Hola a todos amigos!

Espero encontrarlos muy bien en este caluroso mes de marzo.

He aquí un Arduino muy barroco al que le encanta tararear Bach. Lo interesante de este Arduino es que es capaz de afinar la escala a partir de un La medio ingresado por el usuario, con ayuda de la función tuneScale() se genera una escala igualmente temperada de 12 notas como output a partir de dicho “la” medio, recibido como input.

Para este sketch, basta cambiar el valor de la4 en la línea de código número 12.

De esta manera nuestro Arduino rompió la jaula de la entonación en “La 440 Hz” a la que se le había querido encasillar en una precoz etapa del bosquejo.

La motivación para escribir este código fue escuchar las diferencias de afinación en escalas igualmente temperadas al elegir un La medio en el intervalo [400,450]Hz como “guía de afinación”. Pues, se sabe que la afinación con un la de 440 Hz, no fue normalizada sino hasta 1995 con ISO 16, antes del cual se consideraba aceptable cualquier “la” del intervalo [400,450]Hz, siendo un La de alrededor de 430 Hz el predominante en muchas escuelas.

Función para afinar escala a partir de La medio ingresado (A4)

La curiosidad de escuchar una misma melodía con variaciones en la afinación de la escala igualmente temperada, fue motivación suficiente para escribir el siguiente bosquejo con el cual puedes elegir el valor de tu la medio o “guía de afinación” para después apreciar un fragmento del hermoso preludio No.1 en do mayor, parte del clavecín bien temperado, escrito por el maestro Bach.

A continuación se comparte el bosquejo de Arduino para su propio deleite:

////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  Tune me & I Play you Bach – Arduino Bach player with user defined tuning – tlachinolliatl@gmai.com /////
//  Visit our life Blog at:                                                                            /////   
//                         http://www.atl.travel.blog                                                         ///// 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The inspiration behind this code was to hear the differences in equal temperament tuning  varying the value of the key note A4   ////
// standardly tuned at 440 Hz with some controversy about better harmonic generation with 432 cicles per second (Hz).               ////
//  Overall, there was a tendency towards the end of the 18th century for the frequency of the A above middle C to be in the range  ////
// of 400 to about 450 Hz.                                                                                                          ////  
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// change following value for tuning the scale
double la4 = 400; // checar como puede modificar este valor el usuario durante ejecución
//recomendación: definir los tiempos, h de half: d, w, h, q
int h=250; // aquí solo se definió h, ya que para esta melodía no habrá variación de tiempo en las notas.
// cent function recieves number of cents n and returns proportion factor to use it in tuneScale function to create user tuned scale
double centFactor(int n){
    double proportion;
    double power;
    power = (double)n/12; // por no hacer el casting todo valía nepe
    proportion = pow(2, power);
    return proportion;
  }
// The Tune function
double * tuneScale(double la4){
    static double  scale[12]; // arreglo para guardar las notas generadas
    // a partir de middleA podemos obtener Do de una octava mas arriba, que es la que utilizaremos
    // por medio de la siguiente formula de Cents, introducida por Alexander Ellis en 1875
    // b = a*2^(n/1200) 
    // se obtiene cualquier nota b por medio de la nota a y el numero n de cents en el intervalo de a hasta b
    double do5;
    do5 = la4*centFactor(3);
    for (int i = 0; i < 12; i++) {
      scale[i] = do5*centFactor(i);
   }
  return scale;
  }
double * scale = tuneScale(la4); // creation of the scale from tuneScale function and predefined la4
double  C = scale[0], //definimos las frecuencias de las notas
        Cs = scale[1],
        D = scale[2],
        Ds = scale[3],
        E = scale[4],
        F = scale[5],
        Fs = scale[6],
        G = scale[7],   
        Gs = scale[8],
        A = scale[9],
        As = scale[10],
        B = scale[11], 
        PAU = 30000; //pausa

int random_tonal_row, random_note = 0;        
// array of 15 tonal rows consisting of 16 notes each
double melody[15][16] = { // consider array as [number of melody rows][number of notes on each melody row]

  // The Well-Tempered Clavier, BWV 846: Prelude No. 1 in C major (Fragment)

                   { C/2, E/2, G/2, C, E, G/2, C, E, C/2, E/2, G/2, C, E, G/2, C, E },
                   
                   { C/2, D/2, A/2, D, F,  A/2, D, F, C/2, D/2, A/2, D, F,  A/2, D, F },
                   
                   { B/4, D/2, G/2, D, F, G/2, D, F, B/4, D/2, G/2, D, F, G/2, D, F },
                   
                   { C/2, E/2, G/2, C, E, G/2, C, E, C/2, E/2, G/2, C, E, G/2, C, E} ,

                   { C/2 , E/2 , A/2 , E, A, A/2, E, A, C/2 , E/2 , A/2 , E, A, A/2, E, A },

                   { C/2, D/2, Fs/2, A/2, D, Fs/2, A/2, D, C/2, D/2, Fs/2, A/2, D, Fs/2, A/2, D },

                   { B/4, D/2, G/2, D, G, G/2, B/2, G, B/4, D/2, G/2, D, G, G/2, B/2, G },

                   { B/4, C/2, E/2, G/2, C, E/2, G/2, C, B/4, C/2, E/2, G/2, C, E/2, G/2, C },

                   { A/4, C/2, E/2, G/2, C, E/2, G/2, C, A/4, C/2, E/2, G/2, C, E/2, G/2, C },

                   { Fs/4, A/4, D/2, A/2, C, D/2, A/2, C, Fs/4, A/4, D/2, A/2, C, D/2, A/2, C },

                   { G/4, B/4, D/2, G/2, B/2, D/2, G/2, B/2, G/4, B/4, D/2, G/2, B/2, D/2, G/2, B/2 },

                   { G/4, As/4, E/2, G/2, Cs, E/2, G/2, Cs, G/4, As/4, E/2, G/2, Cs, E/2, G/2, Cs },
                     
                   { F/4, A/4, D/2, A/2, D, D/2, A/2, D, F/4, A/4, D/2, A/2, D, D/2, A/2, D }, 

                   { F/4, D/2, F/2, Gs/2, B/2, F/2, Gs/2, B/2, F/4, D/2, F/2, Gs/2, B/2, F/2, Gs/2, B/2 },

                   { E/4, C/2, E/2, G/2, C, E/2, G/2, C, E/4, C/2, E/2, G/2, C, E/2, G/2, C }
                   
                   };

void setup() {
  // put your setup code here, to run once:
  pinMode(11, OUTPUT); // fija pin 11 como salida
  Serial.begin(9600); //for freakin' printin'
}

void loop() {
  for (int i = 0; i < 15; i++) {  
    //random_tonal_row = random(0,15); // definimos renglon tonal de manera aleatoria. Para random(min,max) el mínimo es inclusivo mientras el maximo es exlcusivo
    Serial.println();
     // imprimimos en serial para rescatar posibles combincaciones interesantes al utilizar random
    //Serial.print(":");
      for(int j = 0 ; j < 16; j++){
        Serial.print(melody[i][j]);
        //random_note = random(0,17); // 17 no existe es para agregar posible pausa
        //Serial.print(random_note);
        Serial.print("\t"); // tabulador para distinguir renglones tonales de mas de dos digitos
        tone(11, melody[i][j]); //da el tono a la frecuencia de la nota del ciclo, le pasamos el renglon tonal aleatorio para las 16 notas o podemos pasarle también random note.
        delay(h);//se mantiene con la nota el tiempo definido, para tiempos mas complejos se puede hacer un arreglo similar a melody
        noTone(11); //finaliza la nota
      }
  }
  //Serial.println();
}

El código anterior pueden descargarlo en el enlace compartido a continuación:

¡Haz clic aquí para descargar Arduino_i_play_u_bach sketch!

Cualquier pregunta, duda, aclaración o recomendación acerca del código por favor háganla saber escribiendo un correo en la sección de contacto.

Aquí pueden escuchar un par de grabaciones de audio con fines demostrativos donde se compara la apreciación de un fragmento de BWV 846: Prelude No. 1 in C major ejecutado con una escala igualmente temparada en la entonación normalizada con A4 = 440 Hz seguida de una entonación de 400 Hz. ¿Cual te parece mas armónica?

Escuchar BWV 846 afinado en base a “la” medio de 400Hz

Escuchar BWV 846 afinado en base a “la” medio de 440Hz

Ejercicios propuestos:

  1. Modifica el código para que la melodía sea reproducida al revés.
  2. Modifica el código para que se reproduzcan los renglones tonales de forma aleatoria.
  3. Modifica el código para que reproduzca las notas de la melodía de forma aleatoria.

¡Saludos y feliz primavera!

Aplicaciones web educativas en R

R Shiny: herramienta en potencia para facilitar el proceso de enseñanza-aprendizaje

¡Hola a todos amigos!

En esta hermosa tarde de noviembre, aprovecharemos para platicarles un poco acerca del lenguaje de programación R y la poderosa librería Shiny, con la cual puedes diseñar tu propia aplicación web interactiva de manera increíblemente sencilla, te invitamos a conocer el poder de R Shiny probando la siguiente app, con la que podrás conocer entre otras cosas, las propiedades de los primeros diez millones de números naturales:

https://atltl.shinyapps.io/niko/


En la imagen de portada (al inicio), se muestra una grafica de pastel con cinco rebanadas, las cuales representan la proporción de los factores primos del numero 123123, los cuales son:
3, 7, 11, 13 y 41.

Si hacemos el producto de los factores primos de un numero, reconstruimos el numero original:

3 x 7 x 11 x 13 x 41 = 123123


Nota curiosa:

¿Recuerdan algo así como?

“El orden de los factores no altera el producto”

Esta oración habla específicamente de una multiplicación (producto). Los factores no son mas que los elementos que se multiplican. Pero esto no aplica para cualquier operación. Por ejemplo, en la división. Cuando no hay alteración por el orden de operado, decimos que la operación es conmutativa.


La aplicación fue bautizada con el nombre “Nicómaco”, en honor al filósofo y matemático Nicómaco de Gerasa (primero en clasificar los números naturales en abundantes, deficientes y perfectos, según la suma de sus divisores propios) te permite conocer tanto los divisores propios de un número como la suma de los mismos. Obtener los factores primos y su clasificación según de Gerasa, entre otras cosas.

Con Nicómaco, podemos introducir los conceptos de número natural, numero primo y compuesto, de divisores y factores, entre otros, de una manera didáctica, interactiva y divertida. Aprovechando la tecnología que ofrece la amplia paquetería de librerías de R y unas cuantas funciones propias.

Además, Nicómaco contiene un espiral de Ulam interactivo, con el que se puede, una vez comprendidas las definiciones de números primos y compuestos (y saber que no existe una “fórmula” para obtener el n-ésimo primo) sumergirnos en la curiosidad visual del aparente orden en el caos de distribución primal sobre estos fabulosos espirales, donde podrá controlar tanto el número de vueltas cómo el número de entradas.

Espiral con 7107 entradas, 2470 vueltas.

A continuación presentamos una intrigante animación del espiral de Ulam que se obtuvo variando el numero de entradas mientras se mantenía un numero de vueltas constante, con 10 capturas por segundo…

Aquí dejamos el script con las funciones que se utilizaron para generar gifs de este tipo.
A la función create_gif() se le indica intervalo [a,b] y numero de vueltas. Se crean (b-a) imágenes en el directorio de trabajo en el que se encuentre. Con las que puede generar un gif con ayuda de una aplicación como PicGif (OSX).

## Script que genera b-a graficas para creac gif
## Function that plots Ulam Arquimedian Spiral (Pseudo Stach spiral, Stach gives 1 turn por cada cuadrado perfecto)
prime.spiral <- function(obs,vueltas){
  vueltas <- vueltas * 2  
  data.frame(x = seq(0, vueltas * pi, length.out = obs), primo = sapply(1:obs,chkp)) %>% mutate(theta = x %% (2 * pi), r = x) %>%
  ggplot() + aes(x = theta, y = r, colour = primo) +
  coord_polar(start = - pi / 2, direction = - 1) + 
  ggtitle(expression(Espiral~r == theta)) + geom_point() +
  ylim(0, vueltas * pi) + xlim(0, 2 * pi) +
  labs(x = NULL, y = NULL)
}

create_gif <- function(a,b,vueltas){
	v <- a:b
	for(n in v){
		myplot <- prime.spiral(n, vueltas) 
		png(paste("plot", n, ".png", sep = ""))
		print(myplot)
		dev.off()
	}
}

Se recomienda crear una carpeta especial para almacenar los archivos png creados por create_gif() y asignarla como directorio de trabajo. Una vez hecho esto basta con introducir las funciones anteriores y hacer:

create_gif(num_entradas_inicial, num_entradas_final, num_vueltas)

Ejemplo:

create_gif(100, 150, 20)

crea (150-100) = 50 imágenes de un espiral de veinte vueltas. iniciando con 100 entradas y aumentando de una en una hasta 150. Con estas 50 imágenes se puede crear un gif como el mostrado arriba con ayuda de algún software que genere gifs a partir de un conjunto de imágenes, software muy común hoy en día.

¡Espero que les haya parecido interesante y les deseo lo mejor!

–Atl Tlachinolli

Como acelerar tu código de R

Fi de Euler en la mirilla
–Toc toc… –¿Quién es? –Fi de Euler…

Deja de escribir “R a la C” y aprovecha la verdadera velocidad de R

¡Mira este video si no estas de humor para leer!

Resumen

Para escribir código veloz en R tomamos en cuenta tres cosas:

  • Pruebas lógicas
  • Subconjuntos
  • Ejecuciones simultaneas de elementos de un objeto

El código que las utilice en lugar de ciclos for con condiciones if será por lo general más rápido.

Esto pasa por que R, a diferencia de lenguajes como C, no compila antes de ejecutar. Durante la compilación, la computadora optimiza el uso de la memoria para los ciclos for, es por eso que corren rápido en C, pero en R, debemos hacer uso de las Pruebas lógicas, Subconjuntos y Ejecuciones simultaneas de elementos para sacar provecho de sus características y así obtener el mayor beneficio (la mayoría de las veces).


Se optimizaron las funciones del paquete R Qurra, obteniendo una mejora notoria en tiempo de ejecución, mediante el uso de estos tres principios. También se obtienen los primeros 1000 valores de la función Fi de Euler en tan solo veinte segundos (en un equipo del 2009).

Introducción

En la entrada anterior compartimos un pequeño paquete de funciones de R, resultado de un ejercicio de iniciación realizado después de repasar la sintaxis y conceptos fundamentales. Aunque las funciones cumplieron su cometido, estábamos cayendo en una mala costumbre típica de programadores que se mudan de lenguajes cómo C a R.

G. Grolemund, autor de Hands-On R Programming, libro excelente que comparto a continuación:

https://rstudio-education.github.io/hopr/

diría que estábamos “hablando R con acento de C”…

Es decir, utilizando un montón de ciclos for con condiciones if dentro (sin tomar en cuenta que R no compila) en lugar de aprovechar las características que hacen a R tan poderoso, en una palabra, la vectorización. Se re-escribió el código del paquetito de funciones pero ahora sí, “a la R”, e hicimos luchar las distintas versiones de funciones chkprime para verificar que se haya conseguido una mejora en tiempo de ejecución.

Procedimiento

Se escribió una segunda versión del paquete de funciones R Qurra, la cual se comparte a continuación:

rqurra2.0.R

intentando evitar ciclos for con condiciones if dentro y se trató de implementar todo mediante pruebas lógicas, subconjuntos y ejecución simultánea de elementos.

Se escribió la función fight para hacer competir a la familia de funciones chkprime, tomando el tiempo que demoran en hallar los primos en los intervalos:

[1,1000] , [1,10000] y [1,100000]

y observar las mejoras en tiempo de ejecución.

La función regresa un data frame listo para utilizarse para graficar en ggplot (paquete de R).

se escribió la función phi que recibe n natural como argumento y regresa phi(n) donde phi es la función Fi de Euler, función de suma importancia en teoría de números y el sistema de cifrado RSA.

Resultados

En este video se muestra como correr el script y utilizar las funciones, así como resultados y conclusiones:

Gráfica de comparación de velocidad de familia de funciones chkprime* (realizada con ggplot2 y data frame que regresa la función fight), observe que a pesar de que el tiempo de ejecución de la familia es muy similar para una longitud de 1000 (punto de partida), a medida que seguimos avanzando observamos que la función chkprime “a la C” (en rojo) se empieza a quedar atrás y es rebasada incluso por la chkprime.r (en verde) que está muy poco optimizada (por no decir otra cosa).


Comparación de tiempo de ejecución entre familia de funciones que encuentran primos
Comparación de velocidad de la familia de funciones chkprime

Con ayuda de la función testrlpr reloaded, la cual revisa si un par de números son primos relativos entre si, se diseñó la función phi, que regresa el valor de la función Fi de Euler, es decir, le pasas un natural como argumento y te regresa la cantidad o cardinalidad del conjunto de primos relativos de ese número que sean menores que el mismo. Se obtuvieron los primeros diez mil valores de la función para realizar la gráfica siguiente.

Gráfica de primeros 10000 valores de función Fi de Euler, creada con ggplot.
(obtenidos en aprox. 110 minutos con la función phi en cpu Intel i5 2.4Ghz con 4 GB de RAM)


Gráfica de primeros 10000 valores de la función fi de Euler
La función fi se relaciona con el sistema de cifrado RSA, el cual ocupa primos enormes para el encriptado

Conclusiones

A pesar de todo, no hay que pensar que es malo usar ciclos for en R, pero recordar este par de consejos podría ser útil:

  1. Si observas un ciclo for con un if dentro, lo mas seguro es que puedas remplazarlo con operaciones de subconjuntos y condiciones lógicas y este será mas veloz.
  2. Si es necesario utilizar un ciclo for, trata de minimizar su bloque de código para que se realice lo menos posible dentro del mismo.

En R la mayoría de las funciones están vectorizadas, por lo que al aplicarlas a un vector se hace a todos los elementos del vector al mismo tiempo, evitando demoras, mientras un loop for lo haría uno por uno (y sin el boost que le daría la compilación), esta es la causa por la cual es preferible evitarlos de ser posible, en la mayoría de los casos.

Una parte muy importante de la programación en cualquier lenguaje es la reutilización de código. En la ciencia de datos, es prudente aprovechar también cualquier información ya existente antes de generarla uno mismo, así se logra completar proyectos en menor tiempo. Por ejemplo, seguro en algún lugar en la red podemos encontrar los primeros diez mil (o más) valores de la función Fi de Euler. Nosotros hubieramos podido ahorrar los 110 minutos que se tardó la función phi en hallar los primeros diez mil valores que utilizamos para la gráfica. También pudimos haber utilizado alguna función para checar primos disponible en la red en lugar de perder tiempo escribiendo las nuestras… Pero la idea de escribir estos pequeños paquetes de funciones, es que nos sirva de ejercicio para: acostumbrarnos a la sintaxis de R, entender el manejo de las estructuras de control que ofrece R para después poder comprender, modificar y unir cualquier código que hallemos y que el tiempo que perdimos en escribir estos “paquetitos de funciones” se recupere a la hora de solucionar las tareas de código del futuro. Lo que queremos decir es; si todavía no te sientes como un experto de R, es mejor que escribas unas cuantas funciones por ti mismo antes de querer reutilizar código ya existente. Así cómo crear algunos vectores, matrices, listas y marcos de datos para acostumbrarse a su manejo y filtrado.

¡Los mejores deseos para todos ustedes!

– Atl Tlachinolli

Programación en R

Los primeros cuatro primos se encuentran entre el uno y el diez. Si los sumas, el resultado es 17

Números: primos, primos relativos perfectos y amigos

Aprendiendo R con curiosidades matemáticas

Preámbulo

¿Qué tal Tlachinollis?

En lo personal, por acá se podría decir que somos mas adeptos de ANSI C pero debemos comentar que nos estamos enamorando de R. Este poderoso, intuitivo y eficaz lenguaje, te permite aprender a programar evitando conceptos complicados como declaración de variables, apuntadores y asignación de memoria, es la herramienta perfecta para el estudiante de ciencias e ingenierías o para cualquiera con una curiosidad inherente por los números.

Confesaremos ser novatos en R, lo poquito que hemos escrito son unas funciones muy sencillas para el manejo de tablas generadas por sistemas de rastreo deportivo ZXY (ZXY Sport tracking systems), las cuales pueden hallarse aquí:

R ZXY Sport Tracking data edition tools

esto ya fue hace tres años y a hachazos, sin saber mucho de R se fue implementando en unos tres días por que así fue el plazo de trabajo, hicimos lo que se pidió… pero digamos que sin aprender de forma adecuada, o al menos como hubiésemos deseado en caso de haber tenido mas tiempo.

Ahora estamos desempolvando o más bien re-aprendiendo con paciencia y con ayuda de un par de libros excelentes para iniciarse, los cuales se encuentran en la red en varios sitios, aquí les dejo la lista con los enlaces por si les interesa:

La mejor manera de aprender es con las manos a la obra. Después de refrescarnos un poco de la sintaxis de R para quitarnos el chip ANSI C, algunos resultados fueron las siguientes funciones que sirven para revisar curiosidades matemáticas como números primos, números perfectos, números amigos y primos relativos, que son funciones muy básicas que presentan un buen ejercicio para el aprendizaje de un nuevo lenguaje de programación, además pueden llegar a ser de utilidad para estudiantes de cursos cómo fundamentos de álgebra . En fin, quisimos compartirlas, esperamos que a alguien le sean útiles.


Código

A continuación se muestra el código fuente y explicaremos como pueden usarse las funciones para pasar un buen rato.

¡Hágalo usted mismo!

Tan solo copie y pegue el siguiente código en la consola de R y presione introducir, con lo que estará listo para jugar con las funciones :

# R Qurra packet
# functions to test primes, relative primes, perfect and friend numbers
# This package may be useful for undergraduate students in Fundaments of Algebra courses
# where you are usually introduced deeply into this concepts and their properties
# tlachinolliatl@gmail.com
#########################################################################

# Function that checks for primality
# returns TRUE in case n prime, FALSE instead
# try checking primality for first 100 natural numbers like this:
# > chkrprime(1:100)
chkprime <- function(x){
	primo <- vector()
	j <- 1
	for(n in x){
		primo[j] <- T
		for(i in 2:(sqrt(n))){
			if(n%%i==0 && n!=2){
				primo[j] <-F
				break
			}
		}
	j <- j+1		
	}
return(primo)
}
# Function that returns a list of proper divisors of a given set of numbers
# divp stands for (div)isores (p)ropios
#
divp <- function (x){
	k <- 1
	lista <- list()
	for(n in x){
		divisores <- vector()
		j <- 1	
		for(i in 2:(n/2)){
			if(chkprime(n)) break # not looping if n is prime
			if(n%%i==0){
				divisores[j] <-i
				j <- j+1
			}
		}
	lista[[k]] <- c(1,divisores)
	k <- k + 1			
	}
return(lista)
}

# Function that checks if a pair of numbers are friends between them
# if friends, testfrnd returns TRUE, else it will return FALSE
#
#  Muhammad Baqir Yazdi found the pair (9363584,9437056) in the XVII century 
# Checking this pair took a couple of minutes for my old Intel Core 2 Duo at 2.13 GHz
# Try with  (1184, 1210) for faster computation
testfrnd <- function(x,y){
	divpx <- unlist(divp(x)) # is the same divp(x)[[1]]?
	divpy <- unlist(divp(y))
	sumx <- sum(divpx)
	sumy <- sum(divpy)
	if(sumx==y && sumy==x){
		return(T)
	}else return(F)
}
#Function that checks if two numbers x,y are relative primes between them
# i.e. MCD(x,y) = 1 i.e. they have no common proper divisors between them !=1
# if relative primes, testrprime returns TRUE, else it will return FALSE
testrlpr <- function(x,y){
	divpx <- unlist(divp(x))
	divpy <- unlist(divp(y))
	if(length(divpx)==1 && divpx[1]==1 || length(divpy)==1 && divpy[1]==1){
		return(T)
	}else
	if(any(divpx[2:length(divpx)]==divpy[2:length(divpy)])){
		return(F)
	}else return(T)
}

#Function that checks if a number is perfect
# i.e the sum of his proper divisors (including one) add up to the same number
# Example: proper divisors of 6 are 1, 2, 3 wich sum 1+2+3 = 6 the number itself
# RETURNS TRUE IF NUMBER IS PERFECT FALSE INSTEAD 
# Find the perfectos between 1:10000 with a crazy R loop like this:
# > for(i in 1:10000) if(testprfc(i)) print(i)
# be patient it may take a while
testprfc <- function(x){
	divpx <- unlist(divp(x))
	sumx <- sum(divpx)
	if(sumx==x){
		return(T)
	}else return(F)
}


En el siguiente video se muestra como sacarle un poco de jugo a estas funciones desde la consola de R, lo cual puede ser una práctica para cualquiera que se esté iniciando en este lenguaje:

Si tienes comentarios para mejorar el código o algún consejo de R relacionado con las funciones anteriores será muy apreciado.

¡Nos despedimos con los mejores deseos!


De los números he aprendido:

“Si quieres llegar a ser perfecto comienza por ser tu propio amigo”

– E.P. del Cerro


Bracalete de Coralillo

“El ombligo” – Jerald

Primer cuento de la serie, “La escalera infinita” de E.P. del Cerro.

Acerca del autor

E.P. del Cerro es un poeta y escritor mexicano independiente que realiza su obra cerca de Xico, Veracruz. Autodidacta y misterioso, se le puede encontrar al pie de la montaña, bajo la sombra de los encinos, donde escribe durante horas sus andanzas y recuerdos de la juventud, en un intento de hacer conciencia y poder servir a generaciones al porvenir. Dicen que habita en una cueva cercana de la zona, en un terreno muy escabroso en el que es complicado el ingreso incluso para los adeptos a la exploración salvaje.

La escalera infinita

E.P del Cerro ha estado escribiendo ya desde hace unos 10 años y la idea principal en su mente es un libro llamado “La escalera infinita” donde se compilan distintos relatos llenos de fantasía, magia y poderosos alcaloides. Desde la indefenso THC hasta el maligno Tolueno. “Bracalete de coralillo” es tan solo uno de las numerosas aventuras de este intrincado autor. Lo recomendamos ampliamente. A continuación agregamos un fragmento de el mencionado cuento y un link para descargar el archivo pdf con la historia completa.

Bracalete coralillo (fragmento)

El cielo estaba despejado. Por un instante la mañana pareció estar suspendida en el tiempo… no se escuchaba ningún ruido alrededor. El sol se elevaba majestuoso y esparcía seda dorada entre los verdes cerros, múltiples aves se regocijaban con su calor mientras acicalaban sus plumajes tornasol. Más a lo lejos se hallaban unas ardillas recibiendo el baño vital que les ofrecía el benévolo astro. Todo estaba lleno de una gratitud y alegría que podía ser apreciada inclusive con los sentidos adormecidos.

Era una dicha estar presente en ese momento. Un mundo lleno de impredecibles instantes que mantienen el suspenso. En cada paso… en cada respiro.

Con los años aprendes a dejarte llevar… a abandonar la imagen que tienes de ti mismo y permitirte ser moldeado por los acontecimientos que experimentas en esta incesante marea de emociones que nos gusta llamar vida. – E.P. del Cerro.

Link de descarga

Click aquí para descargar cuento competo “Bracalete de Coralillo.pdf”

Espero que tengan un poco de tiempo para darle una leída y nos comenten que les pareció. Saludos.

Gráfica y regresión local de temperatura interna LG M2762D

Se observa un comportamiento logarítmico con una posible asíntota en y = 35ºC tras dos horas de funcionamiento después de la reparación de Pierre y Atl mod.

Graficando datos capturados por sensor LM35 en Arduino Monitor Serie

Mah xipano

Problema

Insatisfechos con las gráficas obtenidas por el Arduino Serial Plotter, con sus raras escalas y repleta de interferencias generadas por las variaciones de voltaje (capturadas por el sensor LM35 durante los registros), decidimos hacer nuestras propias gráficas en R.

Resumen

Se modificó nuestro bosquejo de Arduino, de modo que lo único que se imprimiera en el Monitor Serie fueran pares ordenados X1, X2.
Donde X1 = segundos transcurridos y X2 = temperatura registrada en tiempo X1.
Después se realizaron tres pruebas, dos con un tiempo de 3600 segundos y una de 7200 (con distintos aparatos: Apple Tv, Philips DVD, Wii U), durante las cuales se registraron las medidas de temperatura por segundo con el bosquejo mencionado, todas las pruebas fueron realizadas con una luz de fondo al 100%. A continuación se copio la información del Monitor Serie y se guardó en un archivo de texto con extensión .csv para su futura exportación a R en donde se realizaron las graficas respectivas junto con una regresión local de el paquete lattice encontrado en librería de R.

La televisión pudo utilizarse por un periodo de 2h sin alcanzar los 35ºC (temperatura máxima de funcionamiento recomendada en el manual de usuario oficial de LG).

Existen diferencias en el comportamiento del aumento de la temperatura interna dependiendo del equipo que se esté utilizando o quizás dependiendo de la naturaleza de las imágenes presentadas durante las pruebas, aparentemente, el menor aumento de temperatura por unidad de tiempo se obtiene mediante transmisión por RGB observando videos en youtube, mientras el mayor se observa jugando Wii U conectado mediante HDMI. Dicho esto, aclaramos que la afirmación del párrafo anterior sigue siendo válida en ambos casos.

Requerimientos

  1. Computadora, Arduino, Sensor LM35, R.
  2. Bosquejo de Arduino para capturar datos:
    Bosquejo
  3. Archivo de datos capturados en extensión .csv, se obtiene con bosquejo anterior
    Ejemplo
  4. Script de R para graficar datos con regresión local:
    Script

Procedimiento

Con el sensor LM35 instalado en el interior de la TV, aislado y apartado lo suficiente para evitar cortos circuitos (ver esta entrada para mas información). Se importó el nuevo bosquejo a nuestro Arduino, el cual se colocó en la parte posterior del televisor de manera que pudieramos conectar el LM35 (hicimos una perforación en la parte trasera de la tele para dar salida a los cables del LM35 instalado adentro) y se realizaron tres experimentos para los cuales se mantuvo abierto el Monitor Serie de Arduino y al finalizar cada experimento se copio la información del Monitor en Serie y se pasó a un archivo de texto para guardarla con extensión .csv para después importarlas a R.

Se obtuvieron estos tres archivos:

https://www.mediafire.com/folder/23vzusy97i6eg/

Después se realizó el script de R que se presenta a continuación:

  
#R Plot - Graficando regresión local a partir de medidas con interferencia
#Medidas de temperatura de interior de TV LG m2762d tomadas con transistor LM35
#instalado en su interior, datos capturados con Arduino.
#Bosquejo de Arduino, apunta un par ordenado x,y donde x = segundo, y = temperatura
#en el monitor en serie. Uno por línea, estos datos fueron después copiados y pegados
#En un editor de texto y guardados con extensión .csv para su futura manipulación en R
#EL SIGUIENTE SCRIPT ESTÁ DESARROLLADO PARA GRAFICAR LOS DATOS CAPTURADOS JUNTO CON UNA
#REGRESIÓN LOCAL. LA FINALIDAD ES LA PRESENTACIÓN DE UNA CURVA DE TEMPERATURA
#CONTRA TIEMPO PARA ESTE EQUIPO DESPUÉS DE LA REPARACIÓN DE PIERRE Y MODIFICACIÓN ATL
#CON EL OBJETIVO DE PREVER FUTURAS PROBLEMÁTICAS EN LA PLACA DEL INVERSOR
#COMO USAR:
#
#------------------------------------------------------------------------------------
#Importando archivo:
#/Users/Administrador/Desktop/prueba_temperatura_8_jul_appletv
plotdata <- read.csv("directorio_de_archivo/archivo.csv")


#Graficando con regresión local (LOESS) con ayuda de lattice (librería de R)

#importando libreria de lattice
library(lattice)


#panel function pa' paintar pimped líneas
panel_fn <- function(x, y, ...)
{
    panel.xyplot(x, y,col = "cornflowerblue" ...)
    panel.xyplot(x, y, type = "smooth", col = "gray33", lwd ="4", ...)
    #panel.abline(v = 3600, col="darkorange")
    panel.abline(h = 35, col="orangered")
	
}


#plotting you menso!

xyplot(plotdata$X2 ~ plotdata$X1, panel = panel_fn, pch=".", cex = "2",xlab = "Etiqueta X", ylab = "Etiqueta Y" , main = "Título principal", xlim=c(0, max(plotdata$X2)), ylim = c(20,40) )



  

Basta sustituir <directorio_de_archivo/archivo.csv> por la ruta hacia tu archivo en la primera línea del código y correr el script para obtener la gráfica.

Resultados

Prueba 1. Apple TV, aprox 60 minutos

Línea naranja-roja horizontal en y = 32ºC. Supuesta asíntota según entrada anterior bajo una prueba por RGB de 1 hora 40 minuots. Aquí ya la está alcanzando en 1 hora. ¿Es RGB más cool?

Prueba 2. Philips DVD, aprox 60 minutos

Se puede apreciar que a pesar de que la Prueba 2 inició a una temperatura menor que la Prueba 1, se alcanzó la misma temperatura al cabo de 1 hora.
¿A qué se debe?

Prueba 3. Wii U, aprox 2 horas

Aparentemente se calienta mas rápido con Wii U. Podemos ver que en menos de una hora ya se rebasó la “asíntota” de 32ºC. También podemos ver que no parecen existir interferencias, debe ser por el convertidor AC/DC del Wii U.
¿Bonito no?

Conclusiones

Todavía no estamos seguros de nada en específico pero podríamos afirmar lo siguiente:

O utilizar la televisión por RGB es lo que menos genera estrés por temperatura y utilizarla con Wii U es lo que más.

Ó cada vez se está calentando más rápido nuestra televisión.

Debemos mencionar que en la prueba de 2 horas se comenzó a percibir un olor peculiar cómo a plancha caliente alrededor del segundo 6000. No era un olor a quemado, pero tampoco muy agradable. Pienso que quizás es buena idea dejar reposar la PCB dentro de agua destilada después de la reparación y limpieza (nosotros utilizamos alcohol isopropílico para limpiar después de las reparaciones) para eliminar cualquier residuo químico que pudiera despedir gases no deseables.

Secuela

En un par de semanas más, dándole uso a nuestra televisión vamos a abrirla nuevamente para ver el estado de nuestra PCB del inversor (pieza reparada) y de una vez crearemos un manual con instrucciones para realizar la reparación de Pierre y la modificación de Atl paso por paso, reuniendo las recomendaciones y advertencias que se conocieron durante la experimentación documentada en este, nuestro Blog de Vida.


Por otro lado, me parece intrigante la belleza que presentan los patrones de interferencias en las pruebas de Apple Tv y Philips DVD, y estamos pensando en traducir algunas secciones superiores de estas interferencias para escucharlas en forma de música.

Ahí hay un mensaje oculto…

¡Saludos amigos!

–Atl Tlachinolli

DivX hack en LG M2762DL (Norte América).

¿Puede EAX31549701 con IC LGE1864C-LF reproducir video desde USB “service only”?

¿Por que no es posible hacer este “hack” en equipos fuera de la Unión Europea?

A LG Electronics no le bastó con hacer inversores defectuosos cómo el PLLM-M901D y violar los acuerdos de las licencias de software libre GPL y LGPL en versiones de firmware ( software de la tele) del 2009 al 2011. Sino que además decidieron vender la peor versión de FLATRON m2762d en América, Asia y Australia (la triple A).

Sin mencionar que las actualizaciones que lanzaron no eran, por lo general, para parchar problemas del firmware sino para bloquearlo más, de modo que los usuarios fueramos incapaces de modificar opciones para las cuales, antes de la actualización, se tenía un acceso sencillo.


En la sección de secuela de la entrada anterior, mencioné que quizá era posible modificar el televisor desde el menú de servicio para obtener lectura de imágenes, música y video desde la entrada USB en la parte posterior que dice “service only”. Y en efecto, esto ha sido logrado anteriormente pero solo en televisores europeos…

La razón por la cual no funciona en modelos de otros continentes es por que la placa principal de audio y video es en esencia diferente para los modelos europeos. En la siguiente imagen vemos una comparación de ambas:

Audio/Video Main board americana EAX31549701 (izquierda) y su prima europea EAX61341504 (derecha).

La diferencia mas problemática en el caso de querer meter el firmware europeo en una americana es el mismísimo chip principal, la europea trae un  LMD9201A-LF-SD y la americana un LGE1864C-LF, a continuación se muestra una comparación de los dos IC’s:

XD ENGINE EUROPEO (IZQUIERDA), XD ENGINE AMERICANO (DERECHA) AMBOS PARA LG TV M2762DL

Esta parece ser la causa principal (seguro otros IC’s distintos ayudan) de que la televisión quede inservible al intentar “flashear” el firmware europeo en una televisión de otro continente y también por la cual no es fácil encontrar instrucciones para esta modificación en nuestros modelos, ya que seguramente el chip no es tan bueno (su velocidad) como para reproducir video desde la USB.

Así que dejaremos esto por la paz y pues si alguien sabe cómo lograr utilizar el USB en una FLATRON m2762dl americana por favor explíquenos.

Debo mencionar que en LG se negaron a proporcionarme un firmware actualizado para este equipo, así como cualquier información al respecto, como muestro en la siguiente captura:

LG no guarda firmware descontinuado ni aporta información acerca de este.

Así que cualquiera que haya bloqueado su m2762d intentando activar reproducción de video por USB por medio de firmware europeo en un aparato americano (o cualquier otro motivo), no cuenten con la ayuda de LG para regresar su equipo al funcionamiento. Tendrán que cambiar todo el AV mainboard… o que algún buen samaritano proporcione el firmware original (yo podría hacerlo si es que alguien lo necesita para el modelo en cuestión) e intentar flashearlo por Serial cable (RS232).

La única versión americana de firmware que pude encontrar en la web fue el 4.30.01 y no estoy seguro si sea compatible para m2762dl, si alguien me puede ayudar con esto, aquí comparto el firmware americano de LG que hallé disponible:

https://www.mediafire.com/file/538ic7a5wqzj1ry/US_IC102_V4.30.01_flash.epk

¡Saludos!