jueves, 26 de mayo de 2016

Curso de Java Clase 2: Las entradas, los Strings e introducción a las sentencias de control


Sobre las Entradas

   Como acabamos de ver en el video las entradas en consola se logran usando una combinación de dos cosas System.in y Scanner, ahora vamos a hablar un poco de lo que sucede bajo el capó 

¿Qué es System.in?

 En la entrada pasada, vimos que System es la clase que contiene las operaciones básicas de entrada y salida, en este caso "in" representa un flujo de información, en el mundo de la programación vamos a usar la palabra inglesa "Stream", de hecho mas adelante en el curso se va a dedicar una clase completa a los Streams. Desde un punto de vista conceptual, un Stream es un canal de información, imagínenlo como una carretera donde circulan vehículos de todo tipo, donde cada vehículo lleva paquetes que deben ser entregados, en este ejemplo los paquetes representan la información que es transportada, que ahora no es mas nada que el texto que introducimos en la consola.
  La gran diferencia con "System.out" es como es obvio que "in" trabaja exclusivamente con flujos de entrada.

¿Qué es Scanner?

  Scanner es una clase, como vimos las clases sirven para crear objetos con ellas, esto, como dije en el video va a quedar mas claro cuando veamos orientación a objetos. Para poder entenderlo mejor sin abrumarlos de teoría imaginemos lo siguiente: Los objetos en programación son como los objetos del mundo real y como tales tienen sus propiedades y funciones, por ejemplo un vehículo, tiene una propiedad, el color y una función transportar cosas y personas; entonces si el objeto del mundo real es un vehículo ¿Cual sería la clase? podemos imaginarla como el manual de instrucciones para fabricar un  vehículo.
   Con Scanner creamos un objeto del tipo Scanner, y podemos usar una de sus funciones, en esta caso "nextLine", para transportar nuestra información a la consola, Scanner es nuestro vehículo en la autopista Java. 


System es una clase ¿Podemos crear un objeto con ella?

  
    Excelente pregunta, si te la estás haciendo te felicito, la respuesta a esta pregunta es negativa, existen muchas clases que no se pueden instanciar ya que son abstractas, de forma muy resumida puedo decir que solo están para aprovechar sus funciones sin que sea necesario crear objetos con ellas, es como un manual de aeróbicos, es un manual para hacer algo, pero el resultado no es un objeto físico.


¿Podemos atrapar una entrada en consola sin Scanner?

    
    Si, si se puede, pero te verás obligado a hacer manualmente un montón de cosas, el buffer y el manejo de excepciones son un ejemplo. Como prometí en el video a continuación un ejemplo de entrada en consola sin Scanner.

public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(
                new InputStreamReader(System.in));
        System.out.print("¿Su nombre? ");
        System.out.flush();
        String nombre = in.readLine();
        System.out.println("Felicidades" + nombre);
    }

  Aparte hay que importar varias cosas :
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;


¿Importar?  ¿y la aduana nos va a cobrar impuestos?

  
   Con importar lo que hacemos es traer código desde otros proyectos o librerías, en este caso Java ya nos provee con una serie de librerías que podemos importar y utilizar, esta se conoce como la librería estándar de Java, es de hacer notar que el paquete "Java" de las librerías no es el único. La palabra reservada "import" y sus respectivas librerías a importar, van siempre después de la linea del paquete.

Los Srings son objetos ¿y new?


  String es una clase y por lo tanto las variables de tipo String son objetos, entonces ¿porque no usamos new para crear objetos? String es una excepción en este caso, realmente no conozco si hay mas clases con esta excepción. Es importante saber que crear un objeto String con "new" no es incorrecto, es solo innecesario, veamos el siguiente ejemplo:
  String texto = new String("hola mundo");
Este código no nos va a dar ningún error, pero como dije antes es innecesario ya que como vimos lo podemos hacer así:
String texto = "hola mundo";

Introducción a las Sentencias de Control

  Sin sentencias de control, la programación sería muy aburrida, todo nuestro código se ejecutaría linea por linea sin excepción. Con este ejemplo acabamos de definir lo que son, simplemente son porciones de código que nos permiten decidir que se va a ejecutar y que no. La forma mas básica de ellas en Java es la siguiente:
if( Condición ) {
 codigo a ejecutar si la condición es cierta ;
}

  La condición puede ser cualquier cosa que sea verdadera, por ejemplo
