¿Cursando fundamentos de programación en la UNED? Tengo un regalo para tí. Parte 2.

Hola a todos aquellos interesados y cursando la asignatura de fundamentos de programación de la UNED. Con dos días de retraso con respecto a la fecha indicada en el planning, publico una solución a la práctica 3. El programa imprime la hoja de calendario correspondiente a un mes comprendido entre Enero de 1601 y Diciembre de 3000.
El código se encuentra comentado para una fácil comprensión. Espero que os sea de ayuda. Simplemente decir que no encontré un mecanismo en condiciones para el procedimiento que imprime el calendario, así que al final me decanté por hacerlo utilizando el comando "printf" tantas veces como fuera necesario.
El código fuente lo podéis encontrar aquí.

Recordar que las dos primeras prácticas las podéis encontrar aquí

Fritzing, mucho más que software de diseño de PCB

Últimamente venía pensando que sería interesante para mí adentrarme más en el mundo del diseño de circuitos impresos. Si bien en la carrera estudiamos al respecto, no lo hicímos con gran profundización. Así que me puse manos a la obra y por el camino apareció Fritzing. En el sitio web lo definen, no solo como una herramienta software para el diseño de layouts, sino también como una iniciativa open-source hardware y una comunidad virtual que permite a los usuarios documentar, enseñar y compartir sus proyectos electrónicos. Y bien que lo han conseguido, a tenor de lo que se puede ver en el apartado de proyectos de su sitio web. Cientos y cientos de proyectos electrónicos y muchos de ellos utilizando Arduino, lo cuál me viene en este momento como anillo al dedo.

La herramienta software se encuentra en este momento en fase beta, aunque la he estado probando y no he encontrado problema alguno. Destacar que es realmente sencillo y visual el montar tu circuito virtual y obtener el layout en caso de que queramos crear u ordenar nuestra tarjeta de circuito impreso PCB. Podéis encontrar un videotutorial básico aquí, aunque hay realmente mucha documentación en Internet al respecto. Como punto negativo (a mi modo de ver bastante negativo) decir que no permite la simulación de circuitos. Según indican en su web, la idea es montar el circuito real y, una vez comprobado que funciona, documentarlo mediante Fritzing y obteniendo la PCB si así lo deseamos.

Aspecto visual de la aplicación

Crear una base de datos básica de clientes en Java

Unos pocos días atrás creé una entrada en la cuál mostraba una base de datos para clientes (por ejemplo) que había creado utilizando el software y lenguaje de programación Gambas. Si bien en aquel programa utilizaba una base de datos SQLite para almacenar los datos, en este programa se almacena en la memoria del ordenador. Quedo por lo tanto en mi lista de tareas el realizar la base de datos en Java almacenando datos en un servidor. 

La aplicación consiste en una ventana principal que contiene una tabla que muestra la lista de clientes guardados. Esa ventana permanece hasta que se realiza alguna de las tres acciones posibles, que son dar de alta a un nuevo cliente, modificar un cliente o dar de baja a un cliente previamente almacenado. Al elegir la opción de alta de un nuevo cliente aparecerá sobre la ventana principal un nuevo panel con cuadros de texto para introducir los datos y el botón de guardar. En caso de que la opción elegida sea modificar o borrar un cliente, el panel que aparecerá contendrá cuadros de texto para buscar un determinado cliente y además otros cuadros de texto que muestran el cliente sobre el que realizar la opción que se desee. Personalmente pienso que la interfaz que he creado es bastante mejorable, pero la utilidad y funcionalidad que quería darle las tiene.

Decir que la lista de clientes almacenados se guarda en un ArrayList. Encontré información muy interesante con respecto a este tipo de elementos aquí. Como de cada cliente se almacena el nombre y los dos apellidos, pues la lista está formada por conjuntos de ArrayList, teniendo por tanto una lista ArrayList<ArrayList<String>>. Para recorrer los elementos de la lista he utilizado un ListIterator, y para buscar un determinado cliente el método de ArrayList "contains". Podeis ver y descargar el código fuente en el enlace al final de la entrada.

Aspecto de la ventana principal

