Tutorial#2.01# - Matlab Mobile para Android

En esta ocasión, con motivo de los tutoriales de MATLAB, quiero presentaros esta aplicación para Android llamada "MATLAB Mobile" y que como podréis intuir, esta diseñada por Mathworks.

Con MATLAB Mobile podemos acceder desde Android a Mathworks Cloud o a tu ordenador directamente para usar MATLAB. Asi es posible realizar algunas funciones básicas de MATLAB desde tu terminal Android.

Características:

Así pues, entre las funciones que podemos usar remotamente con MATLAB Mobile desde Android son:

• Acceder a la línea de comandos de MATLAB.
• Ejecutar Scripts.
• Visualizar resultados de manera numérica o gráfica.
• Usar comandos memorizados en el historial de MATLAB.
• No se puede crear Interfaces Gráficas de Usuario ( GUIDE ).
• No se puede realizar interacciones con figuras 3D.

Por otro lado, se trata de una versión ligera de MATLAB, con lo que las limitaciones son evidentes. No es posible usar herramientas de procesado de señal, por ejemplo. Tampoco podremos acceder al editor de MATLAB y tampoco dispondremos de SIMULINK ( lastima! ).

Requisítos:

 

Los requisitos para esta aplicación son:

• Requiere Android 2.3.3 o superior.
• Para poder utilizar la aplicación requiere disponer de una licencia profesional o académica de MATLAB R2012a o superior, o bien una licencia de la versión de estudiante de MATLAB R2012a o superior.
• La instalación de la app mediante el fichero APK requiere la activación de la opción "Orígenes desconocidos" dentro de Ajustes>Aplicaciones.

Instalación:

Para realizar la instalacion de MATLAB Mobile, previamente deberemos tener instalada la version de MATLAB 2012a o superior con su licencia correspondiente.

Una vez instalado MATLAB en tu PC ( si no lo tenias previamente, claro! ) se debe instalar un complemento llamado "Connector", tal como se muestra en el siguiente tutorial aportado por Mathworks.

Básicamente, si disponemos de MATLAB R2013a el software está ya instalado, sino se debera descargar e instalar.

Para comprobar si MATLAB tiene el software "Connector", basta con escribir el siguiente comando:

           connector 

Y por ultimo, nos queda descargarmos "MATLAB Mobile" desde Playstore de Android.

Configuración:

Para habilitar el remoto acceso a la sesion de MATLAB basta con usar el siguiente comando:

           connector on

La primera vez que introduzcamos el comando en MATLAB, nos solicitará una contraseña de acceso 

Cuando quedamos desactivar la utilización de MATLAB Mobile, bastará con picar lo siguiente:

           connector off

Una vez hayamos activado "Connector" en nuestro Matlab, se nos muestra la información que define nuestra conexion, como se muestra a continuación:

Depues, solo faltaria introducir estos datos en la aplicacion de MATLAB Mobile, en el apartado de "Add a Computer", en el que nos solicitara la dirección IP y la contraseña previamente introducida en "Connector":

Una vez realizado esto, ya esta listo para funcionar.

Prueba:

Ahora vamos a probar el funcionamiento del sistema. 

Por un lado tengo mi MATLAB R2013a abierto en mi PC, y por otro lado tengo mi Smartphone Samsung con MATLAB Mobile.

Primero pruebo comandos sencillos para ver el comportamiento. Voy a definir una funcion ( que describo abajo) y a graficarla desde mi smartphone:

        >> x = 0:pi/30:2*pi;         %  x vector, 0 <= x <= 2*pi, increments of pi/30
 >> y = sin(3*x);             %  vector of y values
 >> plot(x,y)                 %  create the plot
 >> xlabel('x (radians)');    %  label the x-axis
 >> ylabel('sine function');  %  label the y-axis
 >> title('sin(3*x)');        %  put a title on the plot

Y mientras vamos introduciendo cada linea, podemos comprobar como nuestro MATLAB va recibiendo los datos. 

Smartphone:

Historial en MATLAB Mobile:

Gráfica en MATLAB Mobile :

  

Matlab en PC:

Conclusiones:

Como primera impresión me parece una herramienta que, si bien tiene ciertas carencias ( no disponemos de Simulink ni de GUIDE.... ) si que ofrece una buena persperctiva de futuro en cuanto a la interconexion entre dispositivos con MATLAB.

