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!!