Aspecto al seleccionar la opción de alta de cliente

Aspecto de la ventana añadiendo nuevos clientes

Ventana de modificar cliente con cuadros de búsqueda

 Podéis descargar el código fuente desde aquí.

Tweaks estéticos para Lubuntu. Efecto exposé, shadows, aerosnap...

Como hemos citado anteriormente, Lubuntu está enfocada a ser rápida, ligera y con poco consumo de recursos. Eso tiene sus ventajas (evidentes), pero también acarrea algunos inconvenientes, como puede ser el de no tener efectos de escritorio avanzados por defecto. Hablo de efectos tales como AeroSnap, Exposé o Shadows, que, a mi modo de ver, no solo son efectos estéticos sino que también pueden llegar a ser prácticos (especialmente AeroSnap).

Aunque los usuarios de Linux disponemos de Compiz, este requiere bastantes recursos y se sale un poco de la filosofía de Lubuntu. Por lo tanto aquí trataré de explicar tips para poder tener efectos de escritorio que consuman pocos recursos.

• AEROSNAP

El primero de ellos y al que más utilidad le encuentro es el efecto AeroSnap, que consiste en que dos ventanas quedan divididas ocupando cada una de ellas la mitad, lo que permite trabajar en una mientras vemos la otra. La explicación de cómo instalarlo la podéis encontrar aquí. Básicamente consiste en modificar el archivo "lubuntu-rc.xml". Para ello, abrimos LXTerminal y ejecutamos:

gksu leafpad ~/.config/openbox/lubuntu-rc.xml

En el archivo de texto que aparece se encuentra básicamente la configuración de combinaciones de teclas que realizan alguna función en nuestro sistema. Encontraremos algunas de ellas, como subir y bajar el volumen, modificar el brillo de la pantalla, etc.

Con el editor de texto abierto, buscamos la línea que contiene el siguiente texto:

<chainQuitKey>C-g</chainQuitKey>

y debajo de ella pegamos el siguiente código:

<!-- Aero Snap for Openbox Begin Code-->

    <keybind key="W-Left">        # HalfLeftScreen

      <action name="UnmaximizeFull"/>

      <action name="MoveResizeTo">

        <x>0</x>

        <y>0</y>

        <height>97%</height>

        <width>50%</width>

      </action>

    </keybind>

    <keybind key="W-Right">        # HalfRightScreen

      <action name="UnmaximizeFull"/>

      <action name="MoveResizeTo">

        <x>-0</x>

        <y>0</y>

        <height>97%</height>

        <width>50%</width>

      </action>

    </keybind>

    <keybind key="W-Up">        # HalfUpperScreen

      <action name="UnmaximizeFull"/>

      <action name="MoveResizeTo">

        <x>0</x>

        <y>0</y>

        <width>100%</width>

        <height>50%</height>

      </action>

    </keybind>

    <keybind key="W-Down">        # HalfLowerScreen

      <action name="UnmaximizeFull"/>

      <action name="MoveResizeTo">

        <x>0</x>

        <y>-0</y>

        <width>100%</width>

        <height>50%</height>

      </action>

    </keybind>

<!-- Aero Snap for Openbox End Code-->

Guardamos el archivo, cerramos la ventana y volvemos al terminal, donde introducimos:

openbox --restart

Cerramos la terminal y ya podemos comprobar nuestra nueva funcionalidad pulsando la combinación de teclas windows y botón derecho, izquierdo, arriba o abajo, en función de dónde queramos colocar nuestra ventana.

Efecto aerosnap con ventanas separadas verticalmente

Efecto aerosnap con ventanas separadas horizontalmente

• EXPOSÉ

El segundo efecto del que os hablo es Exposé. Podéis encontrar una explicación completa de instalación y configuración aquí. Básicamente consiste en instalar el paquete Skippy-XD y volvemos a modificar el archivo "lubuntu-rc.xml" que cambiamos para el efecto anterior. Para ello, de nuevo en una terminal

gksu leafpad ~/.config/openbox/lubuntu-rc.xml

Buscamos desde el editor de texto la línea que contiene

<chainQuitKey>C-g</chainQuitKey>