Como punto negativo he de decir que he encontrado algunas dificultades para realizar la conexión de mi MATLAB Mobile en ciertos puntos, pero nada grave. Tambien cabria resaltar que las funciones de sensores no estan habilitadas para MATLAB de versiones inferiores a 2014a.....

Y como punto positivo, un entorno gráfico de trabajo bastante cómodo y compacto y muchas posibilidades de futuro.

A términos generales, lo encuentro una herramienta bastante buena.

A matlabear pues!!!!!!

Tutorial#1.01# - Termistor con Arduino

En este proyecto nos proponemos a monitorizar la temperatura de algun medio con un termistor tipo NTC y usando una plataforma Arduino.

Primeramente se hará un repaso de la teoria de funcionamiento del termistor y el por qué de su configuracion.

Teoria Termistor:

El termistor es uno de los elementos electrónicos mas flexibles y usados en la electrónica.

Se trata de un resistor cuyo valor varia de manera significativa con la variación de la temperatura de

una manera mayor que las resistencias comunes.

Por el tipo de encapsulado y formato, existen una gran variedad de termistores, tal como se muestra en la siguiente imagen y su seleccion dependera del uso, la precision, etc:

Asi pues, segun su tecnologia también se diferencian diferentes tipos de termistores, los mas comunes son los llamados NTC ( Negative Temperature Coefficient ) y los PTC ( Positive Temperatue Coefficient ).

Cuando la temperatura aumenta, los tipo PTC aumentan la resistencia, y en los NTC a la inversa, es decir, disminuye. El simbolo electrónico del termistor es el siguiente:

 El funcionamiento y las ecuaciones que gobiernan el termistor pueden ser consultadas en el siguiente enlace:

Termistor - Wikipedia

Termistor - Teoria

Esquema del circuito:

El esquema del circuito es bastante sencillo. La idea básica es la configuración del "divisor de tension", que se trata de una configuración de circuito eléctrico.

El circuito en si es como se muestra a continuación:

 Asi pues, teniendo en cuenta que la salida Vout sera la señal que procesara Arduino en su entrada analogica, podemos diseñar nuestro circuito eléctrico. En este caso se ha realizado con el software "Fritzing", que resulta bastante cómodo para nuestro proposito.

En este caso se ha utilizado una resistencia R2 de 10 k ya que mi termistor es de aproximadamente 10 k. Para este proyecto he usado un termistor extraido de un dispositivo electrónico reciclado, asi que tuve que realizar las medidas oportunas para obtener los datos característicos del termistor, ya que trabajé sin datasheet ( se explicará ), pero es recomendable comprar uno que este documentado. 

Un ejemplo es este termistor de Epcos a 10 K. Si observamos el datasheet, nos viene totalmente documentado el valor de Beta y demas valores, asi como el comportamiento del temistor segun la temperatura.

 Asi pues, el esquema de montaje electrico es como se muestra a continuación:

Cálculos y medidas:

Primeramente,  debemos saber el valor de Beta del termistor que vamos a usar, que habitualmente será proporcionado por el fabricante en su datasheet junto con demás valores de interés. Si es este nuestro caso, pasaremos al apartado de "Formulas".

Si, en cambio, os pasa como a mi, que reciclando algunos componentes obtuve un termistor para mi proyecto, deberemos hacer algunas medidas previas, que que el calculo de Beta se obtiene con las temperaturas de 2 extremos, en nuestro caso 0º y 100 º.

Beta = ( Log ( Rt2 / Rt1 ) ) / ( ( 1 / T2 ) - ( 1 / T1 ) )

Donde 

T1 = Temperatura medida en Kelvin ( aprox 0 º )

T2 = Temperatura medida en Kelvin ( aprox 100º )

Rt1 = Valor de Resistencia a T1

Rt2 = Valor de Resistenica a T2

Con lo que una vez realizadas las medidas, se introducen en la formula de Beta. En este caso podriamos introducir los valores medidos y realizar los calculos o introducir el valor de Beta directamente.

Código de Arduino

/* 

Termistor NTC con arduino

Monitorizacion de temperatura con sensor NTC sobre plataforma
Arduino.

Algortimo de calculo de temperatura en:
http://en.wikipedia.org/wiki/Thermistor

En este proyecto usamos una Beta conocida, de lo contrario se podría calcular
de la siguiente maneta:

             Beta=(log(RT1/RT2))/((1/T1)-(1/T2));

*/

#include <math.h>
#include <stdio.h>

//  Datos para las ecuaciones algoritmo termistor