int numero = 2;
if(número == 2) {
System.out.println("El numero es 2!!");
}

Atención

Acabamos de ver dos operadores diferentes: "=" y "==" el primero es para  asignar valores a variables y el segundo es para comparar dos valores

  En el código de arriba si lo ejecutamos, la respuesta en consola sería : "El número es 2!!"

Las funciones "equals" e "equalsIgnoreCase"

    Estas funciones comparan dos textos y devuelven "verdadero" si son iguales y "falso" si no lo son, veamos el siguiente ejemplo:
Tomemos tres variables String, cada una con su respectivo valor:
String texto1 = "hola";
String texto2 = "chao";
String texto3 = "Hola";
  Ahora usemos una de nuestras funciones, como son funciones que devuelven verdadero y falso, tenemos que usarlas dentro de una sentencia de control, en este caso un "if"
if(texto1.equals(texto2)){
   System.out.println("Son iguales");
}
  Este código no se va a ejecutar porque las variables como podemos observar no tienen el mismo valor, ahora veamos lo siguiente:
if(texto1.equalsIgnoreCase(texto3)){
   System.out,println("Son iguales");
}

  En este caso, si se ejecuta el código, ya que la función "equalsIgnoreCase" las compara sin importar las mayúsculas y minúsculas, si por el contrario hubiéramos usado la función "equals", el código no se hubiera ejecutado, te invito a que lo intentes por tu cuenta a modo de ejercicio.

Las palabras raras de la clase: "Sobrecarga de métodos"

  En clases futuras vamos a ver funciones y esto quedará mucho mas claro, muy resumidamente puedo decir, que las funciones o métodos, son bloques de código que podemos llamar cuando queramos para ejecutar todo lo que tengan dentro. Podemos verlo de la siguiente manera, son como variables pero en lugar de almacenar valores, almacenan código. Pero las funciones no solo se identifican por el nombre, si no por los parámetros y la cantidad de los mismos que le podemos pasar, parámetros son eso que colocamos dentro de los paréntesis, por lo tanto podemos crear las funciones que queramos, con el mismo nombre, y no vamos a obtener ningún error siempre y cuando definamos parámetros diferentes para cada una.

Java Serie de Ejercicios: Introducción


Para ir a la lista de reporducción del curso haz click aquí

   Hoy empezamos una nueva serie de videos que forman parte del curso de Java, si viste el video que acompaña esta entrada ya sabes de que se trata, de todas formas explico que en estos videos se les va a invitar a realizar ciertas practicas con el fin de que afiancen y practiquen conocimientos adquiridos durante el curso.

Pendiente en las clases

  Antes de publicar un video de ejercicios, en la clase correspondiente yo colocaré un aviso, de modo que una vez publicada dicha clase le seguirá el ejercicio, en las diapositivas del video aparecerá algo como lo siguiente:

  Si al momento de ver el video ya esta disponible el ejercicio yo colocaré un enlace directamente en el video.

El código fuente

  Como dije en el video (si no lo has visto click aquí) se te va a invitar a pausar el video para que tu mismo intentes realizar la práctica, aquí en el blog encontraras algunas pistas en dado caso de que necesites alguna orientación. Por último en la misma entrada con las pistas, colocaré el código fuente para que lo descargues.

Sobre el juego que acabas de ver

  Si sigues el curso en su totalidad aprenderás a hacer eso y mucho mas, así que animo.

martes, 24 de mayo de 2016

Curso de Java Clase 1: Las Variables, tipos de datos y nuestro primer programa

Para ver el video que acompaña esta entrada haz click aquí
Para ir a la primera clase haz click aquí
Para ir a la lista de reproducción de Youtube haz click aquí

¿Cuando usar el "punto y coma" ?

  Después de haber visto el video, si fuiste lo suficientemente observador habrás notado que hay sitios de nuestro código que finalizan con punto y coma y hay otros que no

  Entonces ¿Cuando finalizar con punto y coma en java? La respuesta es muy simple, se finalizan todas las sentencias pero no la declaraciones de bloque. Las declaraciones de bloque son todas aquellas que seguidas de su nombre tienen llaves de apertura y cierre ( { y }) y una o varias lineas de código dentro de estas llaves. Si es una sentencia de linea deberá siempre y obligatoria mente terminar en punto y coma. En las imágenes de arriba vemos que "public class" y el metodo "main", son declaraciones de bloque, ya que tienen su nombre seguido de las llaves con código dentro de las mismas, el resto de código son sentencias de linea.

