Sensor de temperatura con arduino y java

Sensor de temperatura LM35 y java

Saludos nuevamente de mi parte.
Estamos a qui para un nuevo tutorial, esta vez de nuevo con arduino y java, pero
en esta ocasin utilizando un sensor de temperatura (LM35).
***************************************************************************
para llevar acabo este tutorial se da por hecho que ha visto el post anterior ya que
la manera en que arduino se comunicara con java es la misma por lo tantos los
pasos a seguir son los mismo. no ser asi por favor miviste el ----> post
***************************************************************************
Un LM35 es un dispositivo electrnico capas de poder medir la temperatura,
consta de tres bases o patas, cada una con su propio propsito uno para gnd o
tierra, otro para vin o voltaje de entrada y por ultimo vout o voltaje de salida.
El LM35 funciona de la siguiente manera.
1c = 10mlv
lo que es igual a un grado centigrado es igual a 10 mili
volts
por lo que si en temperatura ambiente tenemos 32c
el LM35 tendra en su base de salida 320 mlv;
La forma en que se conecta a arduino y la funcin de cada una de sus bases es
la siguiente:

Con esta unin se pueden dar mil usos, desde mecnicos, electrnicos y por que
no hasta mdicos como fue en mi caso, ver otro de mis blogs donde use este
cirucitor para fines medicos.

paso 1.preparar java para la conexin con arduino llamando libreras y ajustando
directorios de archivos. (visto en el post anterior mismos pasos) ir al post anterios
paso 2.preparar la interfaz en java encargada de recibir los datos que arduino le ara llegar,
para este tutorial yo he preparado un termmetro dibujado en el metodo paint() de
una clase java. quedando asi

Esta interfaz ira representando los valores que arduino le haga llegar.
CDIGO
public void paint(Graphics g)
{
//super.paint(g);//para algunos sistemas windoxs
repaint();
//temp=(redonde((n/.30)));
if ((x-c<=156)&&(x-c>=106))
{
fondo=Color.BLUE;
}
if ((x-c<=106)&&(x-c>=74))
{
fondo=Color.ORANGE;
}
if ((x-c<=74)&&(x-c>=34))
{
fondo=Color.RED;
}

//base
//fuente de todas las letras en el termometro
Font f = new Font( "Helvetica",Font.BOLD,16 );
g.setFont( f );
g.setColor(Color.BLACK);
g.drawArc(90,230,50,50, 130,280);//base arriba
g.drawArc(80,230,70,60, 130,277);//base abajo
g.drawLine(100,80,100,235);
g.drawLine(92,80,92,237);
g.drawLine(132,80,132,235);
g.drawLine(140,80,140,238);
//base
g.drawArc(92,60,48,48,8,180);//tapa de arriba
g.drawArc(100,65,32,32,5,180);//tapa de abajo
//g.drawArc(90,50,50,50, 540,360);
//rellono que simula al mercurio
g.setColor(fondo);
g.fillArc(90,230,50,50, 0,360);
g.fillRect(101,80,31,156);//rellono mercurio
g.setColor(Color.WHITE);
g.fillRect(101,80,31,x-c);//rellono mercurio
//fuentes
g.setColor(Color.white);
g.fillArc(100,65,32,32,5,180);//tapa de abajo
g.drawString((c)+"C", 95,260);
//letras
g.setColor(Color.BLUE);
g.drawString("0 -", 70,240);
g.drawString("20 -", 65,220);
g.setColor(Color.ORANGE);
g.drawString("40 -", 65,200);
g.drawString("60 -",65,180);
g.setColor(Color.RED);
g.drawString("80 -", 65,160);
g.drawString("100 -",55,140);
//g.drawString("120 -", 55,120);
//g.drawString("140 -",55,100);
if(x<=10)
{
g.setColor(Color.RED);
g.fillArc(100,65,32,32,5,180);//tapa de abajo
}
}
Es fcil notar que el termmetro ira adquiriendo otro color mientras la temperatura
vaya aumentando.

paso 3.
hasta ahora solo se ha preparado la interfaz de usuario, entramos a la parte de
la conexin pues prepararemos arduino para mandar los datos a java.
el codigo es muy simple.
void setup()
{
//abrimos el puerto serie a una tasa de bits de 9600 estantar
Serial.begin(9600);
}//fin de setup
void loop()
{
//se prepara los datos para ser enviados
/*primero se lee lo que esta en la entrada analgica 0 luego lo multiplicamos por
500 por que esta siendo alimentado con 5v y hay 500 veces 10 mlv en el. 10ml por
500 = 5v (LM35 usa 10ml para presesentar un 1c)
esta es la explicacin de por que por 500
luego se divide entre 1023.
esto por que es lo mximo que arduino puede leer de la estragada analogica
y por ultimo escribimos en el puerto serie la cantidad que nos quedo. ya en grados
*/
Serial.write((analogRead(0)*500.00)/1023.00);
//le decimos a arduino que lee la entrada analgica cada segundo
delay(1000);
}
cabe aclarar que hay dos formas en las que arduino enva informacion por el
puerto serie son Serial.write ();
y Serial.println();
uno envia el valor real y el otro pinta el resultado sin importarle cual es su valor.
ejemplo si estamos a 61c
el mtodo Serial.write (); mandara una a por que? es simple por que en la tabla
ascii a=61 entonces cuando java reciba esta "a" sabr que es un 61 y lo graficara
en el termmetro.
el metodo Serial.println (); este no le importara su valor real y
simplemente pondr en el puerto serie el 61
entonces cuando java reciba este este 61, tomara el "6" y graficara en
el termmetro el 54, tabla ascci 6 =54
e inmediatamente tomara el "1" y graficara en el termmetro el 49, por la misma
razon 1 en la tabla ascii=49.
por lo que el metodo Serial.println() no es valido para estas practicas.
el codigo sin comentarios queda asi:

paso 4 y ultimo:
recibir los datos de arduino
//importamos las librerias necesarias para la conexion
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.lang.reflect.*;
import java.io.InputStream;
import processing.app.Preferences;
creamos
una variable de tipo Input para que este reciba los datos de arduino asi:

static InputStream input;

luego en el metodo main que previamente fue preparado para la comunicacion
asemos int n=0; n=(input.read()) ;//Temperatura
temperatura(n);
y ese valor se lo mandamos a un metodo encargado graficarlo en el termmetro.
public static void temperatura(int t)
{
c=t;
}
la "c" del cdigo es la que se graficara en arduino.
el cdigo quedara as sin el metodo paint :
import gnu.io.PortInUseException;
import gnu.io.UnsupportedCommOperationException;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import java.io.InputStream;
import java.io.OutputStream;
import processing.app.Preferences;
import java.util.*;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.awt.Color;
/**
*
* @author victor
*/
public class Temperatura extends javax.swing.JFrame {
int x=156;static int c=0;static int m=1;
double temp=0;
Color fondo=Color.GREEN;
static byte chunk[]={1};
static int n=0;
static InputStream input;
static OutputStream output;
static SerialPort serialport;
private static final String PORT_NAMES[] = {
//"/dev/tty.usbserial-A9007UX1", // Mac OS X
//"/dev/ttyUSB0", // Linux
"/dev/ttyACM0","/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2",
"/dev/ttyUSB3", "/dev/ttyUSB4", "/dev/ttyUSB5", "/dev/ttyUSB6", "/dev/ttyUSB7",

"/dev/ttyUSB8",
"/dev/ttyUSB9",
"/dev/ttyUSB10",
"/dev/ttyUSB11",
"/dev/ttyUSB12","/dev/ttyUSB13","/dev/ttyUSB14","/dev/ttyUSB15","/dev/ttyUSB16",
"/dev/ttyUSB17","/dev/ttyUSB18","/dev/ttyUSB19","/dev/ttyUSB20","/dev/ttyUSB21"
,"COM3","COM0","COM1","COM2","COM4","COM5","COM6","COM7","COM3","
COM8","COM9","COM10","COM11","COM12" // Windows
};
static public class MyPrefs extends Preferences {
static public void init() {
Preferences.init("/home/victor/.arduino/preferences.txt");
//Preferences.init("c:/preferences.txt");
}
}
/** Creates new form Temperatura */
public Temperatura() {
initComponents();
}
public static void temperatura(int t)
{
c=t;
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Termometro");
javax.swing.GroupLayout
layout
=
new
javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 244, Short.MAX_VALUE)
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 300, Short.MAX_VALUE)
);
pack();
}// </editor-fold>
/**
* @param args the command line arguments
*/
public static void main(String args[]) throws IOException, PortInUseException,
UnsupportedCommOperationException {

/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code
(optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default
look and feel.
*
For
details
see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for
(javax.swing.UIManager.LookAndFeelInfo
info
:
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Temperatura.class.getName()).log(java.util.loggi
ng.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(Temperatura.class.getName()).log(java.util.loggi
ng.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(Temperatura.class.getName()).log(java.util.loggi
ng.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(Temperatura.class.getName()).log(java.util.loggi
ng.Level.SEVERE, null, ex);
}
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Temperatura().setVisible(true);
}
});
MyPrefs.init();
System.out.println("puerto usado: " + MyPrefs.get("serial.port"));
System.out.println("targeta utilizada: " + MyPrefs.get("board"));
/*CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier(
MyPrefs.get("serial.port"));*/
CommPortIdentifier portId = null;
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();

// iteraciones para buscar el puerto

while (portEnum.hasMoreElements()) {
CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();
for (String portName:PORT_NAMES) {
if (currPortId.getName().equals(portName)) {
portId = currPortId;
break;
}
}
}
Temperatura m=new Temperatura();
serialport = (SerialPort)portId.open(m.getClass().getName(), 9600);
input = serialport.getInputStream();
output = serialport.getOutputStream();
serialport.setSerialPortParams(MyPrefs.getInteger("serial.debug_rate"),
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
while(true){
while(input.available()>0) {
//System.out.println((char)(input.read()));
try {
/*
int available = input.available();//esta linea regresa el valor de la cantidad de
informaion en el puerto serie
byte chunk[] = new byte[available];//se crea una rreglo de tipo bite que tiene
como limite el valor de avalible
input.read(chunk, 0, available);//lee lo que se encuentra pendiente en el
puertoserie y lo guarda en el arreglo
// Displayed results are codepage dependent
//despliega en pantalla todo lo que logro leer
System.out.println("");
//System.out.println("Arduino dice: "+new String(chunk));
n=Integer.parseInt(new String(chunk));
System.out.println(""+n);
*/int b=0;
int n=0; n=(input.read()) ;//Temperatura
temperatura(n);
System.out.println(n);
} catch (Exception e) {
System.err.println(e.toString());
}
//System.out.println(""+ban);
}
}

}
static public double redonde (double x)
{
return Math.rint(x*1)/1;
}
}
cdigo completos dudas comentarios y/o sugerencias a vctr.31@hotmail.com