int analogPin=1;     // [V]       Entrada analogica de medida del termistor
float Vin=5.0;       // [V]       Voltage de entrada en el divisor de tension
float Raux=10000;    // [ohm]     Valor de la resistencia del divisor de tension
float Rntc=100000;   // [ohm]     Valor de resistencia del termistor (NTC) a 25ºC
float T0=298.15;     // [K] (25ºC)
 
float Vout=0.0;      // [V]        Voltage given by the Voltage-Divider
float Rout=0.0;      // [ohm]      Resistencia actual del Termistor (NTC)

float Beta=0.0;      // [K]        Parametro Beta
float Rinf=0.0;      // [ohm]      Parametros Rinf
float TempK=0.0;     // [K]        Temperatura de salida en grados Kelvin
float TempC=0.0;     // [ºC]       Temperatura de salida en grados Celsius
 
int iCont;            // Contador de ciclos, para calculo de temperatura media
float cTemp1;         // Variable temporal para acumular las temperaturas leidas
 

//  Declaracion de entrada analógica

int analogPin1 = 1;   // [Boole]  Entrada analógica 1 de Arduino 


//-----------------------------------------------
//---------------   Configuracion   -------------
//-----------------------------------------------

void setup() {
  // Puerto Serie
   Serial.begin(115200); 
   
   // Configuramos el pin del Arduino en entrada
   pinMode(analogPin, INPUT);
 
  // Parametros de calculo
   Beta = 4380;
   Rinf=Rntc*exp(-Beta/T0);
}
//-----------------------------------------------
//------------  Fin Configuracion     -----------
//-----------------------------------------------


//-----------------------------------------------
//--------------- Loop Principal ----------------
//-----------------------------------------------

void loop()    // Bucle de programa principal
{

  double TempC;
  double temp = Termistor(analogRead(1));  // Read sensor
  TempC=temp;
  Serial.print("Celsius:");
  Serial.print(TempC,1);
  Serial.println("");
  delay(1000);
}  
 
//-----------------------------------------------
//-----------Fin  Loop Principal ----------------
//-----------------------------------------------
 

//************************************************
//********* Funcion Termistor lectura   **********      
//************************************************
  
double Termistor(int RawADC) {
    // Cálculo del valor de la resistencia termistor (NTC) a través de Vout
    Vout=Vin*((float)(RawADC)/1024.0);
    Rout=(Raux*Vout/(Vin-Vout));
 
    // Calculo de la temperatura en grados Kelvin
    TempK=(Beta/log(Rout/Rinf));
    // Calculo de la temperatura en grados Celsius
    TempC=TempK-273.15;
    // Almacenamos la temperatura (Celsius) actual para después obtener la media
    cTemp1 = cTemp1 + TempC;
    // Hacemos una pausa de 10 milisegundos   
    delay(10);
}

//************************************************
//******* Fin Funcion Termistor lectura   ********      
//************************************************

Ahora, solamente quedaria comprobar el margen de error con el que funcionaria nuestro termistor, y listo!!

The Ben Heck Show

Guteng tag!!

Rulando por internet buscando info util sobre un proyecto de impresion 3D he topado con una especie de serie de capitulos llamados "The Ben Heck Show".....y solo os puedo decir que me gusto mucho. Bastante.

Ben Heck Show

Se trata de una show en el que el tal Ben Heck se dedica a diseñar y construir diferentes propuestas o proyectos en su laboratorio.......y la verdad, muy bien documentados y con muchos consejos muy utiles!!!

Asi que no dejeis de buscar sus videos porque son bastate interesantes

Saludos!!!

FRANCO RECCHIA

METROPOLITAN ARTIST

Curioseando por ahí encontré el otro dia la web de este artista "metropolitano" que me llamó mucho la atención.....y es que hacia maquetas de ciudades con......¡circuitos electronicos y piezas de PC!

Se trata de circuitos electronicos reciclados por el artista italiano Franco Recchia, natural de Verona y nacido en 1957, gran apasionado de la tecnologia en sus multiples formas.

Viendo estos resultados......¿quien no piensa preguntar donde esta la agencia de alquiler de viviendas en esta ciudad? .

El enlace a la web de este artista es:

http://www.francorecchia.it/

¡Que aproveche!

Intel Galileo ya esta aquí!

November ist gut so!

Intel acaba de sacar al mercado una placa de desarrollo, la primera que crea integramente dicho fabricante de circuitos, y además, parece que lo hace por todo lo alto.

