[Debian] Instalar Java (JDK y JRE) desde repositorios

La instalación de Java es sencilla utilizando repositorios, su instalación esta a solo unos comandos, en este caso fue probado en un debian 8 de 32 bits, entonces pasamos a ejecutar los siguientes comandos:

1) Entrar en modo super usuario

$ su 
 password: "nuestro password"

2) Agregar las siguientes entradas a nuestro source list que podemos hacerlo manual pero en este caso los pondremos de manera automática, aunque los repositorio no son de Debian originalmente porque no soporta esa opción

# echo "deb http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main" | tee /etc/apt/sources.list.d/webupd8team-java.list
# echo "deb-src http://ppa.launchpad.net/webupd8team/java/ubuntu trusty main" | tee -a /etc/apt/sources.list.d/webupd8team-java.list

3) Agregamos las claves necesarias para la instalación

# apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys EEA14886

4) Instalamos el paquete, ya con esto permitiremos

# apt-get update
# apt-get install oracle-java8-installer

Nota: en la parte de la instalación nos pregunta si aceptamos la licencia solo escribimos la palabra "yes"

5) Aceptamos las licencias de forma automatica para las actualizaciones

# echo oracle-java8-installer shared/accepted-oracle-license-v1-1 select true | sudo /usr/bin/debconf-set-selections

6) Configuramos las variables de entorno

# sudo apt-get install oracle-java8-set-default

7) Ya puedes hacer tus pruebas con los siguientes comandos para su utilización

# javac -version 
# java -version 

Fuente: http://www.webupd8.org/2014/03/how-to-install-oracle-java-8-in-debian.html

[Ubuntu] Bajar videos de youtube

 

Muchas veces necesitamos un video y no tenemos una buena conexión de internet, y en linux o ubuntu es muy sencillo poder descargarlo, solo necesitamos instalar clive 

 $ sudo apt-get install clive

Ya una vez que se tiene instalado solo se tiene que poner en la consola el comando clive y la url del video y empezara a descargar. 

$ clive https://www.youtube.com/watch?v=LXqEfkUUlEU

Espero les ayude.

[Android] Conectando Genymotion para probar nuestras aplicaciones

Genymotion es un software que sin problema puede sustituir al emulador que viene por default en los desarrollos de android como ya explicamos en el post anterior, en este caso genymotion es muy noble para la conexion ya que solo tenemos que irnos al menu Settings,  en la pestaña de ABD y poner la ruta del SDK que utiliza nuestro Android Studio. 

Una vez configurado solo lanzamos nuestros emulador y en este caso al abrir Android Studio detectaremos el dispositivo.

 

[Java] Compartir archivos por socket

Continuando con el post anterior, ya antes ya habia escrito algo con sockets pero creo que este esta mas elaborado se trata de una aplicación que permite mediante un servidor de socket generar una carpeta compartida, mediante un cliente se pueden descargar y subir archivos a dicha carpeta, aunque todavía falta seguridad es un buen ejercicio para quien lo pueda utilizar, les dejo un video de su uso y el enlace en gitHub para que descarguen el codigo. 

[Java] JTree como explorador de archivos

 

En Java existe un componente llamado JTree que permite enlistar una serie de elementos en una estructura esquematica o por jerarquia, por lo el poder explorar archivos no es una tarea tan sencilla como se quisiera pero les dejo una libreria. 

En mi caso vamos a crear un proyecto Java y le agregaremos un componente JTree para las pantallas para esto yo tengo el ejemplo en Netbeans por lo que tendría algo así. 

En este caso vamos a entrar al codigo en el constructor pondremos lo siguiente suponiendo que mi componente lo llamaremos jTree1. 

        public ContructorClass{
        initComponents();
        JTreeFile jTreeFiles = new JTreeFile(); 
        jTreeFiles.setJTree(jTree1);
        jTreeFiles.init(); 
        }

Ya lo unico que tendremos que hacer es crear una clase con sl siguiente codigo que permita actualizar el listado de los archivos.

package ui.jTreeLib;

import java.io.File;
import javax.swing.JTree;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

/**
 *
 * @author coby
 */
public class JTreeFile implements TreeExpansionListener{

    
    private JTree jTree1;
    private DefaultTreeModel modelo;

    public DefaultTreeModel getModelo() {
        return modelo;
    }

    public JTreeFile() {
    }

    public JTreeFile(JTree jTree1) {
        this.jTree1 = jTree1;
    }

    public void setJTree(JTree jTree1) {
        this.jTree1 = jTree1;
    }