Declarar Varias Variables

  Si queremos declarar varias variables que tienen el mismo tipo de dato, como por ejemplo lo siguiente:
int numero1 = 5;
int numero2 = 10;
int numero3 = 15;

  Podemos resumir estas 3 lineas de código en una sola de la siguiente forma:
int numero1 = 5, numero2 = 10, numero3 = 15;
Como acabamos de ver, iniciamos como es normal indicando el tipo de dato, luego separamos por comas cada variable y al finalizar terminamos con punto y coma ya que es una sentencia de linea. También es valido crear las variables del mismo modo que acabamos de ver pero sin asignarle valores  de la siguiente forma:
int numero1, numero2, numero3;
  Luego para utilizar estas variables habrá que asignarle algún valor, como por ejemplo:
numero1 = 5;
Ya no es necesario declarar el tipo de dato porque la variable ya fue creada.

La clase System

La clase "System" contiene otras clases y metodos útiles, pero es de destacar que su principal función son las operaciones básicas de entrada y salida, ejemplo de esto es "System.out" que ya utilizamos para hacer una salida en consola

¿Que es "System.in" ?

 Habrás podido notar que "out" no es el único miembro de la clase "System", entre las muchas cosas que aparecen "in" es una de ellas, si sabes suficiente inglés, te estarás preguntando: Si out es salida en consola ¿in será entrada de datos? Felicidades si te haces esta pregunta, significa que haz explorado el código, la respuesta es afirmativa, pero el uso de "System.in" es un poco mas complejo y por lo tanto ese tema será desarrollado en una próxima clase.

Sobre el nombre de las Variables

 Hay ciertas reglas que son validas no solo para Java si no para casi cualquier lenguaje de programación. En cuanto al nombre de las variables tenemos lo siguiente:
  1. Las variables no pueden contener: Espacios en blanco, tildes y cualquier caracter especial excepto el guión bajo. Ejemplo numero&palabra
  2. No pueden comenzar con un número: El nombre de la variable puede empezar solamente con alguna letra o con el guión bajo. Ejemplo 1numero
  3. Si pueden contener números siempre cuando no esten al inicio: Puedes crear una variable cuyo nombre contenga números, pero estos nunca pueden ir al inicio. En el video creamos varias variables de este tipo. Ejemplo numero1
  4. No pueden llamarse igual que alguna palabra reservada de Java: Un ejemplo de esto es la palabra "System" que como ya vimos nos permite acceder a operaciones de entrada y salida, como es obvio no podemos ponerle este nombre a una variable y lo mismo es valido para cualquier palabra reservada.
  5. Las variables distinguen entre mayusculas y minusculas: Esto es super importante, ya que variables con los siguientes nombres: Numero, numero, NUMERO o numeRo, van a ser reconocidas por java como variables TOTALMENTE diferentes

Los tipos de dato

  El tipo de dato es un concepto utilizado no solo en Java si no en casi cualquier lenguaje de programación, al declarar un tipo de dato le estamos diciendo en el lenguaje que valor vamos a guardar en la variable que estamos a punto de declarar, por ejemplo:
String nombre = "Manuel";
 Aquí queremos guardar en la variable "nombre" el valor "Manuel", entonces decimos en el lenguaje, que queremos una variable de tipo String, lo que voy a poner a continuación no es valido :
String nombre = 15;
Estamos intentando asignar un valor del tipo "int" pero declarando un tipo "String", Netbeans en esta caso nos va a dar un error

Los tipos de dato mas comunes y sus especificaciones

   Los tipos de dato en Java se pueden clasificar en "primitivos" y "de tipo objeto", esto va a quedar mas claro cuando veamos "Orientación a Objetos", por ahora solo hablaremos del espacio que ocupan en memoria y del rango de valores que pueden almacenar