Se han guardado este "as" bajo la manga y de repente.....zas, ahi lo teneis!!

 

 Vista frontal de Intel Galileo

 Vista trasera de Intel Galileo

¿A que se os hacela boca agua?

Pues si, la primera placa de desarrollo íntegramente desarrollada por Intel parece que va a dar micho que hablar, y además, parece ser un digno competidor para el glorioso Rasberry Pi.

Intel acaba de lanzar en exclusiva para Mouser (distribuidor de EEUU de componentes electrónicos) esta placa de desarrollo, que a su vez será entregada (unas 10.000 unidades!) a distintas universidades de todo el mundo. No han concretado a cuales, pero hemos de suponer que se estirarán y lo moverán bastante.

Principales curiosidades?

Primeramente, y lo que mas llama la atención es el desarrollo/implementación de la misma. Y es que Intel se ha asociado con los chicos de Arduino (larga vida!) para crear esta preciosidad. Y es que además, es llamatico el hecho de que Intel se haya animado a apoyar el OpenSource y el Hardware libre, cosa que pocos esperariamos del gigante americano.

Lo segundo, es la potencia que han implementado en esta placa a un precio bastante asequible para el publico, unos 60 €, lo que comparativamente, resulta muy atractivo si observamos los precios de las placas de desarrollo actuales a excepcion del Rasberry Pi y Arduino.

¿Características técnicas destacables?

Pues primeramente, dispone de un microcontrolador basado en el Intel Quark SoC x1000, un procesador de Intel de 32 bits de 32 nm que funciona a 400 Mhz y dispone de una memoria de caché de 16 Kbytes. Vamos, un procesador la mar de apañado.

Si a esto le añadimos 256 Mbyte de DRAM (Dinamic RAM), soporte para 3.3 V o 5 V, y lo mejor, compatibilidad total con los dispositivos de Arduino y sus familias.....nada mas que decir ¿no?

Dispone a su vez, de una configuracion hardware muy similar a la de Arduino Duemilanove, en el que nos encontramos 14 I/O digitales con uso de 6 como PWM, 6 entradas analogicas, y conexiones tipo Ethernet 10/100 y USB. Lo que lo hace bastante interesante para el aficcionado a Arduino, que tendra entre sus manos una placa de desarrollo bastante potente.

Y, algo bastante sorprendete a la vez que potente es la implementación de un slot miniPCI-Express, que básicamente,  añade muchas posibilidades de ampliación en el futuro.

Diagrama de dispositivos de Intel Galileo

Según Intel y Arduino, el Galileo será totalmente compatible con el Software de desarrollo de Arduino ( Arduino Software Development Environment) conocido mundialmente como "IDE Arduino". Esto añade una excepcionalidad muy positiva, ya que además, aseguran tener una amplia compatibilidad con los modulos y dispositivos de Arduino.

Resumiendo, que consigues tener un pepino OpenSource en tu casa con compatibilidades con Arduino y confiando en la potencia y fiabilidad de Intel con sus microprocesadores. Todo un lujo.

Ya sabeis, a partir del 29 de Noviembre tendreis el Intel Galileo en Mouser. Un capricho pendiente......

Interfaces Graficas de Usuario (GUI) en Matlab.

1. Primeros pasos. Introduccion a GUIDE, espacios y metodologia.

Os presento aqui los primeros pasos para diseñar Interfaces Graficas de Usuario (GUI´s para andar por casa) mediante el editor grafico GUIDE, la herramienta de simulacion cientifica basada en MATLAB/SIMULINK.

Empezaremos moviendonos en el entorno grafico de inicio de MATLAB ( Menu principal ), desde el que crearemos una plantilla en blanco para ir comenzando el diseño. La ruta es:

>> MATLAB >> File >> New >> GUI

Nos saldra una ventanita en el que nos dara la opcion de abrir una GUI ejemplo, o partir de una en blanco. Seleccionamos la de blanco, tal como se muestra en la siguiente imagen:

 

 Una vez seleccionada nos aparecera el menu editor de GUI. Vamos, lo que viene siendo nuestro espacio de trabajo y en el que estaremos durante horas pegados....asi que hay que ir familiarizandose. Se muestra a la derecha:

Como podeis observar, es algo "tosco" de primeras, pero resulta tremendamente potente si aprendemos a darle uso.

Se distribuye en vario apartados, como detallo a continuacion:

1.1  Herramientas de GUIDE