    /**
     * Metodo que permite enlazar los escuchas de eventos 
     * y permite actualizar 
     */
    public void init() {
        //creamos el nodo principal
        DefaultMutableTreeNode top = new DefaultMutableTreeNode("Directorio");
        //creamos un modelo con el nodo que creamos principal
        modelo = new DefaultTreeModel(top);
        // seteamos el modelo y el escucha al componente 
        jTree1.setModel(modelo);
        jTree1.addTreeExpansionListener(this);
        //extraemos todas las unidades disponibles en caso que tengamos C, D o otra
        for (File f : File.listRoots()) {
            DefaultMutableTreeNode raiz = new DefaultMutableTreeNode(f);
            //añadimos el nodo a la raiz
            top.add(raiz);
            //hacemos un recorrido de dos niveles a partir de cada una unidad
            actualizaNodo(raiz, f);     
        }
    }

    private boolean actualizaNodo(DefaultMutableTreeNode nodo, File f) {
        //quitamos lo que tenga el nodo 
        nodo.removeAllChildren();
        //recursivamente mandamos actualizar
        return actualizaNodo(nodo,f,2); 
    }
    
    /**
     * A partir de un nodo enlista los archivos y los agrega como nodo 
     * @param nodo Es el nodo que tenemos parcialmente como raiz
     * @param f es el archivo que se enlaza con la raiz 
     * @param profundidad el numero de subdirectorios que se quiere que escarbe
     * @return 
     */

    private boolean actualizaNodo(DefaultMutableTreeNode nodo, File f, int profundidad) {
       File[] files = f.listFiles(); // de el nodo que llega listamos todos sus archivos
       if(files!=null && profundidad>0) //permite detener la recursividad si ya llego al limite 
       {   
           for(File file: files)  // recorre todos los archivos 
           {
               DefaultMutableTreeNode nuevo = new DefaultMutableTreeNode(file);
               //vuelve a mandar en caso que sea directorio 
               actualizaNodo(nuevo, file,profundidad-1); 
               nodo.add(nuevo); //crea el nodo
           }
       }
       return true; 
    }
    /**
     * Metodo que se ejecuta al expandir alguno de los nodos
     * @param event 
     */
    @Override
    public void treeExpanded(TreeExpansionEvent event) {
        TreePath path = event.getPath(); // Se obtiene el path del nodo
        DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
        // verifica que sea nodo valido
        if(node==null || !(node.getUserObject() instanceof File) ) return; 
        File f = (File) node.getUserObject();
        actualizaNodo(node, f);  //actualiza la estructura
        JTree tree = ( JTree) event.getSource(); 
        DefaultTreeModel model = (DefaultTreeModel)tree.getModel(); 
        model.nodeStructureChanged(node);
    }

    @Override
    public void treeCollapsed(TreeExpansionEvent event) { }

}

La clase la pueden encontrar en un pequeño ejemplo que dejo a continuación

 

 

[LeapMotion] Hola Mundo, linux SDK + Java

Para los que nos gusta un poco la programación estos dispositivos son muy interesantes, por lo que vamos a hacer un pequeño programa que nos permita leer datos de un leapMotion, vamos a empezar con un pequeño Hola Mundo.

Imagen de leapmotion.com

LeadMotion es un gadget muy interesante para trabajar con realidad aumentada, prácticamente consiste en detectar los movimientos de las manos, bueno un video vale mas que mil palabras por lo que lo dejo.

Interesante la verdad con lo que se puede hacer, pero vamos a entrar en materia, lo primero que haremos es configurar el entorno de desarrollo en mi caso utilizaremos una distribución de ubuntu, java 1.8 y el SDK de leapmotion en su versión 2.2.2 que la puedes descargar en  la pagina de desarrolladores oficial. 

Descomprimiremos la carpeta en una ubicación cualquiera, y posteriormente instalaremos el software que viene en ella, que como es una extensión de deb con el mismo centro de software lo puedes instalar. 

En mi caso instalamos el x64 por la arquitectura y la distribución que se tiene instalado, una vez veras que los sensores del leapmotion se encienden.

Abriremos nuestro proyecto de netbeans en este caso usaremos un tipo de movimiento o gesto que detecta el leadmotion que sera movimientos circulares, y la intensión es hacer un contador que al dar movimientos circulares un contador aumente si es que va en sentido a las manecillas del reloj, de lo contrario disminuiría.

Imagen de la pagina de desarrolladores de leapmotion

Lo primero vamos a hacer es crear un proyecto nuevo de Netbeans, y agregar a las librerias el sdk, a ir a la carpeta del LeapSDK -> Lib, buscaremos el archivo LeapJava.Jar y lo agregamos al proyecto. 

Crearemos un listener que nos ayudara a estar escuchando los eventos 

package example;

import com.leapmotion.leap.*;
/**
 * Clase de escucha para los movimientos
 * @author luis
 */

public class ListenerLeapMotion extends Listener {

    /**
     * Metodo que detecta cuando el leapmotion esta conectado
     * @param controller 
     */
    @Override
    public void onConnect(Controller controller) {
        System.out.println("Connected");
    }