y debajo de ella pegamos el código siguiente

<!-- Start Expose for LXDE-->

<keybind key="A-grave">

     <action name="Execute">

       <command>skippy-xd</command>

     </action>

   </keybind>

<!-- End Expose for LXDE-->

Guardamos el archivo, cerramos la ventana y volvemos al terminal, donde ejecutamos

openbox --restart

Ahora si introducimos la combinación de teclas Alt y la tecla justo encima del tabulador izquierdo obtendremos el efecto exposé.

Efecto exposé

• SOMBRAS Y TRANSPARENCIAS

Otro efecto que podemos aplicar y sin apenas consumo de recursos son las sombras de las ventanas y las transparencias de estas cuando se encuentran en segundo plano. Para ello usaremos compton, el cuál podemos encontrarlo en versiones de 32bits o de 64bits. Tras instalarlo podemos configurarlo siguiendo el tutorial de Gespadas. Si queremos incluirlo como una aplicación de inicio (para que cada vez que arranquemos el sistema se encuentre en ejecución), podemos hacerlo editando el archivo "/etc/xdg/lxsession/Lubuntu/autostart". Para ello, introduce en una terminal el siguiente comando:

sudo leafpad /etc/xdg/lxsession/Lubuntu/autostart

y añade la siguiente línea al final

@compton -cC -i 0.8 -e 0.7 -fF -I 0.065 -O 0.065 -D 6 -m 0.8

Estos parámetros son los que a mí me gustan, aunque lógicamente puedes ponerlos a tu gusto.

Efectos de sombras y transparencias

• ZOOM

Otro efecto de escritorio que podemos utilizar, y me da la impresión que es bastante desconocido para Lubuntu, es el del zoom, que consiste en aumentar una zona determinada del escritorio. Esto lo podemos hacer con la aplicación xzoom, el cuál, si bien no es tan dinámico como el efecto lupa de compiz, puede darnos resultados bastante buenos, sobre todo si quieres hacer un screencast o simplemente necesitas hacer un zoom  para leer alguna letra pequeña. Para instalarlo basta con escribir en el terminal:

sudo apt-get install xzoom

O bien entrar en el Gestor de paquetes Synaptic, buscar xzoom e instalarlo.

Al ser un programa desde consola, que puede resultar incordioso, pero tenemos la posibilidad de hacer que se ejecute mediante una combinación de teclas, de forma idéntica a como lo hacíamos con el efecto exposé. Para ello, escribe en una terminal

gksu leafpad ~/.config/openbox/lubuntu-rc.xml

Buscamos desde el editor de texto la línea que contiene:

<chainQuitKey>C-g</chainQuitKey>

y debajo de ella pegamos el código siguiente:

    <!-- Zoom in the desktop using xzoom-->

    <keybind key="A-z">

      <action name="Execute">

        <command>xzoom -source 250x150 -mag 2</command>

      </action>

    </keybind>

Guardamos el archivo y ya podemos hacer un zoom utilizando la combinación Alt-z. Por supuesto la combinación de teclas que le asignamos, el zoom, o el tamaño de la porción a aumentar son modificables. Un tutorial lo puedes encontrar aquí.

Efecto zoom de la parte inferior derecha del escritorio

• NOTIFICACIONES

Para terminar, un último pequeño tip que consiste en modificar las preferencias de las notificaciones en Lubuntu. Por defecto, las notificaciones aparecen durante 10 segundos, en la parte superior derecha y con un tema predeterminado. Si queremos cambiar todos estos parámetros, basta con ejecutar en un terminal:

xfce4-notifyd-config

Y ya os aparecerá la ventana de preferencias, que permite modificar el tema, la posición y el tiempo de las notificaciones. Mis preferencias son el tema Smoke, la posición abajo a la derecha y el tiempo de retardo de 4 segundos. La opacidad al 72%.

Notificaciones modificadas

En los vídeos a continuación muestro cada uno de los efectos en ejecución así como el procedimiento de instalación (para aquellos no muy familiarizados con la terminal).

¿Cursando fundamentos de programación en la UNED? Tengo un regalo para tí.