Primitivos :
  • byte: Puede almacenar valores de tipo entero, ocupa un byte en memoria y solo puede tener valores del rango que de -128 a 127
  • short: Puede almacenar valores de tipo entero, ocupa 2 bytes en memoria y su rango va de -32768 a 32767
  • int: Puede almacenar valores de tipo entero, ocupa 4 bytes y su rango va de  -231 hasta 231 
  • long: Puede almacenar valores de tipo entero, ocupa 8 bytes, y su rango va de -263 hasta 263 
  • float: Sirve para almacenar decimales simples, ocupa 4 bytes y su rango escapa de los alcances de esta clase, solo diremos que es muy grande
  • double: Sirve para almacenar decimales simples, ocupa 8 bytes y su rango al igual que float, por ahora solo diremos que es muy grande
  • boolean: Aquí solo podremos guardar valores lógicos, verdadero y falso, para ello usaremos las palabras "true" para verdadero y "false" para falso, representa un bit de información pero su tamaño no es algo definido de forma precisa
  • char: Sirve para guardar un carácter, específicamente uno solo y ocupa 2 bytes de información, no hablaré del rango de este tipo en esta clase ya que escapa de los alcances de la misma, solo ten en cuenta que puedes guardar un solo carácter de cualquier tipo
De tipo objeto :
  Este tipo de dato es un poco mas complejo así que no los voy a nombrar a todos, también por cuestiones de espacio ya que son muchos. El espacio en memoria que puede ocupar un objeto en Java o en cualquier lenguaje, puede variar por diferentes factores, así que en este apartado no tiene sentido hablar de memoria, por esta vez solo hablaremos de un tipo de dato:
  • String: Aquí podemos almacenar cadenas de texto completas, sin límite de duración y con cualquier carácter que queramos.

Fin de esta clase, si te gusta mi material puedes apoyarme suscribiendote a mi canal de Youtube
dandole me gusta al video y compartiendo el blog.

domingo, 22 de mayo de 2016

Curso de Java: Introducción

  Para ver el video que acompaña esta entrada haz click aquí
   Al querer aprender java lo primero que nos viene a la mente es ¿Qué es Java? si abrimos google y buscamos java nos aparecen principalmente dos cosas, la descarga de un software y un lenguaje de programación, entonces nos viene a la mente la pregunta ¿Qué es entonces Java? La repuesta es ambos, pero para poder explicar esto primero tenemos que ver algunos conceptos básicos sobre lenguajes de programación en general.
  Dos preguntas importantes: ¿Qué es un programa? ¿Qué es un lenguaje de programación?
  •          Un programa: Son básicamente una serie de instrucciones que la computadora puede ejecutar
  •          Un lenguaje de programación: Son la forma o el lenguaje en el que están escritas estas instrucciones

Sabiendo esto podemos dividir los lenguajes en varias categorías, esto porque la máquina no habla español o inglés, si no habla un lenguaje que no es natural para el ser humano, por lo que clasificamos los lenguajes según su nivel de comprensibilidad para el ser humano
  •          Lenguajes de bajo nivel: Aquí tenemos al lenguaje de máquina que no es comprensible o no es natural para el ser humano
  •          Lenguajes de alto nivel: Son los lenguajes de programación, como java, c, c++, c#


Sabiendo esto ya podemos introducir lo que es la compilación, que no es nada más que el proceso de convertir o traducir un lenguaje de alto nivel a uno de bajo nivel, o lo que es lo mismo, a partir de un lenguaje que el humano puede entender, crear un lenguaje que la máquina pueda entender.
  La compilación tiene una pequeña desventaja, el lenguaje de máquina no es igual para todas las plataformas, es por eso que programas que son para Linux normalmente no funcionan en Windows o programas que son para Mac solo funcionan en Mac
  Aquí es donde explicamos que es ese software también llamado Java. Cuando escribimos un programa java y luego lo compilamos, no estamos compilando al lenguaje de nuestra máquina, si no al lenguaje de la máquina virtual java, este programa que instalamos es una máquina virtual que va ejecutar nuestros programas java ya compilados. Esto es una ventaja ya que siempre y cuando tengamos la máquina virtual de java instalada podemos ejecutar cualquier programa java, sin importar si fue hecho en Linux, Mac o Windows. Podemos decir que el programa se ejecuta en la máquina virtual. Este lenguaje intermedio se llama bytecode
De aquí proviene el slogan de Java: “Escribe una vez, ejecútalo en todas partes”