Alineación de Componentes (Alignment tool): esta opción permite alinear los
componentes que se encuentra en el área de trabajo (Layout Área) de manera
personalizada.

Editor de menú. Editor de Menús (Menú Editor): El redactor de Menú crea menús
de ventana y menús de contexto.

Editor de orden de etiqueta, enumera y ordena los elementos.

Editor de barra de herramientas en el entorno de diseño GUIDE(Toolbar Editor).

Editor del M-file, presenta el archivo donde se escribe el código que luego controlará la GUI.

Propiedades de objetos (Property Inspector): con esta opción se asignan y modifican las propiedades de cada objeto en forma personalizada.

Navegador de objetos. Navegador de Objetos (Object Browser): Muestra todos los
objetos que se encuentra en la figura (en forma de árbol) y a través de Object Browser se puede seleccionar los objetos.

Botón de ejecución (Run button). Grabar y ejecutar: Al presionarse crea la figura
de la interfaz diseñada en el Área.

Asi pues, es importante "conocer" lo que tenemos a nuestro alrededor para poder trabajar con seguridad y eficiencia. Es duro pero.....todos tenemos que hacerlo!

1.2  Herramientasde Diseño de GUIDE

Aqui les presento las "cositas" mas divertidas de esto que llamamos GUIDE. Se trata de la barra de herramientas de objetos programables en GUIDE. Resumiendo, las posibilidades graficas que nos permite el sotfware.

A nuestra izquierda tenemos la barra tal como se nos muestra. Otra vez mas de alguno pensareis.....Que feo!. Pues si, es verdad, en muchas casos en la ingenieria nos dedicamos más a solventar problemas que a dejarlos "bonitos". Aun, asi con tiempo y paciencia se le coje cariño.

Se observan los distintos tipos de elementos que podemos usar para diseñar nuestra GUI, tales como botoneras, selecctores o gráficas.

Os describo algunas de ellas para que vayais tirando, como se suele decir.

Push Button: Son objetos que al presionarlos ejecutan una acción programada, almacenada en el Callback del archivo con extension .m. Digamos que son los clasicos de los clasicos. Ni que decir mas tiene.

Edit Text: A través de este control de usuario puede ingresar por pantalla
datos para que éstos puedan ser utilizados en los cálculos por las variables. Otro de los pesos pesados.

Static Text:  Este control permite visualizar mensajes o valores numéricos en una interfaz. Dicho elemento no tiene asociada una función de Callback, pero podemos editar su contenido ("String"), para cambiar el tipo de letra, color, tamaño, posición, etc y todo a través del inspector de propiedades del elemento.

Axes: Permite a la GUI mostrar imágenes y crear diversos tipos de gráficos
utilizados para visualizar el contenido de una variable. Este elemento es potencialmente el "más" peleon. Ya iremos viendo....

Radio Button: Este control es un elemento condicional, es decir, en un mismo "Button Group" hay varias posibilidades y, solamente una de ellas estará activa.

Button Group: Se trata de un panel que es capaz de detectar
automáticamente la seleccion de un grupo de "Radio Button", facilitando asi la tarea de detección, todo un detalle de la programación.

1.3  Opciones de Objetos

Como ya hemos visto, los objetos parten de un "generico" previamente diseñado para servir de orientación. Ahora pues, la clave del éxito es el cómo y el dónde usas estos elementos para realizar tu interfaz gráfica.

En cada objeto, existe un submenu llamado "Property Inspector", que nos dara información detallada sobre el elemento, su configuración, estilo, "tag", etc.

Se accede mediante el doble click sobre el elemento (clasicazo donde los haya) o, en su defecto, pulsando botón secundario y accediendo mediante la opción "Property Inspector". Este es su aspecto:

Este es un elemento bastante importante, puesto que en el deberemos fijar muchas variables y condiciones para que nuestro elemento funcione en condiciones.

1.4  El archivo de programación .m

Esta es la madre del cordero, el bellocino de oro de la programación de GUI´s en Matlab. Aquí es donde se escribirá todo el programa que controla la GUI en su totalidad, se detallarán todo lo necesario para que cumpla con sus objetivos, etc.

Esto será lo que verás durante todo tu trasiego por el mundo de las interfaces gráficas en Matlab:

Ya nos vamos metiendo más en materia, pero tampoco hay que pegarse un atracón de primeras. En los próximos capitulos desgranaré mas en profundidad el tema del archivo .m y su programación.

Ya sabeis el dicho, las prisas no son buenas primoh......Nos vemos en la próxima.