Actualmente estoy cursando la asignatura Fundamentos de Programación del Grado de Ingeniería Informática de la UNED. Para el que también esté cursándolo, sabrá que hay una parte práctica de la asignatura consistente en 4 prácticas. Por si os puede servir de ayuda, voy a tratar de colgar todas, con comentarios para que puedan entenderse, aquí en mi blog. De momento, puedes encontrar las dos primeras aquí. Espero que os sirva...

Actualización 1: Ya se encuentra disponible la práctica 3. La podéis encontrar aquí.

¿Un coche con control remoto con Arduino? ¡Vamos a intentarlo!

Desde bien pequeño he tenido una gran afición por los coches teledirigidos. Recuerdo perfectamente todos y cada uno de los que he tenido, he incluso siendo ya mayor decidí comprarme uno. Siempre me había interesado por saber cómo están hechos, cómo es posible controlarlo remotamente.
Un buen día, indagando por la web de la Escuela de Ingenierías Industriales de la Unex, descubrí que unos excompañeros míos habían creado un coche con control remoto (podéis encontrar un vídeo aquí)... y me encantó. Quedó en mi recámara la idea de hacer alguno. Y con la reciente adquisición de la tarjeta arduino y unas pequeñas adquisiciones más creo que ese día se acerca. Si observáis el vídeo podréis comprobar que montaron todo desde cero. Yo no llegaré a esos extremos, mi idea está más centrada en la programación de la tarjeta, aunque es evidente que habrá que hacer algo de manualidades. Iré comentando la evolución, espero tenerlo funcionando en un par de meses...

Coche con Arduino

Manejo avanzado de Microsoft Access 2007. Las consultas e informes con parámetros y el panel de control

Puede resultar raro que hable de temas relacionados con la suite ofimática de Microsoft en este blog, y es que ciertamente no la utilizo (utilizo libreoffice). Sin embargo, mi hermano me preguntó unas dudas sobre Access 2007 y traté de ponerme al día con esta aplicación. Si bien no conseguí resolver sus dudas (más bien me las resolvió el a mí), pudimos lograr alcanzar algunos de los objetivos fijados.

Los videotutoriales que muestro a continuación tratan de explicar diferentes aspectos de nivel medio-avanzado de Access, ya que no logré encontrar mucha información al respecto ni en Internet ni en tutoriales.

El primer videotutorial explica cómo crear consultas con parámetros y crear informes asociados a esas consultas.

El enlace al que hago referencia en el vídeo es éste

En este segundo videotutorial se explica cómo introducir los parámetros deseados en un formulario para posteriormente ejecutar la consulta

Y en este último se explica la herramienta de "panel de control" de Access.

Espero que os sirva y os haya resultado de interés.

¿Tienes linux y quieres utilizar la suite de Microsoft? Quizá te interese éste enlace o éste otro.

Videodemostración de Lubuntu

Lubuntu, como ya comenté en otra entrada, está pensado para ser ligero y rápido, incluyendo aplicaciones que cumplan con ese cometido. Pero ¿cómo de rápido se ejecuta este sistema operativo? La respuesta la podéis ver en el vídeo a continuación, en el que el sistema se ejecuta en un netbook de recursos limitados. Tiempos de arranque inferiores a 30 segundos, de apagado inferiores a 5 y ejecución de múltiples apliaciones sin resentirse...

Crear una base de datos de clientes en Gambas

Continuo mi andadura con la programación en Gambas, y esta vez le toca el turno a las bases de datos, con las que también estoy trabajando en Java. Siguiendo el libro de Gambas de Daniel Campos y José Luis Redrejo he creado una base de datos para clientes. Utiliza una SQLite aunque cuando realice la aplicación en Java lo haré con MySQL, que parece más extendida y trabaja utilizando un servidor.

La aplicación se encarga de mostrar una lista de los clientes actuales en una ventana principal y añade las opciones de añadir, modificar o borrar. Para la opción añadir se abre una nueva ventana para introducir los caracteres. 