Breve Historia de java

  Java fue originalmente desarrollado y lanzado al público por James Gosling y la Sun Micro System en 1995 y desde sus inicios fue diseñado para ejecutarse con tan pocas dependencias de implementación como fuera posible, es con datos del 2012 uno de los lenguajes de programación más populares, habiéndose registrado 10 millones de usuarios reportados.
  No se tiene certeza de donde deriva su nombre, al principio se le llamó Oak, por un árbol de roble que había en las afueras de las oficinas, luego se llamó Green y por último obtuvo su actual nombre. Hay varias hipótesis sobre el origen del nombre “Java”, algunos sostienen que podría tratarse de un acrónimo de los nombres de los diseñadores James Gosling, Artur Vann Hoff y Andy Bechtolsheim, otros que podría tratarse de Just Another Vague Acronym, que significa “tan solo otro acrónimo vago”, pero la hipótesis más plausible es que su nombre de deriva de un tipo de café disponible una cafetería cercana, lo que explica también por qué su logo representa una taza de café caliente
Java es un mundo
   Con java no solo podemos hacer programas que corran en nuestro escritorio, sino también páginas web dinámicas (JSP) aplicaciones del lado del servidor (Servlets) Rich Internet aplications (applets) y sistemas embebidos ya que es posible encontrar pequeños dispositivos capaces de ejecutar java de forma nativa, podemos encontrar java en teléfonos móviles, sintonizadores de TV e incluso tarjetas inteligentes (JavaCard)
¿Qué podemos hacer con Java?
ü  Una página web de compras electrónicas, como amazon.com o mercadolibre.com usando JSP y los Servlets
ü  Una página de juegos como MiniJuegos.com, usando los applets que son mini programas que se ejecutan en el navegador
ü  Un software de inventario y facturación para una tienda como aplicación de escritorio
ü  Aplicaciones para Android, las aplicaciones para Android se escriben en Java, pero usando unas librerías especificas
ü  Programar el funcionamiento de las tarjetas que se usan bien sea para abrir las puertas de las habitaciones de hotel o incluso tarjetas débito y crédito de los bancos (JavaCard)
El entorno de desarrollo
El entorno que vamos a usar en el curso va a ser Netbeans, pero también existen otros entornos de desarrollo, eres libre de elegir el que más te guste o se adapte a tus necesidades, a continuación, enlaces de descarga de algunos IDE Java populares:
Netbeans con el JDK incorporado
Netbeans sin el JDK, si deseas instalar Netbeans y el JDK aparte

domingo, 2 de marzo de 2014

Control de varios servos Arduino + Java +RXTX

En esta entrada les muestro un simple programa escrito en java y la librería para conexión serial RXTX, que envía parámetros a un Arduino con 3 servomotores conectados, el programa a través de una serie de "Sliders" controla con precisión los servos desde la computadora, tiene varios campos de texto con los cuales puedes establecer con exactitud el angulo que quieres colocar en el servo, incluso puedes mover los 3 servos al mismo tiempo al colocar los ángulos y luego presionar el botón enviar, para ver un demo del programa en accion : https://www.youtube.com/watch?v=R-7sTBZKypY&feature=youtu.be

   El programa esta compuesto de 3 clases, Gui.java, Multiservo.java y map.java

GUI.java :

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;

public class GUI extends KeyAdapter implements ActionListener, ChangeListener {

    JFrame vt = new JFrame("Servos");
    JLabel txt1 = new JLabel("Selecciona el puerto de tu Arduino");
    String[] puertosOp = {"COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",};
    JComboBox puertosSelec = new JComboBox(puertosOp);
    JPanel panel1 = new JPanel();

    JSlider motor1 = new JSlider(JSlider.VERTICAL, 0, 180, 0);
    JTextField manual1 = new JTextField(3);
    JPanel m1 = new JPanel();
    JSlider motor2 = new JSlider(JSlider.VERTICAL, 0, 180, 0);
    JTextField manual2 = new JTextField(3);
    JPanel m2 = new JPanel();
    JSlider motor3 = new JSlider(JSlider.VERTICAL, 0, 180, 0);
    JTextField manual3 = new JTextField(3);
    JPanel m3 = new JPanel();

    JPanel panel2 = new JPanel();

    JButton enviar = new JButton("Enviar");
    JPanel panel3 = new JPanel();

    MultiServo conexion;