    /**
     * Metodo que detecta los eventos en el leapmotion 
     * @param controller 
     */
    @Override
    public void onFrame(Controller controller) {
        ///Obtenemos el fram que captura
        Frame frame = controller.frame();
        //habilitamos el gesto de los movimientos circulares
        controller.enableGesture(Gesture.Type.TYPE_CIRCLE);
        //configuracion para mejor deteccion 
        controller.config().setFloat("Gesture.Circle.MinRadius", 10.0f);
        controller.config().setFloat("Gesture.Circle.MinArc", .5f);
        controller.config().save();
        
        //sacamos una lista de los eventos que se presenten 
        GestureList lista = frame.gestures();
        //verificamos que haya pasado algo
        if (!lista.isEmpty()) {
            //recorremos entre los eventos que ocurrieron 
            for (Gesture gesture : lista) {                
                switch (gesture.type()) {
                    //Si el evento fue movimientos circulares
                    case TYPE_CIRCLE:                       
                        //instancia de un objeto para el movimiento
                        CircleGesture circle = new CircleGesture(gesture);
                        //a partir de un posicionamiento verificamos a que sentido esta el movimiento
                        if(circle.pointable().direction().angleTo(circle.normal())<= Math.PI/2)                            
                        {  //si se da en sentido del reloj (limite 255)
                            if(LeapMotion.intensidad<255)
                                    LeapMotion.intensidad++; //aumenta el contador
                        }
                        else {
                                if(LeapMotion.intensidad>0)
                                    LeapMotion.intensidad--; //disminuye el contador
                                }
                        System.out.println(LeapMotion.intensidad); //imprimo el contador
                        break;

                }
            }
        }
    }

}

Despues vamos a crear un archivo Main agregando el listener 

package example;

import com.leapmotion.leap.*;
import java.io.IOException;

/**
 *
 * @author luis
 */
public class LeapMotion {

    //variable estatica que almacena el valor segun los movimientos
    public static int intensidad = 0;

    public static void main(String... a) {
        //instanciamos de nuestra clase de escucha 
        ListenerLeapMotion listener = new ListenerLeapMotion();
        //instanciamos la clase para control de los datos 
        Controller controller = new Controller();
        //añadimos el escucha para que tome los eventos 
        controller.addListener(listener);        
        System.out.println("Presiona algo para salir");
        try {
            //detemos el programa hasta que presionemos algo
            System.in.read();
        } catch (IOException e) {
            System.out.println("Ocurrio un error");
        }

        //Se remueve el listener
        controller.removeListener(listener);

    }

}

Para que pueda ser ejecutado hay que ir a la carpeta de LeapMotionSDK/lib/x64(en mi caso) y copiar la ruta para agregarla como argumento en la ejecución como se ve en la pantalla siguiente: 

Despues veras en la consola los valores que van aumentando según tu movimiento de la mano. 

[Galileo] Hacer una caminata o serie de luces con 4 led

Regresando un poco al trabajo con galileo, vamos a hacer un recorrido o caminata con leds programado con la tarjeta de galileo de arduino.

Para esto pondremos cuatro led a los cuales siguiendo el siguiente diagrama del led conectaremos las salidas del 4 al 7 a la conexión de anodo de cada uno de los led. Para las conexiones de cátodo solo conectariamos a una resistencia de 220 o 330 ohms la cual el otro extremo a una salida a tierra de galileo.

Foto de www.zazzle.es

 

Una vez que hicimos las conexiones podemos crear nuestro código en este caso tendríamos que abrir el IDE para galileo o teclear el siguiente código

//salida en la que vamos a empezar el encendido
int cont=4; 
//bandera para poder regresar 
boolean ban=true; 
void setup() {
  //empezamos con el cuatro  
  int led=cont; 
  //activamos todas como salida desde el 4
  for(;led<=7;led++)
    pinMode(led,OUTPUT); 

}

void loop() {
  //inicia encendiendo el led 4 y en cada vuelta va aumentando
  digitalWrite(cont,HIGH);
  //esperamos un tiempo
  delay(500); 
  // apagamos el led que encendimos despues del tiempo
  digitalWrite(cont,LOW);
  //si la bandera esta activida va aumentando si esta falsa va disminuyendo
  if(ban) 
    cont++;  
  else
    cont--; 
  // si el contador llego al final entonces empieza a regresar
  if(cont==8 && ban)
    ban=false;
  else if(cont==3 && !ban) 
    ban=true;
}

Puedes ver los ejercicios en: 

Todo el contenido de los post de arduino son basados en la información que recibí en el curso de Galileo patrocinado por Intel en el Cinvestav de Guadalajara en Noviembre 2014. 

Comunidad de galileo: 

https://engage.intel.com/community/es/galileo