Con respecto al libro citado anteriormente tuve que realizar distintas modificaciones, bien porque la versión actual de Gambas (3.3.3) difiere de la utilizada para el libro, o bien porque mi aplicación, aunque parecida, tiene algunas diferencias. En el siguiente vídeo se muestra el proceso de creación de una nueva base de datos, que parece ser una opción que a muchos usuarios les cuesta encontrar

El aspecto de la ventana principal cuando aún no hay datos de ningún cliente es

Aspecto general de la aplicación

Mientras que con datos ya introducidos pasa a ser

Aspecto con datos introducidos

Esta es la ventana para añadir o modificar de la base los datos de un cliente

Ventana para añadir o modificar cliente

Podéis descargar el código fuente y el archivo ejecutable aquí

Tratando de entender y utilizar alguna API

Desde hace tiempo llevo leyendo el blog de atareao, que es un blog dedicado a Ubuntu y software libre. Uno de los logros que me parecen más interesantes de entre los que este bloguero ha creado son las lentes para Ubuntu, entre ellas Yavol. Tan interesantes me parecieron, que quise informarme sobre cómo las había hecho. Fue ahí donde conocí el concepto de API, que me interesó tanto que quedó en mi recámara guardado para cuando tuviese tiempo, intentar usar alguna.

Actualmente estoy en la parte final de un curso de programación Java utilizando el entorno de programación multiplataforma Netbeans. Así que se me ocurrió la idea de generar una aplicación gráfica con netbeans utilizando la API de Google Translate. Busqué algo de información que me sirviese como punto de partida y encontré información tan interesante como la que podéis ver aquí en un screencast. Así que me puse manos a la obra y pronto obtuve resultados, pero no los esperados (más adelante comentaré por qué). En la siguiente imagen podéis ver el aspecto gráfico de la apliación creada

Aspecto gráfico de la aplicación

El código tuve que modificarlo con respecto al que se incluye en el screencast del enlace anterior, ya que utilicé una versión de la API  más reciente. El código completo lo podéis encontrar debajo

import com.google.api.translate.*;  //Importa todas las clases de la api

public class ApiJava extends javax.swing.JFrame {

    /**
     * Creates new form ApiJava
     */
    public ApiJava() {
        initComponents();
    }