    GUI() {
        vt.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        vt.setResizable(false);
        vt.setLayout(new BorderLayout());
        vt.add(panel1, BorderLayout.NORTH);
        vt.add(panel2, BorderLayout.CENTER);

        panel1.add(txt1);
        panel1.add(puertosSelec);
        puertosSelec.addActionListener(this);

        panel2.add(m1);
        panel2.add(new JLabel("    "));
        panel2.add(m2);
        panel2.add(new JLabel("    "));
        panel2.add(m3);

        m1.setLayout(new BorderLayout());
        m1.add(motor1, BorderLayout.CENTER);
        m1.add(manual1, BorderLayout.SOUTH);
        motor1.addChangeListener(this);
        manual1.addKeyListener(this);

        m2.setLayout(new BorderLayout());
        m2.add(motor2, BorderLayout.CENTER);
        m2.add(manual2, BorderLayout.SOUTH);
        motor2.addChangeListener(this);
        manual2.addKeyListener(this);

        m3.setLayout(new BorderLayout());
        m3.add(motor3, BorderLayout.CENTER);
        m3.add(manual3, BorderLayout.SOUTH);
        motor3.addChangeListener(this);
        manual3.addKeyListener(this);

        vt.add(panel3, BorderLayout.SOUTH);
        panel3.add(enviar);
        enviar.addActionListener(this);
        motor1.setEnabled(false);
        motor2.setEnabled(false);
        motor3.setEnabled(false);
        manual1.setEditable(false);
        manual2.setEditable(false);
        manual3.setEditable(false);
        vt.pack();
        vt.setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        Object f = e.getSource();
        if (f == puertosSelec) {
            motor1.setEnabled(true);
            motor2.setEnabled(true);
            motor3.setEnabled(true);
            String op = (String) puertosSelec.getSelectedItem();
            conexion = new MultiServo(op);

            manual1.setEditable(true);
            manual2.setEditable(true);
            manual3.setEditable(true);
         
            puertosSelec.setEnabled(false);
        }
        if (f == enviar) {
            String val;
            val = manual1.getText();
            motor1.setValue(Integer.parseInt(val));

            val = manual2.getText();
            motor2.setValue(Integer.parseInt(val));

            val = manual3.getText();
            motor3.setValue(Integer.parseInt(val));
        }
    }

    @Override
    public void stateChanged(ChangeEvent e) {
        Object f = e.getSource();
        String val;
        if (f == motor1) {
            val = String.valueOf(motor1.getValue());
            conexion.enviar(Map.rTres(motor1.getValue()));
            manual1.setText(val);
        }
        if (f == motor2) {
            val = String.valueOf(motor2.getValue());
            conexion.enviar(Map.rTres(motor2.getValue()) + 85);
            manual2.setText(val);
        }
        if (f == motor3) {
            val = String.valueOf(motor3.getValue());
            conexion.enviar(Map.rTres(motor3.getValue()) + 170);
            manual3.setText(val);
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {
        Object f = e.getSource();
        int tecla = e.getKeyCode();
        String val;
        if (f == manual1 && tecla == KeyEvent.VK_ENTER) {
            val = manual1.getText();
            motor1.setValue(Integer.parseInt(val));
        }
        if (f == manual2 && tecla == KeyEvent.VK_ENTER) {
            val = manual2.getText();
            motor2.setValue(Integer.parseInt(val));
        }
        if (f == manual3 && tecla == KeyEvent.VK_ENTER) {
            val = manual3.getText();
            motor3.setValue(Integer.parseInt(val));
        }
    }
}

MultiServo.java :


import gnu.io.*;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MultiServo {
Enumeration listaPuertos = CommPortIdentifier.getPortIdentifiers();
CommPortIdentifier puertoId ;
PrintStream arduinoOut ;
SerialPort puerto;
MultiServo(String pto){
    while(listaPuertos.hasMoreElements()){
        puertoId = (CommPortIdentifier)listaPuertos.nextElement();
        if(puertoId.getName().equals(pto)){
            break;
        }
    }
    try {
        puerto = (SerialPort)puertoId.open("Serial", 1000);
        puerto.setSerialPortParams(28800, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);
        arduinoOut = new PrintStream(puerto.getOutputStream());
    } catch (PortInUseException | IOException | UnsupportedCommOperationException ex) {
        Logger.getLogger(MultiServo.class.getName()).log(Level.SEVERE, null, ex);
    }
}

public void enviar(int num){
    arduinoOut.write(num);
}
    public static void main(String[] args) {
       GUI app = new GUI();
    }
 
}

Map.java:

public class Map {
    static int rTres(int n){
        //85 x n/180
        int resultado = (85*n)/180;
        return resultado;
    }
}


Esto es el programa en java, ahora falta el sketch para el Arduino, aqui esta:

#include <Servo.h>
Servo motor1;
Servo motor2;
Servo motor3;
int num;
int mov;

void setup(){
  Serial.begin(28800);
  motor1.attach(9);
  motor1.write(0);

  motor2.attach(10);
  motor2.write(0);

  motor3.attach(11);
  motor3.write(0);
}

void loop(){
  if(Serial.available()>0){
    num = Serial.read();
    if(num >=0 && num <85){
      mov = map(num, 0, 84, 0, 180);
      motor1.write(mov);
    }
    if(num >=85 && num <170){
      mov = map(num, 85, 169, 0, 180);
      motor2.write(mov);
    }
    if(num >=170 && num <= 255){
      mov = map(num, 170, 255, 0, 180);
      motor3.write(mov);
    }
  }
}

jueves, 4 de noviembre de 2010

Curso de TinyMCE en español


Para ver en youtube haz click aquí
Que es TinyMCE:
Es lo que se conoce, como un editor WYSIWYG, lo cual es un acronimo en ingles de: lo que ves es lo que obtienes, y se refiere a los procesadores de texto que muestran directamente el resultado final, y escribir directamente en el, se muestra como una alternativa, a procesadores de texto poco frecuentes el día de hoy, en los que el resultado final no se mostraba hasta el momento de imprimir el documento.

  En el caso de TinyMCE esta diseñado para poder ser usado en nuestras paginas web, integrándolo en el HTML de la misma, esta creado en javascript, y es OpenSource.

En la imagen de arriba vemos un ejemplo de tinyMCE aplicado a una textarea


Primera parte del curso: Implementacion y Uso de tinyMCE
Implementacion:
Lo primero, y mas obvio es descargarse la librería haciendo click aqui, luego para ver el primer capitulo del videotutorial dirigete a este enlace
Archivos de Ejemplo:
Para descargar un archivo de ejemplo, con una implementación básica de tinyMCE, haz click aqui

miércoles, 6 de octubre de 2010

Introducción HTML5 Parte 1

Pregunta Básica ¿Que es HTML5?
Es la nueva revisión del lenguaje HTML, especifica dos variantes para su sintaxis, un html clásico, la variante conocida como html5 que asi se llama por ser la quinta revisión importante, y una variante xml conocida XHTML5, esta es la primera vez que html y xhtml se desarrollan en paralelo, dicho de una forma mas simple es un borrador de lo que sera la próxima versión de html
Diferencias entre html y html5
Etiquetas que pasaron al desuso:
<acronym>, <applet><basefont><big><center><dir><font><frame><frameset><noframes><s><strike><tt>, <u><xmp>
Etiquetas nuevas en html5:
<article>, <aside>, <audio>, <canvas>, <command>, <datalist>, <details>, <embed>, <figcaption>, <figure>, <footer>, <header>, <hgroup>, <keygen>, <mark>, <meter>, <nav>, <output>, <progress>, <rp>, <rt>, <section>, <source>, <summary>, <time>, <video>, <wbr>
Atributos que pasaron al desuso:
rev y charset en <link /> y <a />, target en <link />, nohref en <area />, profile en <head />, version en <html />, name en <map />, scheme en <meta />, archive, classid, codetype, declare y standby en <object />, valuetype en <param />, charset en <script />, summary en header, axis y abbr en <td /> y <th />
Atributos Estándar nuevos:
Al igual que las versiones html anteriores existen atributos que son aplicables a todas las etiquetas, en html5 se agregan los siguientes:
contenteditable, contextmenu, data-yourvalue, draggable, hidden, item, itemprop, spellcheck, subject
Atributos maneja-dores de Evento nuevos:
onafterprint, onbeforeprint, onbeforeonload, onerror, onhaschange, onmessage, onoffline, ononline, onpagehide, onpageshow, onpopstate, onredo, onresize,onstorage, onundo, onunload