    /**
     * 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() {

        panelContenedor = new javax.swing.JPanel();
        txtEspanol = new javax.swing.JTextField();
        btnTraducir = new javax.swing.JButton();
        txtIngles = new javax.swing.JTextField();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        panelContenedor.setName("Traductor básico"); // NOI18N

        txtEspanol.setPreferredSize(new java.awt.Dimension(40, 20));

        btnTraducir.setText("Spa->Eng");
        btnTraducir.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                btnTraducirActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout panelContenedorLayout = new javax.swing.GroupLayout(panelContenedor);
        panelContenedor.setLayout(panelContenedorLayout);
        panelContenedorLayout.setHorizontalGroup(
            panelContenedorLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(panelContenedorLayout.createSequentialGroup()
                .addComponent(txtEspanol, javax.swing.GroupLayout.PREFERRED_SIZE, 87, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addComponent(btnTraducir)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addComponent(txtIngles, javax.swing.GroupLayout.DEFAULT_SIZE, 80, Short.MAX_VALUE))
        );
        panelContenedorLayout.setVerticalGroup(
            panelContenedorLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(panelContenedorLayout.createSequentialGroup()
                .addGap(15, 15, 15)
                .addGroup(panelContenedorLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(panelContenedorLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                        .addComponent(txtEspanol, javax.swing.GroupLayout.DEFAULT_SIZE, 34, Short.MAX_VALUE)
                        .addComponent(btnTraducir))
                    .addComponent(txtIngles)))
        );

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(panelContenedor, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addComponent(panelContenedor, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 12, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>

    private void btnTraducirActionPerformed(java.awt.event.ActionEvent evt) {                                            
        
        try {
            String textoOriginal=(String)this.txtEspanol.getText(); //Recoge el texto
            Translator traslador=new Translator();  //Instancia un objeto de la clase Translator
            String textoTraducido=traslador.translate(textoOriginal, Language.SPANISH, Language.ENGLISH);
            //Convierte el texto original de Spanish a English y lo almacena
            //en textoTraducido
            this.txtIngles.setText(textoTraducido); //Enviamos el textoTraducido a la caja de texto
        }catch (Exception e){   //Chequea excepciones
            System.out.println("Error"+e.getMessage());
        }
    }                                           

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* 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(ApiJava.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(ApiJava.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(ApiJava.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(ApiJava.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new ApiJava().setVisible(true);
            }
        });
    }
    // Variables declaration - do not modify
    private javax.swing.JButton btnTraducir;
    private javax.swing.JPanel panelContenedor;
    private javax.swing.JTextField txtEspanol;
    private javax.swing.JTextField txtIngles;
    // End of variables declaration
}

Cuando todo estaba perfectamente compilado y parecía listo para funcionar, la ejecución de la aplicación me devolvió el siguiente error

Can't parse the response from Google Translate service into JSON object
org.json.JSONException: JSONObject["responseData"] is not a JSONObject.

Tras una búsqueda por internet averigué que este error está relacionado con que ahora la API  de Google Translate es de pago, así que todo mi esfuerzo se fue por la borda porque por simple curiosidad no voy a pagar para usarla.

En un futuro tengo pensado utilizar alguna otra, esta vez cerciorándome de que es gratuita. De momento he pensado en la de OpenStreetMap. ¿Me recomendáis alguna?

Mi Arduino ya está aquí... y qué es Dealextreme

Como comenté hace poco, estaba pensando en adquirir una tarjeta arduino para realizar algunos experimentos. El primero de ellos consistía en utilizar un LCD Hitachi. Pues después de una buena búsqueda de información sobre qué tipo de tarjeta de Arduino me convenía, me decanté por la Arduino Uno, que es básicamente la que más recomiendan para principiantes por su compatibilidad con complementos Arduino, y por la cantidad de información existente sobre ella. Aunque aún necesito algunas cosillas más (están en camino) ya tengo las piezas más importantes, como muestro en la siguiente imagen

Placa Arduino Uno, display Hitachi HD44780 y potenciómetro

Mencionar que los precios de estas tarjetas y sus accesorios (sensores y placas) pueden variar ostensiblemente dependiendo del proveedor. Aunque no es mi objetivo publicitar nada en este blog, ni obtengo ningún beneficio por ello, me siento en la tesitura de hablaros sobre Dealextreme, que es una web de ventas de gadgets a precios realmente interesantes. Proceden de china y al respecto tengo que comentar un punto a favor y otro en contra. Como punto a favor citar que los gastos de envío son totalmente gratuitos. Por contra el tiempo que tarda en llegar el producto puede estar comprendido entre 2 y 4 semanas (esto lo digo por experiencia propia). Como ejemplo de referencia de precios citar que la Arduino Uno la puedes encontrar en tiendas web habituales (incluyendo IVA y portes) por no menos de 30 €, mientras que una copia idéntica la tienes en Dealextreme por 15.20 $ (la puedes encontrar aquí). También disponen de multitud de sensores y complementos que seguro tendré en cuenta en próximas compras.

Aunque podría intentar realizar alguna prueba, estoy esperando una regleta de conexión, así que mientras tanto me centraré en la programación software. 

Comparativa de tarifas móviles en "En Naranja"

Desde el blog de Xakatamovil me he percatado de una comparativa actualizada de tarifas móviles, tanto para hablar y navegar como sólo para hablar. La podéis encontrar en la web de "En Naranja". Para ver la comparativa, haz click aquí.

Pensando en adquirir una tarjeta de Arduino

Arduino es una plataforma libre de hardware y software. Las placas hardware pueden ser hechas a mano o compradas directamente y el software para programarlas está disponible para Linux, Windows y Mac. Está muy extendida, y dispone de una gran cantidad de complementos que podemos adquirir para darle vida.

Placa Arduino MEGA

Como ya dispongo de un display LCD basado en el controlador Hitachi HD44780 que usé en mi etapa de estudios, he pensado que quizá podría trastear un poco y programar la placa para controlar el LCD (en su día lo hice, pero utilizando el puerto paralelo de un PC). 

Display LCD HD44780 de Hitachi

Para realizar todo esto tengo que elegir entre las diferentes placas de Arduino existentes, aunque para el control del LCD una placa básica puede ser suficiente. Con precios que varían desde los 16 € hasta los 90 € aproximadamente, ofrecen una buena variedad. 

Una búsqueda por internet ha servido para cerciorarme de que esta idea que acabo de tener ya ha sido llevada a cabo. Se puede realizar utilizando un PIC o utilizando Arduino. También podemos ver el funcionamiento en un vídeo aquí, así como un tutorial desde la propia web de Arduino 

Como manual para la programación del controlador del LCD voy a utilizar el tutorial que mi exprofesor Jose Ignacio Suárez Marcelo preparó para los alumnos.

Esquema de conexión entre la placa y el LCD

Os mantendré informados en cuanto tenga novedades.

Desarrollando una aplicación gráfica para apagar el sistema automáticamente

Hay comandos en GNU/Linux que permites realizar un apagado de nuestro sistema. Este apagado se puede hacer, bien indicando en cuántos minutos queremos que se apague, o bien indicando la hora. Si queremos la opción de minutos restantes:

shutdown -h minutos

Mientras que si preferimos indicar la hora:

shutdown -h hh:mm

En caso de haber introducido la opción de apagado automático y que queramos cancelarla:

shutdown -c

Utilizando estos comandos y la potencia de gambas podemos desarrollar fácilmente una aplicación gráfica que permita el apagado del sistema. Veámos cómo hacerlo. 

Lo primero es crear el diseño de nuestra aplicación. En mi caso he decidido no esmerarme mucho, y el resultado obtenido es 

Aspecto visual

En esta ventana tenemos la opción de elegir ambos tipos de apagado y además nos muestra el comando que se envía en consola. Por simplicidad a la hora de realizar la programación, requiere que en el caso de elegir la opción "Apagar a las" se introduzcan dos dígitos en cada recuadro y que los valores sean válidos. A continuación se muestran ejemplos con las diferentes opciones en funcionamiento

Ejecutando la opción "Apagar en"

Ejecutando la opción "Apagar a las"

Ejecutando la opción "Cancelar apagado"

El código que ejecuta esta aplicación es

' Gambas class file

Public minutosRestantes As String
Public minutos As String
Public hora As String
Public comando As String
Const cancelar As String = "gksu -l shutdown -c"
Const apagar As String = "gksu -l shutdown -h "

Public Sub _new()

End

Public Sub Form_Open()

End

Public Sub btnCancelar_Click()

  comando = cancelar  'Asignamos como comando la opción cancelar
  txtComando.text = comando
  Shell comando 'Enviamos el comando a la shell
  

End

Public Sub btnAceptar_Click()

  If rdbCuentaAtras.value = True Then   'Comprueba si el boton de cuenta atras esta activo
    minutosRestantes = vlbMinutosRestantes.Text   
    comando = apagar & minutosRestantes   'Si lo está, envía el comando de cuenta atrás
    txtComando.text = comando
    Shell comando
  Else 'Si no lo esta, entonces se envia la hora a la cual queremos apagar la computadora
    hora = vlbHora.Text
    minutos = vlbMinutos.Text
    comando = apagar & hora & ":" & minutos  'Concatena para formar el comando
    Shell comando
    txtComando.text = comando
  Endif  '

End

Gambas y el comando "shell"

Shell es un intérprete de comandos que permite controlar el funcionamiento de la computadora. En GNU/Linux disponemos de la terminal, con la cuál podemos, introduciendo los comandos en modo texto, acceder al sistema.
Indagando un poco en el foro de gambas en español me he percatado de una posibilidad que ofrece esta herramienta que aumenta exponencialmente las posibilidades a la hora de crear programas. Y no es otra cosa que el comando SHELL que se encarga de pasar un comando al sistema. Una guía de comandos la podemos encontrar en el tutorial Linux de tecnum  o en la documentación de Ubuntu en español. Veamos un ejemplo simple que, aunque a priori no muestre toda la grandeza de este comando de gambas, permite dar una idea. El ejemplo consiste en actualizar nuestro sistema. Aunque existe aplicaciones gráficas que permiten hacer esto, también se puede hacer, como todo desde la terminal, de la forma que se muestra a continuación

Evidentemente, es un método que requiere conocer los comandos y que para el usuario puede resultar complejo. Sin embargo, esto mismo se puede hacer gráficamente con una aplicación muy simple. Consiste en un simple botón que al ser pulsado se produce el envío de ese comando a la shell. La interfaz gráfica es

Pulsando este botón se ejecutará la actualización del sistema. El código el siguiente

' Gambas class file

Public Sub _new()
End

Public Sub Form_Open()
End

Public Sub btnActualizar_Click()
Shell "gksu -l apt-get update && gksu -l apt-get upgrade" Wait
End

Como podéis observar el código resulta bastante sencillo. Pronto espero publicar una aplicación más interesante... el apagado automático del sistema.

¿Algún visual basic para linux? Sí, Gambas

Llevo unos meses dedicando tiempo a la programación. Aunque ya tenía conocimientos previos, eran muy básicos, así que decidí dar un empujón al tema. Si has leído la entrada anterior, habrás observado que uno de los tutoriales que podemos encontrar en tecnum está dedicado a Visual Basic, que es para principiantes una de las opciones más adecuadas. Este software permite implementar aplicaciones gráficas en muy poco tiempo. Al estar dirigido a sistemas Windows, decidí buscar algún equivalente para Linux. La respuesta la encontré rápido: Gambas. Aunque hace un tiempo escuché acerca de este proyecto, pensé que estaría actualmente abandonado. Nada más lejos de la realidad, han sacado a la luz tres versiones en aproximadamente un mes. Así que me decidí a probarlo. Si bien la interfaz puede dejar mucho que desear visualmente hablando, cumple con el cometido que andaba buscando, crear programas básicos con facilidad. Sin embargo, gambas utiliza un lenguaje muy parecido a Basic, que era hasta ayer desconocido para mí. Así que se me ocurrió la idea de comenzar a adquirir conocimientos de Basic utilizando el tutorial de tecnum y combinarlo con Gambas. Los resultados me parecen interesantes, el ritmo de aprendizaje muy bueno. También busqué algún tipo de tutorial dedicado especialmente a gambas. Fruto de esta búsqueda encontré el portal Comunidad Gambas-es, en el cuál se incluye una sección de descargas de manuales, entre ellos uno de Daniel Campos y José Luis Redrejo más que interesante (puedes descargarlo desde aquí). Combinando toda esta información me propuse realizar un primer ejemplo. A continuación voy a explicar mi primer proyecto, basado en un ejemplo calculadora muy elemental  incluido en el curso de Visual Basic. Basta con arrancar la aplicación, seleccionar la opción de generar una nueva aplicación gráfica, dar un nombre a nuestro proyecto y ya nos encontramos con algo como esto

Que viene a ser una interfaz, si bien no muy buena estéticamente, con una estructura y opciones parecidas a las que nos podamos encontrar en Visual Basic de versiones antiguas. Añadiendo los elementos necesarios a la ventana principal obtenemos

Con la interfaz ya diseñada, resta por añadir un poco de código en el Main para hacer funcional el programa

' Gambas class file

Public Sub _new()
End

Public Sub Form_Open()
End

Public Sub btnSuma_Click()
  vlbResultado.Text = Val(vlbOperando1.Text) + Val(vlbOperando2.Text)
  txtOperacion.Text = "+"
End

Public Sub btnResta_Click()
  vlbResultado.Text = Val(vlbOperando1.Text) - Val(vlbOperando2.Text)
  txtOperacion.Text = "-"
End

Public Sub btnMultiplicacion_Click()
  vlbResultado.Text = Val(vlbOperando1.Text) * Val(vlbOperando2.Text)
  txtOperacion.Text = "*"
End

Public Sub btnDivision_Click()
  vlbResultado.Text = Val(vlbOperando1.Text) / Val(vlbOperando2.Text)
  txtOperacion.Text = "/"
End
El resultado obtenido es

Espero que les haya gustado...