Rolando Palermo Rodríguez Cruz

Gadget del clima en java

2011-03-26T10:34:00.012-05:00

Luego de un tiempo sin poster (por motivos de trabajo) aquí les traigo este nuevo artículo orientado para la gente que vivimos inmersos en el mundo del desarrollo web. Y esto justamente porque mi primera experiencia laboral fuera de la universidad estuvo orientada a este campo.

Todos sabemos que el desarrollo de aplicaciones web exige un poco más que solo conocer bien el lenguaje de programación en el que estamos desarrollando nuestro proyecto (Java, PHP, ASP, etc.) pues las cuestiones de estética juegan un papel importantísimo. Aprender a editar imágenes es algo realmente muy importante en el desarrollo web y en este post vamos a crear nuestro primer gadget ya que, si bien es cierto los hay por montones en internet, siempre es bueno saber el por qué y el cómo de las cosas, a parte que nos libramos de su molesta publicidad.

Paso 1
Primero debemos registrarnos en algún servicio, en este caso lo vamos a hacer en The Weather Channel ya que lo he probado y los resultados son bastante aceptables. Hecho esto se nos va a proporcionar un enlace similar a este:

http://xoap.weather.com/weather/local/[AQUÍ DEBE IR EL CÓDIGO DE LA CIUDAD]?cc=*&dayf=5&link=xoap∏=xoap&par=[CÓDIGO]&key=[KEY]

Así como también se nos enviará una carpeta con las imágenes de los distintos tipos de climas.

Paso 2
Debemos editar la imágen que usará nuestro gadget, y aquí solamente se necesita un poco de creatividad y un buen programa. Yo uso Firewroks pues es muy completo y los resultados son excelentes.

Bueno, luego de editar nuestras fotos podemos obtener algo como esto:

Paso 3
Esta imágen será el fondo de nuestro gadget, quizás no se vea bien aún pero ahora vayamos a la programación para darle un poco más de estilo.
Nuestro gadget será programado en Java usando JSP para lo cual necesitaremos de un entorno que en nuestro caso será el Netbeans.

Creamos un nuevo proyecto

Nombramos al proyecto como JWeather

Elegimos nuestro servicio

Finalizamos la creación del proyecto

También les dejo un video donde muestro su funcionamiento y cómo debería quedarles:

Imprimir fotos a tamaño real

2011-03-10T00:26:00.006-05:00

Muchas veces tenemos problemas al querer imprimir nuestras imágenes a tamaño real, usualmente los que estamos metidos en el mundo del desarrollo digital, y buscamos soluciones como ponerlas en el MS-Word pero hoy se me ocurrió escribir una pequeña aplicación para automatizar este proceso. Adicionalmente brinda la opción de indicar el número de copias.

La idea es utilizar una impresora virtual que nos genere un archivo PDF con la imágen que queremos imprimir, luego de esto, este archivo PDF ya puede ser impreso en cualquier impresora sin tener que preocuparnos por la escala pues tendrá el tamaño adecuado.

Cualquier sugerencia será bienvenida, de todos modos espero les sea de utilidad. El video que les dejo muestra el funcionamiento de este pequeño programa.

CCNA 4 v4 chapter 2‏ exam

2010-12-21T22:04:00.002-05:00

Puntaje: 97.8

Algoritmo de QuickHull para la Cerradura Convexa con Simulación en Java

2010-11-21T10:03:00.006-05:00

Pues en este post describiré lo relacionado con el algoritmo de QuickHull para encontrar la envolvente convexa de una conjunto de puntos. Evidentemente el esquema será el mismo que se ha venido mostrando a lo largo de todos mis post relacionados con la geometría computacional.

Primero que nada, debemos comprender de qué trata este algoritmo, y no hay mejor que mediante el seudocódigo y un ejemplo donde de ponga a prueba su funcionamiento. El algoritmo de QuickHull nos dice lo siguiente:

Entonces, dada una nube de puntos como la de la imágen:

El algoritmo nos dice que como primer paso debemos seleccionar el punto más a la izquierda y el punto más a la derecha, quedándonos algo así:

Luego debemos separar en dos conjuntos, los que están a la derecha del segmento formado por los dos puntos encontrados anteriormente, y los que están a la izquierda. Estos conjuntos recibirán el nombre de S1 y S2 respectivamente.

Agregamos a la cerradura el punto min, los puntos que hallaremos al procesar el conjunto S1, el punto max y por último los puntos que hallaremos al procesar el conjunto S2.

En la pila en donde se almacenan los puntos hay dos elementos que están con un color de fondo determinado, esto es así porque quiero indicar que en estas posiciones se insertarán conjuntos de puntos que serán hallados de manera recursiva, dada la naturaleza del algoritmo.

Ahora procesaremos S1. En esta parte se llamara a la función encargada de procesar el subconjunto de puntosd. Lo que se hace es escoger el punto más lejano de la recta formada por los puntos a y b, que son las entradas para este subprocedimiento. El punto más lejano es el punto 6 y este punto no tiene ningún punto, ni a la derecha ni a la izquierda, tal como indica el seudocódigo mostrado. Entonces el resultado de procesar el subconjunto S1 será el punto 6.

Ahora es el turno del subconjunto S2. El punto más lejano es el punto 2, el cuál al formar el segmento cb no tiene puntos a su derecha, pero si a su derecha (área amarrilla), pero al formar el segmento ac, presenta un punto a su derecha. Algo que rescatar aquí es que el proesamiento de S2 nos devolverá más de un punto.

Entonces añadimos el resultado de procesar subconjunto A (región amarilla) a la pila y luego el punto 2.

Ahora, siguiendo el procesamiento anterior, el resultado de procesar la región amarilla nos retornará solo el punto 3 el cuál será añadido a la pila y terminará con la recursivad de este algoritmo al cumplir con la condición de finalización (if noEsVacio(s)), ya que no nos quedan más puntos por procesar.

Utilizando los puntos almacenados en la pila podemos generar la envolvente convexa de nuestra nube de puntos, finalizando con esto todo el proceso.

Evidentemente todo esto debe ser contrastado con un modelo que permita certificar que todo lo expuesto anteriormente es cierto y bueno, aquí les dejo una simulación que, de manera interactiva, les permitirá verificar que el algoritmo funciona.

La implementación del Algoritmo QuickHull es la siguiente:

public static List<Point2D> quickHull(List<Point2D> nube) {
    List<Point2D> cerradura = new ArrayList<Point2D>();
    Point2D min_x = new Point2D.Double(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    Point2D max_x = new Point2D.Double(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
    for(Point2D aux:nube) {
        if(aux.getX()<min_x.getX()) {
            min_x = aux;
        }
        if(aux.getX()>max_x.getX()) {
            max_x = aux;
        }
    }
    List<Point2D> S1 = puntosLado(min_x, max_x, nube);
    List<Point2D> S2 = puntosLado(max_x, min_x, nube);
    cerradura.add(min_x);
    cerradura.addAll(findHull(min_x, max_x, S1));
    cerradura.add(max_x);
    cerradura.addAll(findHull(max_x, min_x, S2));
    return cerradura;
}

public static List<Point2D> findHull(Point2D a, Point2D b, List<Point2D> S) {
    List<Point2D> cerradura = new ArrayList<Point2D>();
    Point2D c = new Point2D.Double();
    if(!S.isEmpty()) {
        List<Point2D> A = new ArrayList<Point2D>();
        List<Point2D> B = new ArrayList<Point2D>();
        c = puntosMayorArea(a, b, S);
        A = puntosLado(a, c, S);
        B = puntosLado(c, b, S);
        cerradura.addAll(findHull(a, c, A));
        cerradura.add(c);
        cerradura.addAll(findHull(c, b, B));
    }
    return cerradura;    
}

El código fuente completo lo pueden descargar aquí:

Bueno, espero que les sea de utilidad. Muy pronto postearé otros algoritmos para la cerradura convexa. No se olviden de dejar sus comentarios y críticas.

Quizás te pueda interesar también esos posts:
http://rolandopalermo.blogspot.com/2010/11/java-convex-hull-jarvis.html
http://rolandopalermo.blogspot.com/2010/09/algoritmo-de-graham-para-la-cerradura.html

Servidor Radius en Debian

2010-11-16T23:31:00.012-05:00

Evidentemente si has llegado hasta este post es porque ya sabes qué es un servidor de autenticación Radius, así que las explicaciones las dejaremos de lado.

Sin embargo, a pesar de que existen muchos artículos que abordan este tema, estos no siempre nos funcionan a la primera ^^!... Bueno, en este post trataremos de que nuestro servidor quede correctamente configurado al primer intento.

Lo primero que debemos hacer utlizar los mismos repositorios. El usar otros repositorios podría cambiar ligeramente el proceso de configuración descrito en este post. Bien, vayamos al grano, estos son mis repositorios:

#Repositorios no Libres
deb http://http.us.debian.org/debian/ lenny main contrib non-free

# Seguridad
deb http://security.debian.org/ lenny/updates main contrib
deb-src http://security.debian.org/ lenny/updates main contrib

#### Unstable (sid)
deb http://ftp.fi.debian.org/debian/ unstable main non-free contrib
deb-src http://ftp.fi.debian.org/debian/ unstable main non-free contrib
# deb http://mirrors.kernel.org/debian/ sid main contrib non-free
# deb-src http://mirrors.kernel.org/debian/ sid main contrib non-free

#### Testing
deb http://ftp.fi.debian.org/debian/ testing main contrib non-free
# deb-src http://ftp.fi.debian.org/debian/ testing main contrib non-free
# deb http://security.debian.org/ testing/updates main contrib non-free

#### Experimental
deb http://mirrors.kernel.org/debian/ experimental main contrib non-free
# deb-src http://mirrors.kernel.org/debian/ experimental main contrib non-free

Luego ejecutamos los comandos los siguientes comandos

apt-get clean
apt-get update

Instalamos los paquetes necesarios

apt-get install apache2
apt-get install mysql-server
apt-get install freeradius freeradius-mysql

Editamos el archivo de usuarios (que serían los host o o usuarios finales que harían peticiones de autenticación)

gedit /etc/freeradius/users

En el archivo hay varios ejemplos de usuarios. Descomentamos (borramos este símbolo: #) el usuario steve que viene como ejemplo. Nos quedaría algo así:

En este caso he agregado el usuario toshiba y su clave será cisco. Para probar que el servidor autentica correctamente debemos hacer lo siguiente:
En modo root primero detendremos el servicio:

/etc/init.d/freeradius stop

Iniciamos el modo debug

freeradius -X

Verificamos la autenticación por parte del servidor servidor

radtest steve testing 127.0.0.1 1812 testing123

Debemos obtener algo como esto

Sending Access-Request of id 115 to 127.0.0.1 port 1812
 User-Name = "toshiba"
 User-Password = "cisco NAS-IP-Address = 127.0.1.1
 NAS-Port = 1812
rad_recv: Access-Accept packet from host 127.0.0.1 port 1812, id=115, length=38
 Service-Type = Framed-User
 Framed-Protocol = PPP
 Framed-Compression = Van-Jacobson-TCP-IP

Con esto el servidor ya estaría listo para aunteticar usando los parámetros que trae por defecto. Evidentemente estos deben ser cambios y se le deben agregar algunas otras funcionalidades. En otro post explicaré cómo hacer que nuestro servidor autentique usando usuarios almacenados en una base de datos de MySQL.

Saludos y espero les sea de utilidad.

Algoritmo de Jarvis para la Cerradura Convexa con Simulación en Java

2010-11-16T21:46:00.008-05:00

En esta oportunidad vamos a ver el funcionamiento del algoritmo de Jarvis para la cerradura convexa. Veamos de qué trata el algoritmo:

Bueno, el seudocódigo está bastante claro, pero vamos a ver cómo funcionaría con un pequeño conjunto de puntos. Supongamos que tenemos el siguiente conjunto de puntos:

Primero seleccionamos el punto de menor coordenada y lo llamamos p.

Luego escogemos el punto que forma el menor ángulo con la horizontal, al que llamaremos q y agregamos p a la pila que guardará los puntos que forman la cerradura convexa.

Ingresamos al bucle y vamos a empezar a encontrar los puntos que forman la cerradura convexa teniendo como condición que este deberá formar el menor ángulo con la recta que forma los puntos p y q.

En la primera iteración pasaría esto:

El punto 3 es el que forma el menor ángulo por lo que pasará a formar parte de la cerradura convexa. Vayamos a la siguiente iteración.

El siguiente punto ahora es el punto 2. El punto 3 ya pasó a formar parte de la cerradura convexa. Ahora veamos la siguiente iteración.

Vemos que el punto con menor ángulo es el punto de inicio, además la condición de parada nos dice que q!=inicio. Y la siguiente iteración no se ejecutará ya que nos quedará algo como esto:

El bucle se termina y graficamos la cerradura convexa con los puntos almacenados en nuestra pila, quedándonos así:

Aca les dejo un aplet para verificar el funcionamiento de nuestro algoritmo.

La implementación del Algoritmo de Jarvis es la siguiente:

/**
 *
 * @author Rolando
 */
public static List<Point2D> jarvis(List<Point2D> nube) {
    List<Point2D> cerradura = new ArrayList<Point2D>();
    double min = 0,ang = 0;
    //O(n)
    Point2D p = new Point2D.Double();
    Point2D q = new Point2D.Double();
    Point2D pInicio = new Point2D.Double();
    Point2D posMin = new Point2D.Double();
    p = menorCoordenadaY(nube);
    pInicio = p;
    q = calcularMenorAngulo(nube, p);
    cerradura.add(p);
    while(q!=pInicio) {
        cerradura.add(q);
        min=180;
        for(Point2D aux:nube) {
            if(aux!=q) {
                ang=angulo(q,p,aux);
                if(ang<min) {
                    posMin=aux;
                    min=ang;
                }
            }
        }
        p=q;
        q=posMin;
    }
    return cerradura;
}

El código fuente completo lo pueden descargar aquí:

Bueno, espero que les sea de utilidad. Muy pronto postearé el algoritmo de QuickHull. No se olviden de dejar sus comentarios y críticas.

Quizás te pueda interesar también esos posts:
http://rolandopalermo.blogspot.com/2010/09/algoritmo-de-graham-para-la-cerradura.html
http://rolandopalermo.blogspot.com/2010/11/quickhull-java-convex-hull.html

Acelerar el proceso de arranque en Sistemas Windows 7 con varios procesadores

2010-11-03T13:54:00.004-05:00

El arranque en sistemas operativos Windows 7 por defecto se realiza con un solo procesador, pero podemos sacarle provecho a nuestras computadoras si es que estas poseen más de un núcleo. El proceso es sencillo.

1. Pulsamos las teclas Windows + r y nos aparecerá la siguiente ventana:

2. Escribimos msconfig y pulsamos enter o damos clic en aceptar.

3. Seleccionamos la pestaña Arranque y damos clic en Opciones avanzadas...

4. En la ventana que nos aparecerá marcamosNúmero de procesadores para que la habilite.

5. Seleccionamos el número de procesadores de la lista desplegable y hacemos clic en Aceptar.

6. Luego hacemos clic en Aplicar, luego en Aceptar y se nos pedirá que reiniciemos nuestra computadora.

Eso es todo, espero les sea de utilidad. Cualquier duda o sugerencia, estoy presto a atenderla.

Configuración de Servidor Radius en Packet Tracer

2010-11-03T13:31:00.008-05:00

En este post voy a mostrar la forma de como configurar un servidor Radius en el entorno de simulación de packet tracer. La imágen que muestro a continuación es el reto de integración del CCNA3 v 4.0 que se dicta en Trujillo-Perú (Universidad Privada del Norte).

La idea es es que los usuarios que se conecten a ambos access points puedan autenticarse usando un servidor radius ubicado en la misma VLAN en que la que se encuentran estos access points (VLAN 10).

Bueno, una vez que hemos colocado el servidor radius en la misma VLAN le vamos a asignar un IP, máscara de subred y gateway de forma correcta. La VLAN 10 tiene el siguiente rango de direcciones: 30.30.30.0/24

Y ya que se usa enrutamiento entre VLANS usando router-on-a-stick, la dirección gateway será 30.30.30.1 (para más detalle descarga el archivo de packet tracer al final del post).

Entonces debería quedarnos algo así:

Bien, ahora vamos a configurar el servidor RADIUS. La siguiente imágen nos indicará cómo hacerlo:

Los clientes serán los access points que utlizarán este servidor para la autenticación y los usuarios serán los hosts finales que necesitarán de un usuario y contraseña. Ahora vamos a configurar los access points para que utilizen el servidor.

Primero debemos establecer el método de cifrado que utilizará y luego indicarle la dirección IP del servidor radius de esta manera:

Ahora tenemos que configurar en cada host el nombre de usuario y la contraseña. Para esto seguiremos los siguientes pasos:

1. Editar el perfil del host. Seleccionamos el perfil y le damos clic en Edit.

2. Seleccionamos el SSID del access point al que nos queremos conectar y seleccionamos Advanced Setup.

3. Verificamos que en efecto sea el SSID del access point al que nos queremos conectar (Lo podemos editar, si ese fuese el caso) y luego damos clic en Next.

4. Si tenemos un servidor DHCP entonces dejamos la opción marcada en rojo, en caso contrario tendremos que ingresar los datos requeridos para un host con IP estática. Luego hacemos clic en Next.

5. Seleccionamos el tipo de encriptación que usa el access point y damos clic en Next.

6. Ingresamos el usuario y contraseña que habíamos añadido anteriormente a la base de datos del servidor RADIUS (El número de usuarios en radius dependerá del número de clientes que se conecten a los access points). Luego damos clic en Next.

7. Hacemos clic en Save y listo!!

Y para finalizar el post aca les dejo el archivo de packet tracer.

Con eso ya tenemos nuestro proceso de autenciación usando un Servidor Radius. Cualquier inquietud, no duden en comentarla.

También te podría interesar estos posts:

http://rolandopalermo.blogspot.com/2010/09/caso-de-estudio-2-configuraciones.html

http://rolandopalermo.blogspot.com/2010/08/cap-10-reto-de-integracion-de.html

Fobs4JMF in Windows XP and Netbeans

2010-10-31T22:30:00.010-05:00

Looking for a way to play video in java I found a project called Fobs4JMF. It's a PlugIn which allows to use the wide range of formats supported by ffmpeg in your Java applications.

If you want to try that, you have to follow the next steps:
1. Install the latest JMF version
2. Download Fobs4JMF from here.
3. Extract in a folder (For example in C:\). See the screenshot:

2.Include C:\fobs4jmf_0.4.2_win32\fobs4jmf.jar and C:\fobs4jmf_0.4.2_win32\jmf.jar; into your java classpath environment variable (or include it directly in the command line invocation of java): If you have extracted in C:\ drive, then you can add directly this paths

C:\fobs4jmf_0.4.2_win32\fobs4jmf.jar;C:\fobs4jmf_0.4.2_win32\jmf.jar;

See the screenshot:

Thereafter, follow these steps:

1. Launch JMStudio (java JMStudio).

2. Go to File->Preferences

3. Enter the "Plugins" tab

4. In the "Demultiplexer" tab, add the class "com.omnividea.media.parser.video.Parser" and commit.

5. In the "Codec" tab, add the class "com.omnividea.media.codec.video.NativeDecoder" and commit.

6. In the "Codec" tab, add the class "com.omnividea.media.codec.audio.NativeDecoder" and commit.

7. In the "Codec" tab, add the class "com.omnividea.media.codec.video.JavaDecoder" and commit.

8. Go to the "Packages" tab

9. Include "com.omnividea" in both the Protocol Prefix ~~and the Context Prefix list~~. Move both of them up to the first position. Commit both. See screenshot.

After these steps, the jmf plugin is installed in the system and will be used automatically when needed, not only by JMStudio but also by any program that uses the JMF plugin [1].

If you are using netbeans IDE you have to add fobs4jmf.jar to your classpath project. It should look like that:

Dont' forget to leave a comment ^^!

Thermometer in Java with JFreeChart

2010-10-31T12:16:00.016-05:00

Definitely one of the most interesting componentes of JFreeChart packet is the Thermometer. As part of my thesis I need to use that but when I tried it I managed to use it. It isn't very easy to find the way to use a thermometer component and If you want to get the source code, you have to purchase the JFreeChart Developer Guide.

Much people haven't got a clue how to use it but in this post I'm going to show how we can use the thermometer en our projects, so they are going to look much better.

I haven't read the licence and I can explain nothing about that, but looking for some examples on the net I found a page where the autor show the JFreeChart Demo source code decompiled by him. I supose the decompiling of jfreechart is not allowed, but really is well worth checking it.

Here is the source code:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.rolandopalermo.telecontrol.test;

/**
 *
 * @author Rolando Palermo
 */
import java.awt.*;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.ThermometerPlot;
import org.jfree.data.general.DefaultValueDataset;
import org.jfree.data.general.ValueDataset;
import org.jfree.ui.ApplicationFrame;
import org.jfree.ui.RectangleInsets;


public class ThermometerDemo1 extends ApplicationFrame {
    
    static class ContentPanel extends JPanel implements ChangeListener {
        JSlider slider;
        DefaultValueDataset dataset;
        
        private static JFreeChart createChart(ValueDataset valuedataset) {
            ThermometerPlot thermometerplot = new ThermometerPlot(valuedataset);
            JFreeChart jfreechart = new JFreeChart("Thermometer Demo 1", JFreeChart.DEFAULT_TITLE_FONT, thermometerplot, true);
            thermometerplot.setInsets(new RectangleInsets(5D, 5D, 5D, 5D));
            thermometerplot.setPadding(new RectangleInsets(10D, 10D, 10D, 10D));
            thermometerplot.setThermometerStroke(new BasicStroke(2.0F));
            thermometerplot.setThermometerPaint(Color.lightGray);
            thermometerplot.setUnits(1);
            thermometerplot.setGap(3);
            return jfreechart;
        }

        public void stateChanged(ChangeEvent changeevent) {
                dataset.setValue(new Integer(slider.getValue()));
        }

        public ContentPanel() {
                super(new BorderLayout());
                slider = new JSlider(0, 100, 50);
                slider.setPaintLabels(true);
                slider.setPaintTicks(true);
                slider.setMajorTickSpacing(25);
                slider.addChangeListener(this);
                add(slider, "South");
                dataset = new DefaultValueDataset(slider.getValue());
                add(new ChartPanel(createChart(dataset)));
        }
    }

    public ThermometerDemo1(String s) {
        super(s);
        JPanel jpanel = createDemoPanel();
        setContentPane(jpanel);
    }

    public static JPanel createDemoPanel() {
        return new ContentPanel();
    }

    public static void main(String args[]) {
        ThermometerDemo1 thermometerdemo1 = new ThermometerDemo1("Thermometer Demo 1");
        thermometerdemo1.pack();
        thermometerdemo1.setVisible(true);
    }
    
}

Additionally you have to add these jars (They are in the /lib directory of the JFreechart folder) to your project's classpath:

You can see whole of the source code here http://code.google.com/p/bluelight/
You can get JFreechart project here http://sourceforge.net/projects/jfreechart/files/
That's all by now. I hope it useful.

Don't forget to leave a comment ^^'

¿Quién fué el mejor James Bond?

2010-10-25T12:34:00.003-05:00

Muchos de los que disfrutamos ver una y otra vez las películas de James Bond siempre nos hemos preguntado quién ha sido el mejor actor que ha interpretado el papel de este personaje creado por Ian Fleming. Si buscamos en internet hay muchos debates acerca de ello así como también muchas opiniones encontradas (Sobre todo con respecto al último James Bond, Daniel Craig).

Una de las principales valoraciones que se le da a cada James Bond es el número de películas que este ha realizado. Es por esta razón que George Lazenby casi siempre es colocado en la posición número 6.

Y es que Lazenby solo ha hecho une película de James Bond, me refiero a "Al servicio secreto de su majestad". Y es que no es el hecho de que Lazenby haya sido un mal James Bond, sino que solo ha hecho 1 solo película de las 23 que son tomadas como oficiales.

El siguiente es Sean Connery quien ha interpretado a James Bond en 7 oportunidades. Muchos consideran que él ha sido el mejor James Bond pues luego de filmar estas películas ha tenido una gran trayectoria cinematográfica en cintas con una trama similar a la de James Bond (como La Roca).

Otro factor que le da puntos a Connery es el hecho de haber sido el primer 007 del cine creando un prototipo de personaje (adicionalemente al del propio Bond creado por Fleming) que los otros actores tuvieron que seguir añadiendo cada uno lo suyo.

Roger Moore es otro de los que se perfila como el mejor James Bond, y esto debido a que es el actor que más veces ha encarnado al agente secreto británico, haciéndolo hasta en 7 oportunidades.

Así mismo, según mi opinión, no posee la frialdad del Bond que describe Fleming sino más bien es un tipo sarcástico, demostrando esto en muchas de sus películas. También es muy recordado por ser el que tuvo que enfrentarse en muchas oportunidades al casi inmortal Tiburón.

Ahora es el turno de Timothy Dalton quien tampoco a interpretado a Bond en muchas oportunidades (Solo 2 para ser exactos). Su popularidad en relación con su papel de Bond no es muy buena, ya que el igual que Lazenby, el corto número de películas hechas no le da tantas oportunidades frente el resto de actores.

Sin embargo las dos películas hechas son muy buenas y además ha demostrado tener cierta frialdad a la que no nos tenían acostumbrados Connery y Moore.

Ahora es el turno de otro James Bond, se podría decir el más popular entre gente cuya edad oscila entre los 17 y 30 años. Me refiero a Pierce Brosnan. Es considerado por muchos foros como el mejor James Bond ,pero esto es debido al hecho de que la mayoría de gente que usamos el internet tenemos esa edad (17-30) y asociamos automáticamente la imágen de Brosnan con el agente 007.

No digo que Brosnan haya sido un mal actor pues ha hecho grandes películas y reune casi todas las características de los otros actores pero al verlo pelear contra enemigos evidentemente más fuertes que él y verlo resistir tantos golpes hacía que las películas se vean demasiado fantasiosas. Por lo demás, un excelente actor y la imágen de James Bond para la gente de nuestra generación.

Y ahora es el turno del más discutido James Bond. Me refiero a Daniel Craig. Para mí es el mejor actor que haya realizado este papel pues es un tipo de sentimientos fríos, calculador que primero mata y luego pregunta, no es bromista y tiene las capacidades físicas de enfrentarse al mismísimo Tiburón.

El problema con las películas de Craig es que se han suprimido personas como Q o Miss Moneypenny así como a los autos equipados con lanzamisiles y los artefactos de última generación que si tenían las anteriores películas y se le ha dado (sobre todo en Casino Royal) un toque un poco más sentimental. Un dato curioso es que es recién en esta película que se muestra como James Bond adquiere su licencia para matar (00).

En fin, esa es mi opinión tan válida como la del resto de gente. Y para finalizar este post les dejo la lista de actores en función de la calidad con la que interpretaron a este mítico agente secreto 007.
1- Daniel Craig
2- Sean Connery
3- Pierce Brosnan
4- Roger Moore
5- Timothy Dalton
6- George Lazenby

Ahora solo nos queda esperar para cuando sea el estreno de Bond 23 que actualmente está suspendido indefinidamente y que contará con la actuación de Craig.

Aca les dejo también un video donde salen todos estos personajes.

Flex y Bison en un solo Analizador

2010-10-24T01:49:00.011-05:00

Anteriormente habiamos hablado acerca de la forma de configurar Flex (http://rolandopalermo.blogspot.com/2009/12/como-configurar-flex-en-windows-y-no.html) y también como hacerlo con Bison (http://rolandopalermo.blogspot.com/2010/01/configurando-bison-en-windows-para.html) pero hasta ahora no se había explicado la forma en cómo se puede hacer que ambas herramientas trabajen juntas. Bueno, este post abordará este tema ya que si bien es cierto que la configuración de estas herramientas es sencilla el hacerlos trabajar juntas no lo es tanto.

Bueno, lo primero que tenemos que hacer es tener nuestro Flex y Bison configurados como expliqué en los post anteriores. Luego de eso debemos tener nuestros archivos tanto para flex como para bison listos, claro que la forma de cómo se estructuran estos archivos no es parte de este post. Aca les voy a mostrar los archivos que usé para un proyecto de la universidad (Shark Analyzer 3.0) sobre un lenguaje de programación que estabamos definiendo. Antes que nada un screenshot de lo que es el analizador que hicimos.

Archivo para FLEX

%{
   #include <stdio.h>
   #include <conio.h>
   #include "parser.h"  
%}
%option noyywrap
%option yylineno
letra [a-zA-Z]
digito [0-9]
binario [0-1]
ignora " "|\t|\n
operarit *|+|-|/
operlog &|$
comparador <|>|<=|>=|==|!=
%%
{ignora}+                    {;}
"Entero"                     {printf("Palabra reservada para tipo de dato entero\n");return PRENTERO;}
"Real"                       {printf("Palabra reservada para tipo de dato real\n");return PRREAL;}
"Booleano"                   {printf("Palabra reservada para tipo de dato booleano\n");return PRBOOLEANO;}
"Caracter"                   {printf("Palabra reservada para tipo de dato caracter\n");return PRCARACTER;}
"Si"                         {printf("Palabra reservada para condicional\n");return PRSI;}
"Sino"                       {printf("Palabra reservada para otro condicional\n");return PRSINO;}
"SinoSi"                     {printf("Palabra reservada para definir condicionales secundarias\n");return PRSINOSI;}
"Entonces"                   {printf("Palabra reservada para definir accion a realizar\n");return PRENTONCES;}
"FinSi"                      {printf("Palabra reservada finalizar condicional\n");return PRFINSI;}
"Para"                       {printf("Palabra reservada para bucle de tipo Para\n");return PRPARA;}
"FinPara"                    {printf("Palabra reservada para fin de bucle de tipo Para\n");return PRFINPARA;}
"Mientras"                   {printf("Palabra reservada para bucle de tipo Mientras\n");return PRMIENTRAS;}
"Hacer"                      {printf("Palabra reservada para indicar que se empieza algo\n");return PRHACER;}
"FinMientras"                {printf("Palabra reservada fin de bucle de tipo Mientras\n");return PRFINMIENTRAS;}
"FinHacerMientras"           {printf("Palabra reservada para indicar fin de bucle Hacer-Mientras\n");return PRFINHACERMIENTRAS;}
"Funcion"                    {printf("Palabra reservada para declaracion de funciones\n");return PRFUNCION;}
"Estructura"                 {printf("Palabra reservada para declaracion de estructuras\n");return PRESTRUCTURA;}
"FinFuncion"                 {printf("Palabra reservada para finalizar funcion\n");return PRFINFUNCION;}
"Retorna"                    {printf("Palabra reservada para retorno de funcion\n");return PRRETORNA;}
"SinValor"                   {printf("Palabra reservada para funcion sin valor de retorno\n");return PRSINVALOR;}
"Definir"                    {printf("Palabra reservada para definir funciones\n");return PRDEFINIR;}
"Constante"                  {printf("Palabra reservada para definir constantes\n");return PRCONSTANTE;}
"Entrada"                    {printf("Palabra reservada para definir entradas\n");return PRENTRADA;}
"Salida"                     {printf("Palabra reservada para definir salidas\n");return PRSALIDA;}
{letra}({letra}|{digito})*   {printf("Identificador\n");return IDENT;}
{letra}+                     {printf("Caracter\n");return CARACTER;}
{binario}+                   {printf("Binario\n");return BOOLEANO;} 
{digito}+                    {printf("Entero\n");return ENTERO;}
{digito}+"."{digito}+        {printf("Real\n");return REAL;}
{comparador}                 {printf("Comparador\n");return COMPARADOR;}
":="                         {printf("Asignador\n");return ASIG;}
";"                          {printf("Fin sentencia\n");return PCOMA;}
"!="                         {printf("Diferente\n");return DIF;}
","              {printf("Coma\n");return COMA;}
"=="                         {printf("Igual\n");return IGUAL;}
"."                          {printf("Punto\n");return PTO;}
">="                         {printf("Signo mayor-igual\n");return MAIGU;}
"<="                         {printf("Signo menor-igual\n");return MEIGU;}
"("                          {printf("(\n");return PARIZ;}
")"                          {printf(")\n");return PARDE;}
">"                          {printf(">\n");return MAYOR;}
"<"                          {printf("<\n");return MENOR;}
"{"                          {printf("{\n");return LLIZ;}
"}"                          {printf("}\n");return LLDE;}
"+"                          {printf("+\n");return MAS;}
"-"                          {printf("-\n");return MENOS;}
"*"                          {printf("*\n");return POR;}
"/"                          {printf("/\n");return ENTRE;}
"&"                          {printf("&\n");return YLOG;}
"$"                          {printf("Operador Logico\n");return OLOG;}
.                            {printf("ERROR LEXICO EN LINEA %d \n",yylineno);}
%%
int main(int argc,char *argv[])
{
 if ((yyin = fopen(argv[1], "rt")) == NULL)
 {
  printf("\nNo se puede abrir el archivo: %s\n", argv[1]);
 }
 else
 {
  //yylex();
  yyparse();
 }
 fclose(yyin);
 return 0;
}

Lo único diferente con respecto al ejemplo que mostré en el post de configuración de flex es que ahora no invocaremos a la función yylex() sino que ahora se invocará a la función yyparse(). Adicionalmente vemos que en la cabecera se invoca a la librería "parser.h" la cuál debe contener las deficiones para cada toquen de nuestra gramática.

Arhcivo parser.h

#ifndef YYSTYPE
#define YYSTYPE int
#endif
#define PRENTERO 257
#define PRREAL         258
#define PRBOOLEANO 259
#define PRCARACTER 260
#define PRSI         261
#define PRSINO         262
#define PRSINOSI 263
#define PRENTONCES 264
#define PRFINSI         265
#define PRPARA         266
#define PRFINPARA 267
#define PRMIENTRAS 268
#define PRHACER         269
#define PRFINMIENTRAS 270
#define PRFINHACERMIENTRAS  271
#define PRFUNCION     272
#define PRFINFUNCION     273
#define PRRETORNA     274
#define PRSINVALOR     275
#define PRESTRUCTURA     276
#define MAS 277
#define MENOS 278
#define POR 279
#define ENTRE 280
#define OLOG 281
#define YLOG 282
#define PRDEFINIR 283
#define PRCONSTANTE 284
#define IDENT 285
#define ENTERO 286
#define REAL 287
#define BOOLEANO 288
#define CARACTER 289
#define COMPARADOR 290
#define ASIG 291
#define PCOMA 292
#define DIF 293
#define COMA 294
#define IGUAL 295
#define PTO 296
#define MAIGU 297
#define MEIGU 298
#define PARIZ 299
#define PARDE 300
#define MAYOR 301
#define MENOR 302
#define LLIZ 303
#define LLDE 304
#define PRSALIDA 305
#define PRENTRADA 306

extern YYSTYPE yylval;

Cone esto ahora debemos definir el archivo para bison.

Archivo para Bison:

%{
int yystopparser=0;
%}


%token PRENTERO PRREAL PRBOOLEANO PRCARACTER PRSI PRSINO PRSINOSI PRENTONCES PRFINSI PRPARA  
PRFINPARA PRMIENTRAS PRHACER PRFINMIENTRAS PRFINHACERMIENTRAS PRFUNCION PRFINFUNCION PRRETORNA PRSINVALOR PRESTRUCTURA MAS MENOS POR ENTRE OLOG YLOG  
PRDEFINIR PRCONSTANTE IDENT ENTERO REAL BOOLEANO CARACTER COMPARADOR ASIG PCOMA DIF COMA IGUAL PTO   
MAIGU MEIGU PARIZ PARDE MAYOR MENOR LLIZ LLDE PRSALIDA PRENTRADA
%start inicio

%%
inicio  : funcion
  | constante 
  | estructura
  ;

estructura : PRESTRUCTURA IDENT LLIZ n
n  : declaracion n
  | declaracion nn
nn  : LLDE IDENT PCOMA o
o  : estructura
  | constante
  | funcion
  ;

constante : PRDEFINIR PRCONSTANTE e
e  : PRENTERO IDENT f
  | PRREAL IDENT f
  | PRBOOLEANO IDENT f
f  : ASIG g
g  : ENTERO PCOMA y
  | REAL PCOMA y
  | BOOLEANO PCOMA y
y  : constante
  | estructura 
  | funcion  
  ; 

funcion  : PRFUNCION j
j  : PRENTERO k
  | PRREAL k
  | PRBOOLEANO k
  | PRCARACTER k
  | PRSINVALOR k
k  : IDENT PARIZ l
l  : kl
kl  : declaracion l
  | ll
ll  : PARDE sentencia m
m  : PRRETORNA IDENT p
  | p
p  : PRFINFUNCION funcion
  | PRFINFUNCION 
  ;

comparacion : IDENT COMPARADOR b
b  : IDENT
  | REAL
  | ENTERO
  | BOOLEANO
  ;

declaracion : PRENTERO c
  | PRREAL c
  | PRBOOLEANO c
  | PRCARACTER c
c  : IDENT PCOMA
  ;

asignacion  : IDENT ASIG a
a  : IDENT PCOMA
  | ENTERO PCOMA 
  | REAL PCOMA
  | BOOLEANO PCOMA
  | oparitmetica PCOMA
  ;

mientras : PRMIENTRAS PARIZ x
x  : comparacion y
  | oplogica y
y  : PARDE sentencia PRFINMIENTRAS
  ;

hacermientras : PRHACER sentencia PRFINHACERMIENTRAS PRMIENTRAS PARIZ cc
cc  : comparacion PARDE
  | oplogica PARDE
  ;

para  : PRPARA PARIZ asignacion comparacion PCOMA asignacion PARIZ sentencia PRFINPARA
  ;

si  : PRSI PARIZ sh
sh  : comparacion shh
  | oplogica shh
shh  : PARDE PRENTONCES sentencia h
h  : PRFINSI
  | PRSINOSI PARIZ comparacion PARDE PRENTONCES sentencia i
i  : h
  | z
z  : PRSINO PRENTONCES sentencia PRFINSI
  ;

sentencia : declaracion sentencia 
  | declaracion 
  | asignacion sentencia 
  | asignacion
  | mientras sentencia 
  | mientras
  | hacermientras sentencia 
  | hacermientras 
  | para sentencia
  | para
  | si sentencia 
  | si
  | entrada sentencia
  | entrada
  | salida sentencia
  | salida
  ;

salida  : PRSALIDA ASIG LLIZ LLDE PCOMA
  ;

entrada  : PRENTRADA IDENT PCOMA
  ;

oparitmetica : MAS PARIZ q
  | POR PARIZ q
  | suma
  | producto
q  : oparitmetica PARDE r
suma  : MAS r t
producto : POR r t
t  : r u
u  : t
  | 
r  : IDENT
  | REAL
  | ENTERO
  ;


oplogica : OLOG PARIZ qq
  | YLOG PARIZ qq
  | yy
  | oo
qq  : oplogica PARDE rr
oo  : OLOG rr tt
yy  : YLOG rr tt
tt  : rr uu
uu  : tt
  | 
rr  : comparacion 
  ;

Con esos tres archivos ya casi estamos listos. También dentro del directorio donde están trabajando (Directorio en donde se encuentra el archivo de flex y bison) deben crear el siguiente archivo:

Archivo error.c

void  yyerror(char * msg)
{
 printf ("%s\n", msg);
}

Ahora solo nos queda compilar los scripts de flex y bison del siguiente modo:

Con esto nuestro directorio de trabajo debería quedar algo así:

Ahora si usan DevC++ solo deben crear un proyecto y añadir todos los archivos ahí presentes. Observen además que para correr el programa no se nos pedirá que ingresemos el nombre de del archivo sino que lo debemos mandar como parámetro, en otras palabras el archivo generado no se debe ejecutar con doble clic sino por medio de la consola del windows. Creo que una imágen vale más que mil palabras:

El hecho que el programa tenga una forma especial de ejecutarse es que nosotros hicimos un proyecto en la Universidad en donde desde una aplicación en Java invocabamos a un ejecutable generado en C que se encargaba de realizar el procesamiento de la gramática y esa salida la mostrabamos en Java (que lógicamente presenta una mejor interfaz de usuario). Esto lo cuento a modo de anécdota por si tuvieran que hacer algo similar.

Y bueno, lógicamente también les pondré unos ejemplos de código. El primero es el que está escrito correctamente:

Codigo00.txt

Estructura est 
{
Entero num;
Entero nfgj;
Booleano ggnum;
} est1;

Definir Constante Entero numero := 145 ;

Funcion Entero miFuncion( Caracter Cadena; ) 

   Car:=Carro;
   Entero Num;

   Mientras ( c<d )

      Car:=Carro;
      Entero bandera;
      Booleano boole;
      boole:=1;

      Mientras ( a>=4 )

         Car:=Carro;
         Entero bandera;
         Booleano boole;
         boole:=1;

  Para ( a:=14; a<=25; a:= + 5 4 ;(
  
  
  Si ( a==4 ) Entonces
    Bool:=1;
     FinSi
  
  FinPara
  

      FinMientras

   FinMientras

   Si ( a==4 ) Entonces
  Bool:=1;
   FinSi

   Retorna Numero 

FinFuncion

Y el programa Shark Analyzer 3.0 lo analiza de la siguiente manera:

Y el siguiente código está mal escrito
Codigo01.txt

Definir Constante Entero numero := 145 ;
Definir Booleano nume := 1 ;
Funcion Entero ( Entero num; Real fre; Booleano boll;) 
   Mientras (  )
      Booleano ghjfg;
      bocfgh:=1;
      Mientras ( a>=4 )
         Car:=Carro;
         Entero bandera;
         Booleano boole;
         boole:=1; 
 Si ( a==4 ) 
   Bool:=1;
   Booleano boolean;
 SinoSi (a==5) Entonces
  Bool:=2;
 Sino Entonces
  Bool:=3;
    FinSi
      FinMientras
   FinMientras
   Retorna Carro
FinFuncion

Shark Analyzer 3.0 nos muestra lo siguiente:

También puedes descargar el jar de Shark Analyzer y probar tus propios códigos (claro, en función de la gramática mostrarda en el script de bison).

También puedes cambiar la gramática y de esta manera el archivo ejecutable que te genera tu compilador de C lo puedes usar en lugar de kernel.exe, de este modo Shark Analyzer usará tus gramáticas y no las que trae por defecto en su kernel. exe. Eso si, recuerda que para que la consola de salida de Shark Analyzer marque de rojo las salidas donde se ha encontrado un error léxico o si ha ocurrido un error sintáctico, en el archivo de flex esta línea:

.                            {printf("ERROR LEXICO EN LINEA %d \n",yylineno);}

Siempre debe empezar con "ERROR", en otras palabras esa línea no debería ser modificada del archivo de Flex.

Cualquier duda o sugerencia no dudes en escribirla.

Caso de estudio 2: Configuraciones Básicas y Enrutamiento Estático

2010-09-30T18:02:00.017-05:00

Estaba en el internet viendo algunas cosas y unos compañeros de la Universidad me consultaron sobre un caso de estudios que les habían dejado en el curso de Redes de computadoras sobre la configuración de routers CISCO y bueno, me propuse darles una mano con la finalidad de que les sea de utilidad no solo a ellos sino a mucha gente a la que le interesa esta área tan fascinante, las redes de computadoras.

El problema propuesto es el caso de estudio 2, que se muestra a continuación.

Bueno, vayamos por partes. Lo que se nos pide es lo siguiente:

Calcule el direccionamiento según corresponda utilizando VLSM.
Considere el uso de sumarizacion y enrutamiento por defecto en las rutas estáticas que utilice y redistribuya estas.
Habilite la administración remota con telnet en todos los routers (usuario:ASDADMpassword:ASDPASS).
Habilite enrutamiento dinámico RIP vl y v2. Considere las actualizaciones de enrutamiento solo donde corresponda.

Configuraciones basicas

Habilite contraseña para el acceso al modo privilegiado (contrasefia: ASDCISCO)
Habilite el mensaje de bienvenida, indicando lo siguiente: "Solo se permite el acceso a personal autorizado".
Indique en la descripción de las interfaces la cantidad de host asociados a esa red.
Deshabilite el protocolo CDP en las interfaces fastethernet.
Configure los nombres de host para cada router.
Habilite la resolución de nombre los PCs.

Bueno, primero hagamos el diseño IP. Esta parte es la más importante y es donde mayor énfasis deberíamos poner puesto que los comandos dependen de la marca de los equipos, pero el diseño IP es inherente a eso.

Un buen diseño IP es fundamental para todo Ingeniero de Redes.

Bueno, primero debemos asiganar bloques de direcciones a cada región, tanto para el lado derecho, como para el izquierdo y el central. Yo recomiendo lo siguiente:

Para el lado izquierdo usar:192.168.1.0/24

Para el lado derecho usar:10.1.0.0/16

Para el lado central usar:172.30.1.0/24

Listo, ya tenemos los bloques de direcciones a usar. Ahora veamos algunos requerimientos: "Habilite enrutamiento dinámico RIP vl y v2". Esto significa que en un lado debemos usar subneteo con una sola máscara y en el otro lado si podemos usar VLSM.

En el lado izquierdo, que es donde usaremos RIP V1, vamos a hacer un subneteo normal con la misma máscara para todas las subredes puesto que RIP V1 no propaga máscaras de subred. El diseño ip para esa área quedaría más o menos así:

Es evidente el desperdicio de direcciones IP que se hace puesto que los enlaces seriales entre routers solo necesitan de 2 direcciones IP por lo que 251 direcciones están siendo desperdiciadas.

En fin, ahora hagamos el subneteo utilizando VLSM para la siguiente región donde emplearemos RIP V2. Es recomendable empezar subneteando por las subredes que mayor cantidad de hosts poseen. En este caso el diseño IP para esa región quedaría así:

Bien, ahora que está hecho eso vayamos a la siguiente parte:

Habilite contraseña para el acceso al modo privilegiado (contrasefia: ASDCISCO)

Esto se consigue de la siguiente forma:

router>enable
router#conf term
router(config)#enable secret ASDCISCO
router(config)#end
router#wr

Esta serie de comandos deberán ser ingresados para todos y cada uno de los routers. Lo siguiente que se nos pide es:

Habilite el mensaje de bienvenida, indicando lo siguiente: "Solo se permite el acceso a personal autorizado".

Lo mismo que en el caso anterior este comando deberá ser ingresado en todos los routers.

router>enable
router#conf term
router(config)#banner motd #Solo se permite el acceso a personal autorizado#
router(config)#end
router#wr

Siguiente paso:

Deshabilite el protocolo CDP en las interfaces fastethernet.

router>enable
router#conf term
router(config)#interface fastEthernet 0/0
router(config-if)#no cdp enable
router(config)#end
router#wr

Lo mismo que el anterior, se deberá realizar en todos los routers. CDP es un protocolo propietario de CISCO que no tiene soporte en otros equipos, en algunos casos es muy útil pero eso será explicado en otro post.

Configure los nombres de host para cada router.

router>enable
router#conf term
router(config)#hostname [Nombre]
router(config)#end
router#wr

Habilitar RIP v1 y v2 es similar pero previamente hemos debido haber configurado cada una de las interfaces del router que supongo ya ha sido realizado. Aca dejo la secuencia de comandos para activar una interfaz de un router.

router>enable
router#conf term
router(config)#interface serial 0/3/0
router(config-if)#ip address [direccion ip] [mascara de subred]
router(config-if)#no shutdown
router(config)#end
router#wr

En el caso de que se trate de interfaces seriales DCE los pasos son los siguientes:

router>enable
router#conf term
router(config)#interface serial 0/3/0
router(config-if)#ip address [direccion ip] [mascara de subred]
router(config-if)#clock rate 64000
router(config-if)#no shutdown
router(config)#end
router#wr

Para configurar RIP en el caso de los routers de la región que usar RIP V1 usamos los siguientes pasos:

router>enable
router#conf term
router(config)#router rip
router(config-router)#network [direccion ip de subred]
router(config)#end
router#wr

Para el sector que usa RIP V2 usamos la siguiente secuencia de comandos:

router>enable
router#conf term
router(config)#router rip
router(config-router)#version 2
router(config-router)#network [direccion ip de subred]
router(config)#end
router#wr

Una ruta estática mediante dirección del siguiente salto se configura asi:

router>enable
router#conf term
router(config)#ip route [addres] [subnet mask] [ip-address]
router(config)#end
router#wr

addres: Dirección de destino de la red remota.
subnet mask: Máscara de subred de la red remota.
ip-address: Dirección IP del router del siguiente salto.

Configuar una ruta estática por defecto:

router>enable
router#conf term
router(config)#ip route 0.0.0.0 0.0.0.0 [interfaz]
router(config)#end
router#wr

interfaz: Interfaz de salida del router  por donde serán enviados paquetes con direcciones IP desconocidas

Este paso es necesario generalmente en los routers de borde o los que se conectan al ISP puesto que tener una tabla de enrutamiento con todas las direcciones de red del mundo es casi imposible de almacenar y además tardaría demasiado en determinar por donde sería enviada.

Incluir la ruta estática en las actualizaciones RIP se hace del siguiente modo:

router>enable
router#conf term
router(config)#router rip
router(config-router)#default-information originate 
router(config)#end
router#wr

Al finalizar debería quedarles algo así:

Faltan algunas configuraciones como las contraseñas y mensajes de bienvenida, pero ya dejo explicada la forma de como se usan estos comandos y, bueno, no podía cerrar este post sin dejarles el archivo de Cisco Packet Tracer además de recordárles también que yo uso la version 5.3.1.0044. Deberan tener la misma version o una superior.

Espero les sea de utilidad y cualquier consulta o sugerencia no duden en hacerla.

Algoritmo de Graham para la Cerradura Convexa con Simulación en Java

2010-09-28T23:54:00.010-05:00

Bueno, al llegar a este post asumo que ustedes ya han leído acerca de lo que trata este problema de la geometría computacional. Esto es muy importante puesto que algunos detalles expuestos aquí no serán tratados muy profundamente. Pues bueno, vayamos al grano.

El algoritmo de graham fué uno de los primero algoritmos utilizados para resolver este problema. El concepto fundamental de este algoritmo es tener en cuenta el sentido de giro que toma un vector respecto a otro de forma iterativa. Para esto Graham nos dice lo siguiente:

Evidentemente es seudocódigo pero no hay mejor forma de entender esto que mediante una prueba. A ver, empezemos.
Supongamos que se nos da un conjunto de puntos como los que se muestra en la figura siguiente:

Y necesitamos hallar la cerradura convexa. Lo primero que nos dice Graham es que escojamos el punto de menor ordenada y luego ordenemos el resto de puntos en función a su ángulo que forman con la horizontal.

Ahora insertamos en una pila los tres primeros puntos de la nube de puntos(evidentemente ya deben estar ordenados y el punto de menor ordenada es el que ocupa la menor posición). Hecho esto inicializamos un contador en 3 y empezamos las iteraciones.

Para i=3

Los tres puntos generan una vuelta la izquierda por lo que incrementamos el contador. Entonces nuestro contador quedaría así:

Para i=4

Vemos que forma una vuelta a la derecha por lo que el contador no se incrementará.

Para i=4

Ahora si se generó una vuelta la izquierda entonces nuestro contador se incrementa.

Para i=5

Tenemos otra vuelta a la izquierda y nuestro contador vuelve a incrementarse.

Para i=6

Una vuelta a la derecha. El contador no se incrementará.

Para i=6

Una vuelta a la izquierda, el contador se incrementará. Además estamos viendo como varia el contenido de la pila (la cual almacena los puntos que forman la cerradura convexa).

Para i =7

Una vuelta a la izquierda.

Para i=8

Vuleta a la derecha, contador sin variaciones.

Para i=8

Incrementamos el contador puesto que se generó una vuelta a la izquierda.

Para i=9

Incrementamos el contador.

Para i=10

Una vuelta a la derecha indica que el contador no se incrementará.

Para i=10

Incrementamos el contador.

Para i=11
Esta es la condición de parada por lo que los datos en la pila quedan así:

Entonces con esos puntos construimos la cerradura convexa y nos quedaría algo así:

Bueno, pero esto no estaría completo sin una simulación. El siguiente applet les mostrará como trabaja esto:

La implementación del Algoritmo de Graham es la siguiente:

/**
 *
 * @author Rolando
 */
public static List<Point2D> graham(List<Point2D> nube) {
    Stack pila = new Stack();
    List<Point2D> cerradura = new ArrayList<Point2D>();
    List<Point2D> temp = new ArrayList<Point2D>();
    //O(n)
    pivote = nube.get(0);
    for(Point2D p:nube) {
        if(p.getY()<pivote.getY()
                || (p.getY()==pivote.getY() &&
                p.getX()>pivote.getX())) {
            pivote = p;
        }
    }
    //O(nlog n)
    temp = mergerSort(nube);
    pila.push(temp.get(0));
    pila.push(temp.get(1));
    pila.push(temp.get(2));
    int i = 3;
    while(i<(temp.size())) {
        Point2D t = (Point2D) pila.pop();
        if(isLeft((Point2D) pila.peek(), t, temp.get(i))>0) {
            pila.push(t);
            pila.push(temp.get(i));
            i++;
        }
    }
    cerradura = pila.subList(0, pila.size());
    return cerradura;
}

El código fuente completo lo pueden descargar aquí:

Bueno, espero que les sea de utilidad. Muy pronto postearé los otros algoritmos de cerradura convexa. No se olviden de dejar sus comentarios y críticas.

También podría interesarte estos post:
http://rolandopalermo.blogspot.com/2010/11/java-convex-hull-jarvis.html
http://rolandopalermo.blogspot.com/2010/11/quickhull-java-convex-hull.html

Videos en HD con Movie Maker y Windows XP

2010-09-02T13:51:00.010-05:00

Hacer videos usando Movie Maker puede ser considerado por muchos como una tarea sencilla pero con este vertiginoso avance de la computación la tecnología HD se ha hecho muy común entre los aficionados a la edición de video y el Movie Maker (Al menos en XP) ya no nos brinda la posibilidad de realizar estos trabajos :s ... Al menos no sin una configuración extra.

Actualmente nos encontramos, también con nuevos sistemas operativos que ya traen integrada consigo esta tecnología. Estamos hablando de Windows Vista y Windows 7.

Pero cierto es que el Windows XP no quiere desaparecer ^^ y esto debido a su robustez y sobre todo a su madurez. XP es un sistema operativo que tiene tiempo y que se resiste a desaparecer pero los usuarios de este (entre ellos me incluyo) tenemos muchos problemas con esta tecnología tan cambiante y que avanza tan rápido. Esto me hace recordar a la tecnología USB y windows 98 ^^... que tiempos!!!.

Bueno, este post es un aporte más a la lucha para que el Windows XP no desaparezca. Hoy vamos a aprender a configurar el movie maker para poder crear videos en formato HD. Lo primero que tenemos que hacer es descargar los archivos que están en esta dirección https://sites.google.com/site/tecnologiaenperu/home/Profiles.rar y descomprimirlos en la siguiente carpeta:

C:\Archivos de programa\Movie Maker\Shared\Profiles

De tal modo que nos debe quedar así:

Luego de esto nuestro MovieMaker quedará listo para poder editar videos con calidad HD. Para esto al momento de guardar nuestro video debemos tener las opciones como se muestra en la siguiente imágen:

A partir de 77 se puede considerar HD por el tamaño de video y la velocidad de bits, que en la imágen están encerrados en rectángulos rojos. Yo recomiendo establecer el tamaño en 85 MB pues se obtiene una buena resolución y al subirlos a nuestro canal de youtube se verán perfectamente xD sino miren este video que hice en movie maker.

También vale aclarar que tengo el Movie Maker en su versión 5.1, aunque supongo que todos deben tener al menos esa versión.

Para usuarios de Vista y Seven esto no es necesario.

Saludos y hasta la próxima!!!.

Transmision de video usando sockets en Java

2010-08-24T01:18:00.005-05:00

Este post será corto de palabras pero como siempre con mucho código fuente para descargar, analizar y reutilizar xD!!

Un amigo de guatemala me hizo una consulta acerca de la transmisión de video y bueno, Dos horas antes de escribir este post me propuse darle una mano. La idea era transmitir video pero sin usar R.T.P. sino transmitiendo uno a uno los frames provenientes de una fuente de video, que en este caso es una cámara web.

Servidor

Cliente

Anteriormente posteé la forma de cómo acceder a los frames de video usando el Java Media Framework, si no lo has leído aún te recomiendo lo hagas http://rolandopalermo.blogspot.com/2010/06/procesamiento-de-video-en-tiempo-real.html y en este post vamos a transmitir esos frames capturados. No explicaré el código porque en internet hay bastante información así como ejemplos de cómo usar sockets en java.

Aquí les dejo el proyecto desarrollado usando Netbeans.

Saludos y espero te sea de utilidad!... No olvides dejar tu comentario que motiva el seguir compartiendo el conocimiento y las experiencias.

Cap. 10: Reto de integración de habilidades de Packet Tracer - CCNA 2 version 4.0

2010-08-13T16:55:00.012-05:00

Introducción:

Esta actividad se centra en las capacidades de división en subredes con VLSM, la configuración básica del dispositivo, el enrutamiento EIGRP y el enrutamiento RIPv2. Una vez que haya configurado todos los dispositivos, probará la conectividad de extremo a extremo y examinará su configuración.

Objetivos

Diseñar y documentar un esquema de direccionamiento en base a los requerimientos.
Aplicar una configuración básica a los dispositivos.
Configurar un enrutamiento estático entre routers ISP.
Configurar el enrutamiento EIGRP en Región 1 y el enrutamiento RIPv2 en Región 2.
Deshabilitar las actualizaciones de enrutamiento en las interfaces adecuadas.
Configurar y redistribuir las rutas predeterminadas.
Verificar la completa conectividad entre todos los dispositivos de la topología.

Tarea 1: Diseñar y documentar un esquema de direccionamiento

Paso 1: Diseñe un esquema de direccionamiento.

Utilice la topología y los siguientes requisitos para diseñar un esquema de direccionamiento:

Los enlaces WAN entre R1 y R2, junto con sus respectivos routers ISP, ya están configurados. También los enlaces entre el servidor ISP y el servidor Web ya están configurados.
El espacio de dirección para la Región 1 es 10.1.0.0/16. Le deberá asignar a cada router de sucursal (B1-R1, B2-R1 y B3-R1) un espacio de dirección según estos requisitos. Comenzando por el requisito mayor, asigne un espacio de direccionamiento a cada router:
B1-R1 necesita espacio para 8000 hosts
B2-R1 necesita espacio para 4000 hosts
B3-R1 necesita espacio para 2000 hosts
Divida el espacio de dirección de cada router de sucursal en cuatro subredes iguales. Registre las subredes en la tabla provista en las instrucciones impresas.
Para las WAN en la Región 1, divida en subredes el espacio de dirección 10.1.128.0/28. Registre las subredes en la tabla proporcionada en las instrucciones impresas.
El espacio de dirección para la Región 2 es 172.2.0.0/16. Se le deberá asignar a cada router de sucursal (B1-R2, B2-R2 y B3-R2) un espacio de dirección según estos requisitos. Comenzando por el requisito mayor, asigne un espacio de direccionamiento a cada router:
B1-R2 necesita espacio para 500 hosts
B2-R2 necesita espacio para 200 hosts
B3-R2 necesita espacio para 100 hosts
Divida el espacio de dirección de cada router de sucursal en cuatro subredes iguales. Registre las subredes en la tabla provista en las instrucciones impresas.
Para las WAN en la Región 2, divida en subredes el espacio de dirección 172.20.4.0/28. Registre las subredes en la tabla proporcionada en las instrucciones impresas.

Paso 2: Documente el esquema de direccionamiento.

Opcional: En la topología, rotule cada subred. Para ahorrar espacio, use sólo los últimos dos octetos, dado que sólo estos octetos cambian.
Utilice la tabla provista con las instrucciones impresas para documentar las direcciones IP y las máscaras de subred. Asigne la primera dirección IP a la interfaz del router.
En los enlaces WAN, asigne la primera dirección IP a R1 y R2 para los enlaces con la perspectiva de cada router B1, B2 y B3 de cada router.

El direccionamiento es algo que en este post no voy a explicar puesto que es algo sobre lo que ya se debe tener amplio conocimiento asumiendo el hecho que estamos en el CCNA2 y direccionamiento IP es un tema del CCNA1.

Bueno, luego de desarrollar todo el direccionamiento ip debemos tener algo como lo siguiente:

Bueno, ahora acá les dejo el running-config, que a estas alturas ya debemos saber interpretarlo.

Para el router B1-R1


Current configuration : 1047 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname B1-R1
!
!
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 10.1.0.1 255.255.248.0
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 10.1.8.1 255.255.248.0
 duplex auto
 speed auto
!
interface Serial0/0/0
 ip address 10.1.64.2 255.255.255.252
!
interface Serial0/0/1
 no ip address
 shutdown
!
interface FastEthernet1/0
 ip address 10.1.16.1 255.255.248.0
 duplex auto
 speed auto
!
interface FastEthernet1/1
 ip address 10.1.24.1 255.255.248.0
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
router eigrp 1
 passive-interface FastEthernet0/0
 passive-interface FastEthernet0/1
 passive-interface FastEthernet1/0
 passive-interface FastEthernet1/1
 network 10.0.0.0
 no auto-summary
!
ip classless
ip route 0.0.0.0 0.0.0.0 Serial0/0/0 
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router B2-R1


Current configuration : 1049 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname B2-R1
!
!
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 10.1.32.1 255.255.252.0
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 10.1.36.1 255.255.252.0
 duplex auto
 speed auto
!
interface Serial0/0/0
 ip address 10.1.64.6 255.255.255.252
!
interface Serial0/0/1
 no ip address
shutdown
!
interface FastEthernet1/0
 ip address 10.1.40.1 255.255.252.0
 duplex auto
 speed auto
!
interface FastEthernet1/1
 ip address 10.1.44.1 255.255.252.0
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
router eigrp 1
 passive-interface FastEthernet0/0
 passive-interface FastEthernet0/1
 passive-interface FastEthernet1/0
 passive-interface FastEthernet1/1
 network 10.0.0.0
 no auto-summary
!
ip classless
ip route 0.0.0.0 0.0.0.0 Serial0/0/0 
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router B3-R1


Current configuration : 1050 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname B3-R1
!
!
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 10.1.48.1 255.255.254.0
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 10.1.50.1 255.255.254.0
 duplex auto
 speed auto
!
interface Serial0/0/0
 ip address 10.1.64.10 255.255.255.252
!
interface Serial0/0/1
 no ip address
shutdown
!
interface FastEthernet1/0
 ip address 10.1.52.1 255.255.254.0
 duplex auto
 speed auto
!
interface FastEthernet1/1
 ip address 10.1.54.1 255.255.254.0
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
router eigrp 1
 passive-interface FastEthernet0/0
 passive-interface FastEthernet0/1
 passive-interface FastEthernet1/0
 passive-interface FastEthernet1/1
 network 10.0.0.0
no auto-summary
!
ip classless
ip route 0.0.0.0 0.0.0.0 Serial0/0/0 
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router R1


Current configuration : 1003 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname R1
!
!
!
enable secret 5 $1$mERr$9cTjUIEqNGurQiFU.ZeCi1
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 no ip address
 duplex auto
 speed auto
 shutdown
!
interface FastEthernet0/1
 no ip address
 duplex auto
 speed auto
 shutdown
!
interface Serial0/0/0
 ip address 10.1.64.1 255.255.255.252
 clock rate 64000
!
interface Serial0/0/1
 ip address 10.1.64.5 255.255.255.252
 clock rate 64000
!
interface Serial0/1/0
 ip address 10.1.64.9 255.255.255.252
 clock rate 64000
!
interface Serial0/1/1
 ip address 209.165.201.2 255.255.255.252
!
interface Vlan1
 no ip address
 shutdown
!
router eigrp 1
 redistribute static 
 passive-interface Serial0/1/1
 network 10.0.0.0
 no auto-summary
!
ip classless
ip route 0.0.0.0 0.0.0.0 Serial0/1/1 
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router ISP-R1


Current configuration : 1052 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname ISP-R1
!
!
!
enable secret 5 $1$843i$2WtI74NAnrsI2xYF0OPmr.
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 209.165.200.225 255.255.255.252
 duplex auto
 speed auto
!
interface FastEthernet0/1
 no ip address
 duplex auto
 speed auto
 shutdown
!
interface Serial0/0/0
 ip address 209.165.201.1 255.255.255.252
 clock rate 64000
!
interface Serial0/0/1
 ip address 209.165.201.5 255.255.255.252
 clock rate 64000
!
interface Vlan1
 no ip address
 shutdown
!
ip classless
ip route 209.165.201.8 255.255.255.252 Serial0/0/1 
ip route 209.165.200.228 255.255.255.252 Serial0/0/1 
ip route 10.1.0.0 255.255.0.0 Serial0/0/0 
ip route 172.20.0.0 255.255.0.0 Serial0/0/1 
!
!
!
banner motd ^C
********************************
  !!!AUTHORIZED ACCESS ONLY!!!
********************************
^C
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router B1-R2


Current configuration : 1037 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname B1-R2
!
!
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 172.20.0.1 255.255.255.128
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 172.20.0.129 255.255.255.128
 duplex auto
 speed auto
!
interface Serial0/0/0
 ip address 172.20.4.2 255.255.255.252
!
interface Serial0/0/1
 no ip address
 shutdown
!
interface FastEthernet1/0
 ip address 172.20.1.1 255.255.255.128
 duplex auto
 speed auto
!
interface FastEthernet1/1
 ip address 172.20.1.129 255.255.255.128
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
router rip
 version 2
 passive-interface FastEthernet0/0
 passive-interface FastEthernet0/1
 passive-interface FastEthernet1/0
 passive-interface FastEthernet1/1
 network 172.20.0.0
 no auto-summary
!
ip classless
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router B2-R2


Current configuration : 1038 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname B2-R2
!
!
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 172.20.2.1 255.255.255.192
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 172.20.2.65 255.255.255.192
 duplex auto
 speed auto
!
interface Serial0/0/0
 ip address 172.20.4.6 255.255.255.252
!
interface Serial0/0/1
 no ip address
 shutdown
!
interface FastEthernet1/0
 ip address 172.20.2.129 255.255.255.192
 duplex auto
 speed auto
!
interface FastEthernet1/1
 ip address 172.20.2.193 255.255.255.192
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
router rip
 version 2
 passive-interface FastEthernet0/0
 passive-interface FastEthernet0/1
 passive-interface FastEthernet1/0
 passive-interface FastEthernet1/1
 network 172.20.0.0
 no auto-summary
!
ip classless
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router B3-R2


Current configuration : 1037 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname B3-R2
!
!
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 172.20.3.1 255.255.255.224
 duplex auto
 speed auto
!
interface FastEthernet0/1
 ip address 172.20.3.33 255.255.255.224
 duplex auto
 speed auto
!
interface Serial0/0/0
 ip address 172.20.4.10 255.255.255.252
!
interface Serial0/0/1
 no ip address
 shutdown
!
interface FastEthernet1/0
 ip address 172.20.3.65 255.255.255.224
 duplex auto
 speed auto
!
interface FastEthernet1/1
 ip address 172.20.3.97 255.255.255.224
 duplex auto
 speed auto
!
interface Vlan1
 no ip address
 shutdown
!
router rip
 version 2
 passive-interface FastEthernet0/0
 passive-interface FastEthernet0/1
 passive-interface FastEthernet1/0
 passive-interface FastEthernet1/1
 network 172.20.0.0
 no auto-summary
!
ip classless
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router R2


Current configuration : 1028 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname R2
!
!
!
enable secret 5 $1$mERr$9cTjUIEqNGurQiFU.ZeCi1
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
interface FastEthernet0/0
 no ip address
 duplex auto
 speed auto
 shutdown
!
interface FastEthernet0/1
 no ip address
 duplex auto
 speed auto
 shutdown
!
interface Serial0/0/0
 ip address 172.20.4.1 255.255.255.252
 clock rate 64000
!
interface Serial0/0/1
 ip address 172.20.4.5 255.255.255.252
 clock rate 64000
!
interface Serial0/1/0
 ip address 172.20.4.9 255.255.255.252
 clock rate 64000
!
interface Serial0/1/1
 ip address 209.165.201.10 255.255.255.252
!
interface Vlan1
 no ip address
 shutdown
!
router rip
 version 2
 passive-interface Serial0/1/1
 network 172.20.0.0
 network 209.165.201.0
 default-information originate
 no auto-summary
!
ip classless
ip route 0.0.0.0 0.0.0.0 Serial0/1/1 
!
!
!
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Para el router ISP-R2


Current configuration : 1086 bytes
!
version 12.3
no service timestamps log datetime msec
no service timestamps debug datetime msec
no service password-encryption
!
hostname ISP-R2
!
!
!
enable secret 5 $1$GMyb$UNr8Qq.Ewy8h5Wtda8FTN/
!
!
!
!
!
!
!
!
!
!
no ip domain-lookup
!
!
!
!
!
!
interface FastEthernet0/0
 ip address 209.165.200.229 255.255.255.252
 duplex auto
 speed auto
!
interface FastEthernet0/1
 no ip address
 duplex auto
 speed auto
 shutdown
!
interface Serial0/0/0
 description Link to R2
 ip address 209.165.201.9 255.255.255.252
 clock rate 64000
!
interface Serial0/0/1
 description Link to ISP-R1
 ip address 209.165.201.6 255.255.255.252
!
interface Vlan1
 no ip address
 shutdown
!
ip classless
ip route 209.165.201.0 255.255.255.252 Serial0/0/1 
ip route 209.165.200.224 255.255.255.252 Serial0/0/1 
ip route 172.20.0.0 255.255.0.0 Serial0/0/0 
ip route 10.1.0.0 255.255.0.0 Serial0/0/1 
!
!
!
banner motd ^C
********************************
  !!!AUTHORIZED ACCESS ONLY!!!
********************************
^C
!
!
!
!
line con 0
 password cisco
 login
line vty 0 4
 password cisco
 login
!
!
!
end

Con fines de pruebas de conectividad he agregado una pc a una de las 4 lan de cada sede. Aca en la imágen se puede apreciar mejor xD!!

Evidentemente cada computadora debe tener su respectiva configuración. Aca se las dejo también xD!!!

Algunos tips muy útiles al momento de configurar un router Cisco. Evidentemente estos tips están de acuerdo a las necesidades de configuración para este laboratorio y a las prestaciones que se quieren alcanzar.

Tip 1!!!!!
Desactivar sumarización automática


R(config)#router rip
R(config-router)#no auto-summary

Tip 2!!!!!
Desactivar las actualizaciones de enrutamiento en las interfaces adecuadas

Muchas veces carece de sentido el envío de actualizaciones de enrutamiento a través de interfaces a las que no hay conectados dispositivos que dialoguen utilizando ese mismo protocolo. En otras ocaciones, razones de seguridad hacen aconsejable no publicar el estado de nuestras redes a través de determinadas interfaces.


R(config)#router rip
R(config-router)#passive-interface

Ejemplo:


R(config)#router rip
R(config-router)#passive-interface fastEthernet 0/0

Tip 3!!!!!
Configurar los intervalos de hello en los router de sucursal en 30 segundos.

Si cambia el intervalo de Hello no olvide de cambiar también el tiempo de espera a un valor igual o superior al intervalo de saludo.


R#conf terminal 
R(config)#interface serial 0/0/0
R(config-if)#ip hello-interval eigrp <id> <tiempo en segundos>
R(config-if)#ip hold-time eigrp <id> <tiempo en segundos>

Ejemplo


B3-R1#conf terminal 
B3-R1(config)#interface serial 0/0/0
B3-R1(config-if)#ip hello-interval eigrp 1 30
B3-R1(config-if)#ip hold-time eigrp 1 180

Tip 4!!!!!
Configurar una ruta estática por defecto.


R(config)#ip route 0.0.0.0 0.0.0.0 <interfaz de salida>

Ejemplo


R2(config)#ip route 0.0.0.0 0.0.0.0 serial 0/0/1

Tip 5!!!!!
Configurar un router para enviar información de la ruta estática por defecto a otros routers de la red.


R(config)#router rip
R(config-router)#default-information originate

Y para finalizar aca les dejo el archivo pka si es que ya no tienen tiempo de leer todo lo anterior xD!!!!

Y aca les dejo otro link hacia el laboratorio de integración del capítulo 6.

Cap. 6: Reto de integración de habilidades de Packet Tracer

Eso es todo, espero les sea de utilidad y no olviden dejar sus comentarios que motiven el seguir compartiendo el conocimiento. Saludos desde Trujillo-Perú xD!!!!!!

Splash Screen o Ventana Splash en java usando Netbeans

2010-08-12T00:21:00.017-05:00

Una imágen vale más que mil palabras dicen muchos... cierto o no, he tomado al pie de la letra esa frase y aca les presento este post dedicado a las tan conocidas ventanas splash. Tutoriales en internet hay por montones, pero este post te guiará paso a paso usando imágenes que te mostrarán exactamente lo que tienes que hacer.
Para este post no estoy creando la ventana splash desde cero usando un JWindow o un JDialog, sino que uso la última funcionalidad que el java brinda para este tipo de cosas, según lo describe Oracle en su artículo http://java.sun.com/developer/technicalArticles/J2SE/Desktop/javase6/splashscreen/

Espero te sea de utilidad y agradezcas dejando un comentario que motive seguir compartiendo el conocimiento xD!!!!!

Paso 1. Crear Proyecto

Paso 2. Seleccionar el nombre del proyecto

Paso 3. Opciones adicionales del proyecto

Paso 4. Creando un paquete ^^!

Paso 5. Poniéndole nombre al paquete ¬¬

Paso 6. Creando un JFrame

Paso 7. Nombrando al JFrame creado

Paso 8. Accediendo a la carpeta src. Esta carpeta está dentro de la carpeta del proyecto y aquí es donde debemos poner la imágen que se mostrará en la ventana splash.

Paso 9. Pegamos nuestra imágen!!!.

Paso 10. Accedemos a las propiedades del proyecto.

Paso 11. Establecemos la clase principal.

Paso 12. Editamos el manifest.mf que se encuentra en la carpeta del proyecto y agregamos lo siguiente:


SplashScreen-Image: splash.jpg

Paso 13. Verificamos que el archivo manifest.mf quede algo así:

Limpiamos el proyecto y lo estructuramos, o sea Clean and Build y listo, eso es todoo!!!!!! En el proyecto que adjunto encontrarán algunos detalles que de seguro ahorita están por su mente xD!!!

Y así se debería ver:

Solo es cuestión de tener buenos gustos jeje ^^!

Ahora, no solo pueden poner una imágen sino también un gif animado, lo cual le dará más vistosidad o hasta una imágen png con canal alfa y toda esa nota de transparencias para obtener una splash screen como el camaleón del CorelDraw ^^!

También en este artículo encontrarán información adicional sobre este tema:
http://wiki.netbeans.org/Splash_Screen_Beginner_Tutorial

Procesamiento de Video en Tiempo Real Con Java

2010-06-30T21:19:00.013-05:00

Al fin otro post ... han pasado meses desde mi último post y hoy mientras revisada algunos apuntes de la universidad encontré un programa que hice en mis ratos libres acerca del procesamiento de video. Antes de escribir este pequeño código tenía un montón de dudas acerca del procesamiento de video. Y de eso trata este post, de dar solución a esas dudas que obviamente no son solo mías sino seguro de muchos novatos en programación.

Bueno, luego de esta pequeña introducción empezemos a hablar acerca del procesamiento de video resolviendo las dudas que yo tenía.

Mi primera duda era: ¿Qué hace diferente al procesamiento de imágenes del procesamiento de video? ... Y esta duda me surgió porque yo tenía la implementación de algunos algoritmos de procesamiento de imágenes y pensaba que quizás podría aplicarlos en alguna cosa interesante. La respuesta a esta pregunta es que es casi lo mismo, es más, me animaría a decir que el procesamiento de video no es más que el procesamiento secuencial de imágenes dentro de un intervalo de tiempo.
Y es que para lograr procesar video solo basta acceder a sus frames e ir procesando imágen por imágen al mismo tiempo que es capturado para poder dar la sensación de movimiento y que es tiempo real.

First doubt has been solved!! xD

Mi segunda duda era: ¿Y qué herramientas puedo utilizar para poder procesar el video? ... Evidentemente hay muchas, pero yo personalmente prefiero Java que son su framework JMF(Java Media Framework) (que evidentemente no es la gran cosa, así que no pidamos maravillas) nos provee la API necesaria para poder acceder a los dispositivos de captura de video y también manipular los datos de un achivo multimedia.

Tercera duda: Bien, ya instalé el Java Media Framework, ahora ¿Cómo instancio un dispositivo de captura de video? ... Bueno, como siempre digo: Un poco de líneas de código dice más que mil papers

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package view;

import java.awt.BorderLayout;
import javax.media.CaptureDeviceInfo;
import javax.media.CaptureDeviceManager;
import javax.media.Manager;
import javax.media.MediaLocator;
import javax.media.Player;
import javax.media.Processor;
import javax.swing.JFrame;

/**
*
* @author Rolando
*/
public class InstanciarCamara extends JFrame {

//Atributos necesarios para acceder a una cámara web
private static Player player;
private MediaLocator localizador;
private Processor p;
private CaptureDeviceInfo dispositivo = null;
private static String source = "vfw:Microsoft WDM Image Capture (Win32):0";

public InstanciarCamara() {
setLayout(new BorderLayout());
setSize(500, 400);
setLocationRelativeTo(null);    //Centrar Ventana
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("Demo Cámara Web");
player = null;
localizador = null;
dispositivo = CaptureDeviceManager.getDevice(source);
localizador = dispositivo.getLocator();
iniciarCaptura();
}

private void iniciarCaptura() {
try {
player = Manager.createRealizedPlayer(localizador);
player.start();
if (player.getVisualComponent() != null) {
add(player.getVisualComponent(), BorderLayout.CENTER);
}
} catch (Exception e) {
System.err.println(e.toString());
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
InstanciarCamara.setDefaultLookAndFeelDecorated(true);
InstanciarCamara camara = new InstanciarCamara();
camara.setVisible(true);
}

}

Con eso ya podemos acceder a una cámara web por ejemplo.

Cuarta duda: Bien, ya puedo acceder a un dispositivo de captura, pero ¿Cómo accedo a los frames para poder procesarlos? Y es aquí donde el java media framework otra vez, gracias a su API, nos provee unos métodos que nos ayudarán a realizar esta tarea. A ver, veamos estas palabras reflejadas en otro poco de código.

Primero necesitaremos un panel para poder cargar la imágen procesada. Este panel solo reescribirá el método paint. A continuación el código.

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/*
* Lienzo.java
*
* Created on 14/05/2009, 02:11:36 PM
*/

package com.test;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;

/**
*
* @author Rolando
*/
public class Lienzo extends javax.swing.JPanel {

private BufferedImage imagen;

/** Creates new form Lienzo */
public Lienzo() {
imagen = null;
}

public void setImage(BufferedImage imagen) {
this.imagen = imagen;
repaint();
}         

@Override
public void paint( Graphics g ) {
super.paint( g );
if( imagen != null ) {
g.drawImage(imagen, 0, 0, getWidth(), getHeight(), this);
g.setColor(Color.BLACK);
g.drawString("http://rolandopalermo.blogspot.com", 10, 20);
}
}                 

}

Y ahora para ver como se capturan los frames del video proveniente de una cámara web les dejo un pequeño proyecto de netbeans.

Espero les sea de utilidad y cualquier pregunta, no duden en consultarme.

La historia tras un reproductor de música ... RaiZex DJ™ RC 1.0

2010-04-22T17:33:00.027-05:00

Mi blog ... una bitácora de las cosas que hago. Este post no va a tener el mismo formalismo que los anteriores puesto que ha sido escrito en un momento de inspiración ^^. Hoy, 22 de Abril del 2010 es una fecha muy importante para mí aunque quizás si algunas cosas no hubiesen sucedido esta fecha sería aún más especial pero bueno, sucedieron y aca estoy yo igual de contento de todos modos pues la vida continua.

Y como dice el título, una historia tras un reproductor de música, de eso les voy a contar en este post. No habrá código, no habrá artículos, ni consejos de como hacerse uno propio pero lo que si habrá es anécdotas por montones, cosas que pasé, cosas que sucedieron .. en fin, ahí vamos XD.

Transcurrían los meses entre julio y septiembre del 2009, yo aún estaba en la universidad en esos pesados ciclos. Trabajos por acá, trabajos por allá ... uf!! que cansado era todo esto hasta que se me presentó la primera oportunidad de poner en práctica todooo mi conocimiento adquirido en las aulas de mi universidad, la Universidad Nacional de Trujillo. Era una radio, Radio Libertad de Trujillo, la que solicitaba de mis servicios. Necesitaban la configuración de un servidor de audio por internet ... es así que se empezó a trabajar, junto a otro compañero y bueno, pasaron los días y el trabajo estuvo hecho. Me sentía contento, había tenido éxito en mi primer enfrentamiento al mundo laboral, al trabajo bajo presión, a las exigencias de un empresario para quien el tiempo es dinero. Heeee, salí airoso de mi primera batalla y además había aprendido un poco más acerca de los formatos de audio - que el mp3 es esto, que el ogg lo otro - que felicidad. Y bueno, también la U finalizaba, empezaba la huelgaaa. "Tiempo de Investigarrrrrrrr", ese era mi frase cada vez que se iniciaba una huelga ^^ y me adentré al mundo multimedia XD ...

Recuerdo haber escuchado de un trabajo que tenían unos amigos que llevaban un curso de procesamiento del habla. Se trataba de graficar el espectro de un archivo .wav ... aquí empezó todooooo. Tardé casi 2 semanas pero lo hice, siiii lo hice, mi primer programa para graficar audioo, que felicidad. Ordené el código y lo posteé en este blog. Estoy hablando del Spectrum Analyzer.

No me cansaba de probarlo, luego de un tiempo intenté graficar archivos wav más pesados y en este intento me acordé de algo: "Recuerdo cuando tenía 19 años y estaba en VI ciclo de la universidad era muyy terco con el java, no lo podía aprender :p y en mi primer encuentro con el Java Media Framework intenté hacerme un reproductor de música, proyecto que claro, nunca acabé"... Es así que entonces me dije: Estamos de huelga en la U, solo estudio inglés 3 veces a la semana por las tardes ... todo estaba a favor de la ciencia (Otra de mis frases ^^) ...

Se acercaba diciembre, mes de navidad, y yo con tantas cosas en la cabeza, claro que no todo era ciencia. Ya saben ... cosas que nos pasa a los jovenes ^^. Y se me ocurrió poder graficar todo tipo de archivo de audio. En ese lapso de tiempo decidí juntar lo que había querido hacer hace tiempo (El reproductor) y lo que quería hacer ahora (Graficar Archivos de Audio). Entonces nació la idea de hacer mi primer apoyo al mundo del Software Libre: "Un reproductor de música". Empezé a leer por acá, páginas por allá, foros y bueno, luego de unos días de lectura hice el primer reproductor cuyo nombre tiene un significado muy especial para mí ^^, es el nombre de una fabulosa persona, Raisa Tatiana XD. Era increíble, lo había conseguido, RaiZex™ estaba listo XD ... pero fiel a mi estilo, no estaba contento, sabía que este reproductor no tendría futuro alguno, había que agregarle más cosas, de ley que siii. De todos modos les dejo una foto para que vean como me quedó, claro que no acepto críticas, jajajajaja

Sabía que le faltaba infinidad de cosas, entonces me puse a pensar que más podía agregarleee ... y se acercaba la navidadddd, y muy al contrario de lo que esto significa, para mí significaba el acercamiento de un evento que no me gustaría nada. Fué terrible!!!! ^^. Bueno ya, sigamos ... Entré a practicar Kung-fu, practicaba boxeo, el inglés, los sentimientoss .... aaaaa el tiempo no me daba. Poco a poco me fuí desligando de estas cosas para poder acabar este proyecto que lógicamente tenía más prioridad. Y es así que luego de casi 1 semana acabé esta segunda versión, igual de pobre que la primera jajaja, pero tenía un significado especial :p a parte del cambio de nombre claro. Había nacido RaiZex DJ™ (Este nuevo nombre se lo debo a mi mejor amigo Gerald Infante XD ... aunque claro, él se inspiró en la misma persona jeje), acá les dejo una foto y obviamente tampoco acepto críticas jajajaja

Aunque igual de humilde que la anterior, fué el primer paso de algo más ambicioso. Ya no quería solo culminar mi reto de hacer mi propio reproductor, No Señorr!!!, quería algo que fuese más allá, algo que trascienda en el mundo multimedia :p. Quería hacer un reproductor tan bueno como el winamp, el iTunes, el Amarok ... vaya que era todo un reto. Entonces manos a la obra, me puse a trabajar, la navidad cada vez más cerca, los sentimientos que daban vuelta en mi cabeza, los golpes del boxeo ... Oh!!! todo en contraaaaa, como siempre XD.

A programar, siii, a programar, luego de otra semana de programación estaba lista, siiiii, mi primer reproductorrr. Aunque claro solo soportaba "wav", "aif", "au" ya era algo. (La navidad había llegado) Me quedó algo así XD:

Aca ya se aceptan algunas críticas :p ... claro que no usaba ningún jar extraaa, excepto el del look and feel ^^. Estaba listoo, siiii, estaba listo para su liberación. A crear la cuenta de sourceforge, en googlecode, a conquistar el mundoooooooooo ... pero algo me bajó de la nube: Quién cambiaría todaaa su música de mp3 u ogg a wav solo para usar mi reproductor??? ... nadieeeeee. Y entonces me dije: Es tiempo de recurrir al software libre :D. Y sin darme cuenta cuenta era 31 de diciembreeeeeee, qué??????????? 31 de diciembreeee, fin de añooo, tiempo para dejar muchas cosas atras, para tomar decisiones para el siguiente añooo. Y siii, eso hice: "Este reproductor no será cualquier cosa, no señorrr!!!!".

Pasaron los meses, enero, febrero, marzo, clases en la universidad, clases de inglés, clases en CISCO, adios box, adios Kung-fu, adios muchas otras cosas ... el trabajo continuó, pero lento, programaba media hora al dia o quizás un poco más. Luego le comenté de mi idea a una amiga, mi amiga Zully Sheena (o Xena como le decimos jejeje), muyyy buena programadoraaa, de las mejoresssssss. Le dije: "Mira, estoy haciendo esto, qué te parece?". Le gustó la idea, se unió al desarrollo y ya eramos dos, siiiii, ya eramos dossss. Entonces nos pusimos manos a la obra, a terminar estoo!!! de ley que siiiiii. Al momento de escribir el post ya tenemos esto: La release candidate 1.0 - heeeeeee, algo bonito al finnn, mírenlo ustedes:

Ya se aceptan críticas XD

Hoy hemos sido invitados a exponer el proyecto en la FLISOL, somos parte de la COLISOL ... vaya, hasta donde llegó la idea. Esto si que es bueno, pero es producto de conocer a la gente exacta en el momento exacto. Gracias a todoss, espero el proyecto vaya adquiriendo más gente, que se haga más grandeeee, en fin ... qusiiera tantas cosas y bueno ... son cosas de la vida.

Es 22 de Abril del 2010 ... como dice Pedrito Suarez, cierren su historia de amor, terminen su libro. Y este post se ha terminado XD.

Reloj Digital con Displays de 7 Segmentos y PIC 16F84A

2010-04-05T13:52:00.020-05:00

En esta oportunidad quiero compartir con ustedes un sencillo reloj basado en un Microcontrolador PIC de la serie 16F84A y usando display ánodo común de 7 segmentos.

Adicionalmente usa otros circuitos con la finalidad de expander el número de salidas, tanto para control como para datos, y de esa forma podemos contar con más displays y más opciones de Configuración. Entre estos circuitos tenemos el conocido 74LS47, de cuál dejaré el esquema mostrando la disposición de sus pines (Figura 1), así como su tabla de verdad (Figura 2). Para mayor información pueden consultar el datasheet de este componente.

Disposición de pines

Tabla de Verdad

Otro circuit usado es el 74LS138, el cuál funcionará como selector de display para realizar el efecto de barrido. No detallaré tampoco a este componente puesto que no es el objetivo de este post, pero si dejaré algunas imágenes, que al igual que las anteriores, nos da una vista rápida de la disposición y el funcionamiento de este integrado.

Disposición de pines

Tabla de Verdad

También dejaré el diagrama de pines de un display de 7 segmentos.

Ahora, una vez conocido el funcionamiento de los componentes individuales, a continuación muestro el diagrama total del reloj, en donde veremos como estos integrados interactuan entre sí para poder obtener nuestro sencillo reloj digital.
Las resistencias que van a los displays son de 330Ω (Naranja, Naranja, Marrón) y las que van a los transistores son de 1KΩ (Marrón, Negro, Rojo). Y claro, las resistencias que van a los pulsadores son de 10KΩ (Marrón, Negro, Naranja).

Antes que nada tenemos que conectar los componentes básicos para el funcionamiento del microcontrolador pic, que son las conexiones a tierra y 5 voltios, el reloj de 4MHz y los capacitores.

Luego podemos armar el siguiente diagrama esquemático para tener en funcionamiento a nuestro sencillo Reloj Digital.

Archivos adjuntos del proyecto:

El código está escritor en ensamblador. Pueden usar el mplab para recompilarlo y usarlo de acuerdo a sus necesidades.

__CONFIG   _CP_OFF &  _WDT_OFF & _PWRTE_ON & _XT_OSC
LIST    P=16F84A
INCLUDE  <P16F84A.INC>

M_UNI equ  H'1D' ; Registro para las unidades de los minutos.
M_DEC equ  H'1C' ; Registro para las decenas de los minutos.

H_UNI equ  H'1F' ; Registro para las unidades de las horas.
H_DEC equ  H'1E' ; Registro para las decenas de las horas.

S_UNI equ  H'20' ; Registro para las unidades de los segundos.
S_DEC equ  H'21' ; Registro para las decenas de los segundos.

BARR equ  H'1B' ; Registro para almacenar el número de barridos.
PAUSE equ  H'1A' ; Registro para almacenar el tiempo de barrido.

;Algunas definiciones de registros y pines
;-----------------------------------------
#DEFINE  REINICIO PORTA,0   ; Pulsador conectado a RA0.
#DEFINE  MINUTO  PORTA,1   ; Pulsador conectado a RA1.
#DEFINE  HORA  PORTA,2   ; Pulsador conectado a RA2.
#DEFINE  DISPLAY  PORTB   ; El display está conectado al Puerto B.

ORG 0

Inicio
bsf  STATUS,RP0  ; Acceso al Banco 1.
clrf DISPLAY   ; Línea del LED configurada como salida.
movlw b'00011111'  ; Las 5 líneas del Puerto A se configuran como entrada.
movwf PORTA
bcf  STATUS,RP0  ; Acceso al Banco 0.
;Inicialización de Registros
;---------------------------
clrf S_UNI   
clrf S_DEC
clrf M_UNI
clrf M_DEC
clrf H_UNI
clrf H_DEC
clrf BARR
;---------------------------

Principal
clrf BARR    ; Limpiamos el registro de barridos
;Para el botón de reinicio no importa los rebotes
;------------------------------------------------
VerificarPulsadorReset
btfss REINICIO   ; ¿Pulsador reposo?, ¿Pulsador=1?
call InicializarRegistros
;------------------------------------------------------------------------------

;Para el botón de incremento de minutos si importan los rebotes
;--------------------------------------------------------------
VerificarPulsadorMinutos
btfsc MINUTO     ; ¿Pulsador presionado?, ¿(Pulsador)=0?
goto VerificarPulsadorHoras ; No vuelve a leerlo
call Temporizador   ; Espera a que se estabilicen los niveles de tensión.
btfsc MINUTO     ; Comprueba si es un rebote.
goto VerificarPulsadorHoras ; Era un rebote y sale.
goto    SoloMinutosEnUno  ; Salta a la subrutina para incrementar los minutos en 1
;------------------------------------------------------------------------------

;Para el botón de incremento de horas también importan los rebotes
;-----------------------------------------------------------------
VerificarPulsadorHoras
;------------------------------------------------------------------------------
btfsc HORA      ; ¿Pulsador presionado?, ¿(Pulsador)=0?
goto SoloSegundosEnUno   ; No vuelve a leerlo
call Temporizador    ; Espera a que se estabilicen los niveles de tensión.
btfsc HORA      ; Comprueba si es un rebote.
goto SoloSegundosEnUno   ; Era un rebote y sale fuera.
call    SoloHorasEnUno
;------------------------------------------------------------------------------

SoloSegundosEnUno
call IncrementarSegundosEnUno

Mostrar
call ValidarTiempo
call Barrido
;------------------------------------------------------------------------------

Fin 
goto Principal
;------------------------------------------------------------------------------

SoloMinutosEnUno
call IncrementarMinutosEnUno
goto Mostrar

SoloHorasEnUno
call IncrementarHorasEnUno
goto Mostrar

;*************************************
; Subrutina de Incremento de Registros
;*************************************

;------------------------------------------------------------------------------
IncrementarSegundosEnUno
incf S_UNI,f      ; Incrementa el valor de S_UNI
movfw S_UNI      ; Carga W con el valor del regustro S_UNI
sublw D'10'      ; Resta 10 para verificar si S_UNI=10?
btfsc STATUS, Z     ; Verifica si el resultado fué cero
call IncrementarSegundosEnDiez ; Si es cero, entonces acarreamos uno
return
;------------------------------------------------------------------------------

IncrementarSegundosEnDiez
clrf S_UNI      ; El acarreo implica limpiar el registro anterior
incf S_DEC,f      ; Incrementa el valor de S_DEC
movfw S_DEC      ; Carga W con el valor del regustro S_DEC
sublw D'6'      ; Resta 6 para verificar si S_UNI=6?
btfsc STATUS, Z     ; Verifica si el resultado fué cero
call IncrementarMinutosEnUno  ; Si es cero, entonces acarreamos uno
return
;------------------------------------------------------------------------------

IncrementarMinutosEnUno
clrf S_DEC      ; El acarreo implica limpiar el registro anterior
incf M_UNI,f      ; Incrementa el valor de M_UNI
movfw M_UNI      ; Carga W con el valor del regustro M_UNI
sublw D'10'      ; Resta 10 para verificar si S_UNI=10?
btfsc STATUS, Z     ; Verifica si el resultado fué cero
call IncrementarMinutosEnDiez ; Si es cero, entonces acarreamos uno
return
;------------------------------------------------------------------------------

IncrementarMinutosEnDiez
clrf M_UNI      ; El acarreo implica limpiar el registro anterior
incf M_DEC,f      ; Incrementa el valor de M_DEC
movfw M_DEC      ; Carga W con el valor del regustro M_DEC
sublw D'6'      ; Resta 6 para verificar si S_UNI=6?
btfsc STATUS, Z     ; Verifica si el resultado fué cero
call IncrementarHorasEnUno  ; Si es cero, entonces acarreamos uno
return
;------------------------------------------------------------------------------

IncrementarHorasEnUno
clrf M_DEC      ; El acarreo implica limpiar el registro anterior
incf H_UNI,f      ; Incrementa el valor de H_UNI
movfw H_UNI      ; Carga W con el valor del regustro H_UNI
sublw D'10'      ; Resta 6 para verificar si S_UNI=10?
btfsc STATUS, Z     ; Verifica si el resultado fué cero
call  IncrementarHorasEnDiez  ; Si es cero, entonces acarreamos uno
return
;------------------------------------------------------------------------------

IncrementarHorasEnDiez
clrf H_UNI      ; El acarreo implica limpiar el registro anterior
incf H_DEC,f      ; Incrementa el valor de H_DEC
movfw H_DEC      ; Carga W con el valor del regustro H_DEC
sublw D'10'      ; Resta 6 para verificar si S_UNI=10?
btfsc STATUS, Z     ; Verifica si el resultado fué cero
clrf H_DEC      ; Si es cero, entonces acarreamos uno
return
;------------------------------------------------------------------------------

;*********************************
; Subrutina de Barrido de Displays
;*********************************

;------------------------------------------------------------------------------

Barrido
btfss REINICIO   ; ¿Pulsador reposo?, ¿Pulsador=1?
call InicializarRegistros
incf BARR, f    ; Incrementa en 1 el registro de barridos
;Unidades de segundos
;--------------------
movlw b'00001111'  ; Activamos el primer display
movwf DISPLAY   ; Movemos el dato al puerto B
movf S_UNI,0   ; Mueve M_UNI al registro W
iorlw b'00000000'  ; Aplicamos la máscara
movwf   DISPLAY   ; Mostramos en el puerto B
call  Temporizador ; Pausa para establecer niveles de tensión correctamente
movlw B'00001111'  ; Cargamos el valor adecuado a W para limpiar los registros
movwf DISPLAY   ; Limpiamos el display para evitar que los dígitos se repitan
;------------------------------------------------------------------------------
;Decenas de segundos
movlw b'00011111'  ; Activamos el segundo display
movwf DISPLAY   ; Movemos el dato al puerto B
movf S_DEC,0   ; Mueve S_DEC al registro W
iorlw b'00010000'  ; Aplicamos la máscara
movwf   DISPLAY   ; Mostramos en el puerto B
call  Temporizador ; Pausa para establecer niveles de tensión correctamente
movlw B'00011111'  ; Cargamos el valor adecuado a W para limpiar los registros
movwf DISPLAY   ; Limpiamos el display para evitar que los dígitos se repitan
;------------------------------------------------------------------------------
;Unidades de minutos
movlw b'00101111'  ; Activamos el tercer display
movwf DISPLAY   ; Movemos el dato al puerto B
movf M_UNI,0   ; Mueve M_UNI al registro W
iorlw b'00100000'  ; Aplicamos la máscara
movwf   DISPLAY   ; Mostramos en el puerto B
call  Temporizador ; Pausa para establecer niveles de tensión correctamente
movlw B'00101111'  ; Cargamos el valor adecuado a W para limpiar los registros
movwf DISPLAY   ; Limpiamos el display para evitar que los dígitos se repitan
;------------------------------------------------------------------------------
;Decenas de minutos
movlw b'00111111'  ; Activamos el cuarto display
movwf DISPLAY   ; Movemos el dato al puerto B
movf M_DEC,0   ; Mueve M_UNI al registro W
iorlw b'00110000'  ; Aplicamos la máscara
movwf   DISPLAY   ; Mostramos en el puerto B
call  Temporizador ; Pausa para establecer niveles de tensión correctamente
movlw B'00111111'  ; Cargamos el valor adecuado a W para limpiar los registros
movwf DISPLAY   ; Limpiamos el display para evitar que los dígitos se repitan
;------------------------------------------------------------------------------
;Unidades de horas
movlw b'01001111'  ; Activamos el quinto display
movwf DISPLAY   ; Movemos el dato al puerto B
movf H_UNI,0   ; Mueve M_UNI al registro W
iorlw b'01000000'  ; Aplicamos la máscara
movwf   DISPLAY   ; Mostramos en el puerto B
call  Temporizador ; Pausa para establecer niveles de tensión correctamente
movlw B'01001111'  ; Cargamos el valor adecuado a W para limpiar los registros
movwf DISPLAY   ; Limpiamos el display para evitar que los dígitos se repitan
;------------------------------------------------------------------------------
;Decenas de horas
movlw b'01011111'  ; Activamos el sexto display
movwf DISPLAY   ; Movemos el dato al puerto B
movf H_DEC,0   ; Mueve M_UNI al registro W
iorlw b'01010000'  ; Aplicamos la máscara
movwf   DISPLAY   ; Mostramos en el puerto B
call  Temporizador ; Pausa para establecer niveles de tensión correctamente
movlw B'01011111'  ; Cargamos el valor adecuado a W para limpiar los registros
movwf DISPLAY   ; Limpiamos el display para evitar que los dígitos se repitan
;------------------------------------------------------------------------------
;Verificar barrido
movfw BARR   ; carga W con el número de barridos
sublw D'50'   ; Resta 50 para comparar si es igual a 50
btfsc STATUS, Z  ; Verifica si el resultado fué 0, o sea si BARR=50?
return     ; Se completó el número de barridos
goto    Barrido
;------------------------------------------------------------------------------

ValidarTiempo
movfw H_UNI   ; Carga el registro W con el valor del registro H_UNI
sublw D'4'   ; Resta 4 para verificar si es que el valor de W=4?
btfsc STATUS, Z  ; Verifica si el resultado fué cero
goto ValidarHora  ; Ahora llamamos al subrutina para verificar el siguiente dígito de la hora
return
;------------------------------------------------------------------------------

ValidarHora
movfw H_DEC     ; Carga el registro W con el valor del registro H_DEC
sublw D'2'     ; Resta 2 para verificar si es que el valor de W=2?
btfsc STATUS, Z    ; Verifica si el resultado fué cero
goto InicializarRegistros ; Al llamar a esta subrutina quiere decir que la hora=24, lo cuál implica un reinicio
return
;------------------------------------------------------------------------------

InicializarRegistros
clrf S_UNI
clrf S_DEC
clrf M_UNI
clrf M_DEC
clrf H_UNI
clrf H_DEC
return
;------------------------------------------------------------------------------

Temporizador
movlw D'255'  ; w = 50 decimal
movwf PAUSE  ; K = w

Kloop
decfsz PAUSE,f  ; K = K - 1 , salta a la siguiente instrucción si es cero.
goto  Kloop
return
;------------------------------------------------------------------------------

END    ; Fin del programa.

CCNA 4.0 exploration 1 - Exámen Capítulo 7 en Español

2010-03-27T15:46:00.006-05:00

Aquí les dejo un exámen del curso de certificación CISCO correspondiente al Capítulo 7 del CCNA 4, Capa de Enlace de Datos. El exámen está resuelto al 100%, espero les sea de utilidad.

Configurando Bison en Windows para Desarrollar una Sencilla Calculadora con Notacion Polaca

2010-01-26T19:12:00.011-05:00

Como podemos leer en la wikipedia, GNU|bison es un programa generador de analizadores sintácticos de propósito general perteneciente al proyecto GNU disponible para prácticamente todos los sistemas operativos, se usa normalmente acompañado de flex aunque los analizadores lexicos se pueden también obtener de otras formas.

En un post anterior mencioné la forma en que uno podía configurar Flex para realizar analizadores léxicos. Bueno, en esta oportunidad vamos a desarrollar una sencilla calculadora con Bison y Flex.

Los pasos para configurar el flex, nos dejan configurado al bison, listo para ser usado en nuestra calculadora.

Ahora, voy a pasar a explicar la forma que deben tener los scripts que ingresaremos tanto a flex como a bison.

Para flex el script debe tener la siguiente estructura:

%{

#include <stdio.h>
#include "y.tab.h"
%}
%option noyywrap
%option yylineno

DIGITO [0-9]
ID [a-zA-Z][a-zA-Z0-9_]*

%%
{DIGITO}+("."{DIGITO}+)? {yylval.real=atof(yytext); return(TKN_NUM);}
"="    {return(TKN_ASIGN);}
";"    {return(TKN_PTOCOMA);}
"*"    {return(TKN_MULT);}
"/"    {return(TKN_DIV);}
"+"    {return(TKN_MAS);}
"-"    {return(TKN_MENOS);}
{ID}   {return(TKN_ID);}
%%

Como nos podemos dar cuenta, en este fichero declaramos los símbolos y las expresiones que forman a los token numero (TKN_NUM). Asumo que ya tienen conocimiento de cada una de las partes de un archivo de flex, así que ahora paso a mostrar la forma que debe tener el archivo que le ingresaremos a Bison:

%{

#include <stdio.h>
#include <math.h>
extern int yylex(void);
extern char *yytext;
void yyerror (char *s);

%}

%union
{
float real;
}

%start Calculadora

%token <real> TKN_NUM
%token TKN_ASIGN
%token TKN_PTOCOMA
%token TKN_MULT
%token TKN_DIV
%token TKN_MAS
%token TKN_MENOS

%token <real> TKN_ID
%type <real> Expresion

%left TKN_MAS TKN_MENOS
%left TKN_MULT TKN_DIV

%%

Calculadora: TKN_ID {printf("El valor de %s es:", yytext);}
TKN_ASIGN Expresion TKN_PTOCOMA{printf("%5.2f", $4);};
Expresion : TKN_NUM{$$=$1;}|
Expresion Expresion TKN_MAS {$$=$1+$2;}|
Expresion Expresion TKN_MENOS {$$=$1-$2;}|
Expresion Expresion TKN_MULT {$$=$1*$2;}|
Expresion Expresion TKN_DIV {$$=$1/$2;};

%%

void yyerror(char *s)
{
printf("Error %s", s);
}

int main()
{
yyparse();
return 0;
}

Tampoco voy a explicar la estructura de este fichero puesto que la documentación en internet es muy variada.

Lo que si voy a detallar es la forma de obtener los ficheros *.c y *.h, puesto que, a mi parecer, es lo más confuso y poco explicado.

Como mencioné anteriormente, al configurar el flex siguiendo los pasos que expliqué en el post anterior el Bison quedará configurado también. Así que solo hay que realizar los siguientes comandos por consola y tendremos todo listo para integrarlo a nuestro proyecto de Dev-C++.

Situamos ambos ficheros en el directorio D:\calculadora(Si no existe, tenemos que crearlo, lógicamente) y luego abrimos una consola de Windows, hacemos lo mismo que hicimos con el Flex, estableciendo las variables de entorno, como muestro en la siguiente imágen:

Y con esos comandos se nos generará unos ficheros, los cuales automáticamente podemos integrarlo a un proyecto de Dev-C++ por ejemplo o agregarle más funciones.

Ahora ya tenemos lista nuestra sencilla calculadora escrita con ayuda de Bison y Flex. Solo debemos ejecutar Calculadora.exe e ir introduciendo algunas expresiones (En notación polaca claro)

a=4 5+;
hola=8 12*;
g=12 6/;

Aquí les dejo la carpeta del proyecto con los archivos tanto de flex como de bison. También les muestro la forma de correr el programa de la calculadora en la siguiente imágen:

Para algo más aplicativo puedes revisar esto:
http://rolandopalermo.blogspot.com/2010/10/lex-y-bison-en-un-solo-analizador.html

Creando un ejecutable con Swi-Prolog

2010-01-26T11:31:00.019-05:00

Este post lo escribí pues algunos amigos me comentaron cómo se podría crear un ejecutable con swi prolog. Bueno, SWI-Prolog nos provee de un mecanismo sencillo para la creación de ejecutables.

La manera de hacerlo es como muestro a continuación:

Primero debemos tener un cuerpo principal, en donde estén los predicados que se ejecutaran al inicio de la llamada a nuestro programa, lo que se asemeja a la función principal de C:

int main(int argc,char *argv[])
{
//Cuerpo de la función principal
return 0;
}

O al método principal de Java:

public Class Main() {

public static void main(String[] arg) {
//Cuerpo del método principal
}

}

En nuestro caso, en SWI-Prolog se declararía del siguiente modo (Hago referencia a SWI-Prolog y no al lenguaje en general, puesto que cada Entorno de Prolog tiene su propia forma de realizar este proceso) :

main:-
%
% Cuerpo del predicado principal
%
halt.

Luego de realizado este proceso, tendrémos que invocar al predicado que se encargará de crear el ejecutable en sí.

qsave_program('c:/ejecutable.exe', [stand_alone(true), goal(main)]).

Con eso bastará para distribuir nuestro propio ejecutable, teniendo en cuenta que al llevar de una máquina a otra al *.exe, se debe hacer lo mismo con los archivos *.dll de la carpeta \bin de la instalación de nuestro SWI-Prolog. (tanto *.dll's como *.exe deben estar en una misma carpeta).

Para cerrar este post, aquí les dejo el código fuente de un Sistema Tomador de Decisiones para la detección de plagas en sembríos de Tara así como su respectivo ejecutable (ejecutable.exe). Debemos descomprimir todos los archivos en la unidad C: de tal forma que nos quede 'C:\programa' y luego seguir los pasos arriba mencionados para generar el ejecutable.

En todo caso adjunto las dll necesarias, en caso no se quiera instalar todo el SWI-Prolog. Las pueden descargar aquí.

Recuerden que dentro de la carpeta programa hay un archivo léeme!!!!.txt es cuál es muy importante que lo lean, o en todo caso lean estos tips para poder ejecutar el sistema experto y generar su respectivo ejecutable:

1. Primero debes crear una carpeta en tu unidad C:\ llamado programa.
2. Dentro de C:\programa descomprimes todos los archivos de programa.rar
3. Descarga
* swi prolog
* swi prolog editor
- Instala primero el swi prolog
- Luego dentro de setup.rar, que es el instalador del swi prolog editor, dale doble clic al archivo setup.exe
- Siguiente, siguiete y listo xD!
4. Abre el swi prolog editor y asegúrate de cerrar todos los archivos anteriormente trabajados haciendo clic en menú
Archivo y cerrar todo.
5. Abre el archivo proyectofinal.pl que está en C:\ llamado programa y luego en menú iniciar, dar clic a consultar.
6. En la parte inferior, en el editor de consultas escribe lo siguiente sin comillas: "main."
7. Listo, tenemos nuestro sistema experto ejecutándose.

Algoritmo de Anillo de Fichas (Token Ring) con Simulación en Java

2010-01-11T14:49:00.006-05:00

Los procesos están organizados formando una estructura de anillo, donde a cada proceso se le asigna una posición en la estructura, de tal modo que cada proceso conoce a sus vecinos.

Al inicializar el anillo se le da al proceso[0] el token, que circula en todo el
anillo. Dicha ficha circula del proceso[k] al proceso[k + 1]. Como es obvio, el token estará circulando por todos los procesos, ya que estos se encuentran referenciados mediante una suerte de lista circular.

Cuando un proceso obtiene la ficha de su vecino verifica si intenta entrar a una región crítica:

En caso positivo:
El proceso entra a la región crítica(Como se muestra en la zona marcada de rojo en la figura siguiente), hace el proceso necesario y sale de ella.
Después de salir pasa la ficha a lo largo del anillo:
No se puede entrar a una segunda región crítica con la misma ficha (token o permiso).

En caso negativo:
La vuelve a pasar.

En un instante dado solo un proceso puede estar en una región crítica. En la figura podemos ver que solo un proceso es de color verde, es decir que solo ese proceso tiene la ficha y solo él está en facultad de poder acceder a su región crítica.

Si la ficha se pierde debe ser regenerada, pero es difícil detectar su perdida:

La cantidad de tiempo entre las apariciones sucesivas de la ficha en la red no está determinada, por ello es difícil decidir si está la ficha se ha perdido por algún error en un proceso o si es que está aún retenida por un proceso que está haciendo un uso intensivo de recursos.

La falla de un proceso es detectada cuando su vecino intenta sin éxito pasarle la ficha:

Se lo debe eliminar del grupo y pasar la ficha al siguiente proceso activo.
Todos los procesos deben mantener la configuración actual del anillo.

Bueno, espero haber sido claro explicando este algoritmo. Y para cerrar el post aquí les dejo el link de descarga del proyecto de simulación realizado en Netbeans.

Capturando Fechas de un JDateChooser

2009-12-28T23:18:00.018-05:00

Entre los componentes que forman parte del paquete de JCalendar desarrollados por Kai Tödter encontramos uno que es muy útil llamado el JDateChooser. Por lo que he leído en distintas páginas en el internet, muchos tienen problemas para capturar las fechas seleccionadas.

Pues en este post vamos a aprender a capturar las fechas del JDateChooser así como darle el formato que uno desee. A lo largo de este post vamos a desarrollar la aplicación que muestro en la siguiente imagen:

En primer lugar para poder dar formato a un JDateChooser, este tiene un atributo el cuál podemos modificar de acuerdo a nuestras necesidades. La forma de cambiarlo es como se muestra en las siguientes imágenes:

Una vez seleccionado el atributo que queremos modificar, le ingresamos el formato que mejor se ajusta a nuestras necesidades, como se muestra en la siguiente imágen:

Pero aún haciendo esto, aún no se ha explicado la forma de capturar la fecha. Bueno, una forma de hacerlo es como muestro en el siguiente bloque de código:


try {
     String formato = comboFormato.getSelectedItem().toString();
     //Formato
     Date date = SelectorFecha.getDate();
     SimpleDateFormat sdf = new SimpleDateFormat(formato);
     txtFechaSeleccionada.setText(sdf.format(date));
} catch(NullPointerException ex) {
     JOptionPane.showMessageDialog(this, "Al menos selecciona una fecha válida!", "Error!", JOptionPane.INFORMATION_MESSAGE);
}

Con eso podremos obtener la fecha y colocarla en una etiqueta de texto o como parte de una cosulta SQL.

Para obtener el día, el mes o el año por separado podemos hacer lo siguiente:


int año = SelectorFecha.getCalendar().get(Calendar.YEAR);
int mes = SelectorFecha.getCalendar().get(Calendar.MONTH) + 1;
int dia = SelectorFecha.getCalendar().get(Calendar.DAY_OF_MONTH);
txtDía.setText("" + dia);
txtMes.setText("" + mes);
txtAño.setText("" + año);

Con eso bastará para poder obtener la fecha y darle el formato que se desee.

Aún así, si no nos gusta usar los componentes de JCalendar podemos escribir nuestro propio calendario. Yo hice uno, el cuál se puede apreciar en la imágen a continuación:

No es la gran cosa, pero con un poco más de tiempo se puede ir mejorando, hasta obtener resultados óptimos.

Bueno, para cerrar el post les dejo el link de descarga del proyecto que fué realizado en Netbeans IDE 6.8 usando jcalendar-1.3.3

Alumnos de Informática de la Universidad Nacional de Trujillo desarrollan un prototipo de los TALON Military Robots™

2009-12-16T09:13:00.016-05:00

Alumnos de la Universidad Nacional de Trujillo lograron desarrollar un primer prototipo, bastante elemental, de los conocidos Robots Talon de Foster Miller Inc.

Con motivo de la IV Semana de la Ciencia de la Computación, alumnos de la escuela de Informática de la Universidad Nacional de Trujillo lograron desarrollar un robot para la exploración de terrenos desconocidos mediante telecontrol. La plataforma sobre la que fué desarrollado el proyecto fué Java, gracias a sus altas capacidades de conectividad así como sus constructores de alto nivel que permitieron la transferencia de datos multimedia de una manera eficaz.

Para el control de los mecanismos, se escribieron programas para Microcontroladores PIC de Microchip, los cuales gracias a sus manera sencilla de adquirirlos así como las posibilidades de ajustarlos a proyectos tan diversos hicieron de estos los candidatos ideales para esta parte de la arquitectura general del proyecto.

Los recuadros rojos indican las disposiciones de las cámaras en el robot, el recuadro verde indica la ubicación de la placa de control, el recuadro azul es el Modem-Router encargado de la transmisión de datos, y en amarillo se muestra la pantalla del control de mando.

Comunicacion USB, Protocolos de tiempo real así como una diversidad de frameworks y mecanismos que nos provee Java fueron la base para estructurar este proyecto en su primera fase.

El Robot cuenta con cámaras, entre ellas una de alta resolución, un micrófono, una lámpara de leds, un haz láser y dispositivos de control de giro lo cuál le permite tener un conocimiento único del entorno que explora, puesto que la cámara que lleva en la parte superior tiene un giro de 360º sobre su eje z. Este giro está acompañado de una lámpara que le permitirá iluminar terrenos carentes de luz. En la parte delantera cuenta con un dispositivo acoplado a una cámara que tiene una capacidad de giro de 270º en horizontal y 60º en vertical. Todo esto añadido a la transmisión de audio nos permite tener un conocimiento del ambiente explorado casi tan bueno como si estuvieramos presentes ahí.

La imagen que se muestra a continuación es una muestra de lo que se visualiza en la estación de mando.

La transmisión de video en tiempo real de 4 orígenes o fuentes de manera concurrente fué uno de los principales problemas a solucionar. Otro fué el accionar de los mecanismos para lo cual se recurrio a la comunicación USB.

La transmisión de datos se basa en el estándar IEEE 802.11 y el control de los mecanismos del robot están bajo el protocolo USB. El robot lleva consigo una computadora portátil, la cuál en su primera fase se encarga de la emisión de los datos multimedia así como de la comunicación con la placa de control. En una siguiente fase está portátil realizará un tipo de procesamiento que prefiero aún no describir.

Como se recuerda, todo está programado en Java, usando Netbeans 6.7 IDE, pero por el uso de determinadas librerías con JNI no se puede hablar de portabilidad, pero sería interesante desarrollar este tipo de proyectos sobre alguna plataforma libre (Como GNU|Debian, mi favorita).

Para cerrar el post les comento que se está trabajando, a la fecha, en un segundo prototipo que se asemjará más a los Sword robots de Foster Miller Inc.

Procesamiento Digital de Audio. Graficador de Espectros de audio escrito en Java

2009-12-15T10:41:00.029-05:00

El procesamiento digital de señales es un área de la ingeniería que se dedica al análisis y procesamiento de señales (audio, voz, imágenes, video) que son discretas. Aunque comúnmente las señales en la naturaleza nos llegan en forma analógica, también existen casos en que estas son por su naturaleza digitales, por ejemplo, las edades de un grupo de personas, el estado de una válvula en el tiempo (abierta/cerrada), etc.

Se puede procesar una señal para obtener una disminución del nivel de ruido, para mejorar la presencia de determinados matices, como los graves o los agudos y se realiza combinando los valores de la señal para generar otros nuevos.[1]

El procesamiento digital de audio es un tipo de procesamiento digital de señales especializado en el tratamiento de la señal de audio.Una señal digital no es audible, ya que requiere ser decodificada antes de su reproducción.[2]

En este post vamos a hablar acerca de la graficación del espectro de audio de un archivo *.wav o *.aif. Pero antes de explicar cómo se realiza la graficación de audio en java, tenemos que tener en cuenta una serie de conceptos que nos ayudarán a comprender mejor la esencia de este proceso.

Primero voy a definir lo que a partir de ahora será Audio Digital.

AUDIO DIGITAL: Proceso de representar una señal de audio como un flujo de
datos numéricos para efectos de almacenamiento, procesamiento o
transmisión. De esta manera prácticamente se elimina la posibilidad de
ruidos o errores en la lectura.

Para poder graficar un archivo de audio lo primero que tenemos que hacer es acceder a los datos numéricos que representan al fichero de audio como una estructura digital. Para eso tendremos que leer el archivo como indico en el siguiente segmento de codigo:


int totalFramesLeidos = 0;
int totalBytesLeidos = 0;
try {
    AudioInputStream flujoEntradaAudio = AudioSystem.getAudioInputStream(fichero);
    int bytesPorFrame = flujoEntradaAudio.getFormat().getFrameSize();
    int numBytes = 1024 * bytesPorFrame;
    byte[] audioBytes = new byte[numBytes];
    // longitud de archivo de audio en bytes
    int longitudArchivoBytes=(int)flujoEntradaAudio.getFormat().getFrameSize()*(int)flujoEntradaAudio.getFrameLength();
    // objeto datos mas informacion ver clase Datos.java
    Datos datos = new Datos(longitudArchivoBytes,flujoEntradaAudio.getFormat().isBigEndian());
    byte[] datosTemporal=new byte[longitudArchivoBytes];
    int pos=0;
    /* el siguiente procedimiento lee los bytes del archivo de audio a memoria */
    try {
        int numeroBytesLeidos = 0;
        int numeroFramesLeidos = 0;
        while ((numeroBytesLeidos = flujoEntradaAudio.read(audioBytes)) != -1) {
            numeroFramesLeidos = numeroBytesLeidos / bytesPorFrame;
            totalFramesLeidos += numeroFramesLeidos;
            System.arraycopy(audioBytes, 0, datosTemporal, pos, numeroBytesLeidos);
            pos=pos+numeroBytesLeidos;
        }
        datos.llenarByte(datosTemporal);
        //datosVoz=new double[longitudArchivoBytes/bytesPorFrame];
        datosVoz = new ArrayList<Double>();
        datosVoz=datos.convertirByteADouble(longitudArchivoBytes/bytesPorFrame);
        frecuency.setMaximum((int) flujoEntradaAudio.getFrameLength()/100);
        int min = frecuency.getMinimum();
        int max = frecuency.getMaximum();
        frecuency.setValue((min+max)/2);
        ((PanelDeslizable)newContentPane).setIntervalo(frecuency.getValue());
        if(flujoEntradaAudio.getFormat().isBigEndian()) {
            System.out.println("BigEndian");
        } else {
            System.out.println("LittleEndian");
        }
        INFORMACION = flujoEntradaAudio.getFormat().toString();
        //obtiene la frecuencia de sampleo
        FRECUENCIA=(int)flujoEntradaAudio.getFormat().getSampleRate();
        ((PanelDeslizable)newContentPane).setDatos(datosVoz);
        ((PanelDeslizable)newContentPane).repaint();
    } catch (Exception ex) {
    }
}catch(Exception e) {
}

Bueno, en el segmento de código anterior, lo primero que se hace es leer el archivo de audio, luego ir leyendo por frames para poder tener la data en un vector el cual será luego procesado de acuerdo a lo que se quiera obtener.Con eso será suficiente para poder acceder al vector de datos numéricos o sample (Cada uno de los valores que se obtienen del proceso de sampleo. Cada una está cuantizada en una cantidad determinada de bits) que representan un archivo de audio.

Se observa también la presencia de una clase, la clase Datos la cuál se encarga de realizar las conversiones respectivas del tipo de datos puesto que un archivo wav es un archivo binario y nosotros procesaremos la data con un tipo de dato más adecuado (Double por ejemplo).

El código que muestro a continuación pertenece a esta clase Datos:


package com.blogspot.rolandopalermo.util;

import java.util.ArrayList;
import java.util.List;

public class Datos {

    byte[] bits ;
    boolean formato;  // para el formato bigEndian y littleEndian
    double mayor, menor;

    public  Datos(int tamano, boolean formato) {
        bits = new byte[tamano];
        this.formato = formato;
        mayor = 0;
        menor = 0;
    }

    public void llenarByte(byte[] bits) {
        this.bits = bits;
    }

    /* ejemplo bits[2]=2 (00000010) bits[3]=3 (00000011)
     se aplica bits[2]<<8 o sea 10 00000000 , luego 11111111(0x000000FF) & bits[3]|bits[2]
     en total da 10 00000011  que es el numero 515 , este es un short de 16 bits , han entrado
     dos bytes en uno (short[i]=contacenar byte[i]+byte[i+1])
     los valores negativos estan en complemento a 2
     */

    public List<Double> convertirByteADouble(int size) {
        List<Double> arrayDouble = new ArrayList<Double>();
        //double[] arrayDouble = new double[bits.length/2];
        if (formato==true) {
            int temp = 0x00000000;
            for (int i = 0, j = 0; j < size ; j++, temp = 0x00000000) {
                temp=(int)bits[i++]<<8;//System.out.println("temp = "+ temp);
                temp |= (int) (0x000000FF & bits[i++]);
                //arrayDouble[j]=(double)temp;
                arrayDouble.add(j, (double)temp);
            }
            return arrayDouble;
        }
        if(formato==false) {  // si el formato es littleEndian
            int temp = 0x00000000;
            for (int i = 0, j = 0; j < size ; j++, temp = 0x00000000) {
                temp=(int)bits[i+1]<<8;//System.out.println("temp = "+ temp);
                temp |= (int) (0x000000FF & bits[(i)]);
                i=i+2;
                arrayDouble.add(j, (double)temp);
                //calcular mayor y menor esto me servira para establecer
                //los parametros en el eje y para la grafica
                if(mayor<arrayDouble.get(j)) {
                    mayor=arrayDouble.get(j);
                }
                if(menor>arrayDouble.get(j)) {
                    menor=arrayDouble.get(j);
                }
            }
            return arrayDouble;
        } else {
            System.out.println("Orden de Bytes desconocido o no soportado");
        }
        return arrayDouble;
    }
}

La forma de graficarlos dependerá de las necesidades que se tenga así como de otros factores como por ejemplo:

FRECUENCIA DE SAMPLEO O MUESTREO: Velocidad, en Hertz, a la cual se extraen las muestras de una señal de audio. Tiene directa relación con el ancho de banda que se obtendrá. Mientras mayor sea la Frecuencia de sampleo, mejor es la respuesta de agudos.

CUANTIZACIÓN: Es el proceso de asignar a una escala "redondeando al peldaño más cercano" el valor de cada muestra. Esta cantidad está determinada por el número de bits utilizados. La cuantización tiene directa relación con el rango dinámico (nivel de ruido) de la señal.

Evidentemente todos estos valores tienen que estar presentes como parámetros al momento de graficar el espectrograma que representará al archivo de audio. Yo recomiendo sean atributos de la clase encargada de mostrar los datos en modo gráfico. En el caso del proyecto que realizé, esta clase tiene el valor de PanelDeslizable (Deslizable puesto que si el gráfico es más grande que la pantalla entonces automáticamente aparecerá un scroll que nos permitirá ubicarnos en la posición que deseemos). El código de esta clase la muestro a continuación:


package com.blogspot.rolandopalermo.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.List;
import javax.imageio.ImageIO;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.Timer;

//@author Rolando

public class PanelDeslizable extends JPanel {

    private Dimension area; //indicates area taken up by graphics
    //private Vector<Rectangle> circles; //coordinates used to draw graphics
    private JPanel drawingPane;
    private Timer reloj;
    private List<Double> datos;
    private int w;
    private int h;
    private static int x0 = 15;
    private int y0;
    private int intervalo;
    private int temporizador;
    private int fin;
    private double  escalaX;
    private double escalaY;
    private Color gridcolor;
    private Color ejescolor;
    private Color texto;
    private Color espectrogramac;
    private Color background;
    private Color player;
    private boolean dibujargrid;
    private boolean dibujarejes;
    private boolean dibujarespectrograma;
    private String informacion;

    public PanelDeslizable(final int w, final int h) {
        super(new BorderLayout());

        background = Color.BLACK;
        gridcolor = new Color(120, 176, 145);
        ejescolor = Color.YELLOW;
        texto = Color.YELLOW;
        player = Color.RED;
        //espectrogramac = new Color(85, 255, 255);
        espectrogramac = Color.GREEN;
        
        area = new Dimension(0,0);

        //Set up the drawing area.
        drawingPane = new DrawingPane();
        drawingPane.setBackground(background);
        //drawingPane.addMouseListener(this);

        //Put the drawing area in a scroll pane.
        JScrollPane scroller = new JScrollPane(drawingPane);
        scroller.setPreferredSize(new Dimension(200,200));

        add(scroller, BorderLayout.CENTER);

        datos = null;

        this.w  = w;
        this.h  = h;
        this.y0 = h/2;

        intervalo = 1;

        temporizador = 0;
        fin = 0;

        escalaX = 1;
        escalaY = 1;

        dibujargrid = true;
        dibujarejes = true;
        dibujarespectrograma = false;

        informacion = null;

        reloj = new Timer (1, new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                temporizador = temporizador + 1;
            }
        });

    }

    /** The component inside the scroll pane. */
    class DrawingPane extends JPanel {
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            w  = getSize().width;
            h  = getSize().height;
            y0 = h/2;
            if(dibujargrid) {
                graficarGrid(g);
            }
            if(dibujarejes) {
                graficarEjes(g);
            }
            if(dibujarespectrograma) {
                graficarEscpectrograma(g);
            }
            if(informacion!=null) {
                g.setColor(texto);
                g.drawString(informacion, 20, 20);
            }
        }
    }

    public void graficarGrid(Graphics g) {
        g.setColor(gridcolor);
        for( int i=0; i < w; i+=15) {
            for(int j=0; j<h; j+=40) {
                g.drawLine(i,j,i,h);
                g.drawLine(i,j,w,j);
            }
        }
    }

    public void graficarEjes(Graphics g) {
        g.setColor(ejescolor);
        linea(0,0,w,0,g);
        linea(0,y0,0,-y0,g);
    }

    public void graficarEscpectrograma(Graphics g) {
        g.setColor(espectrogramac);
        int length = datos.size();
        int[] puntoP = new int[2];
        int i, xi=0,xf=0,yi=0,yf=0;
        for(i=0; i<length-intervalo; i+=intervalo) {
            puntoP[0]=(int) (i * escalaX);
            puntoP[1]=(int) (datos.get(i) * escalaY);
            xi = puntoP[0];
            yi = puntoP[1];
            puntoP[0]=(int) ((i + intervalo) * escalaX);
            puntoP[1] = (int) (datos.get(i+intervalo) * escalaY);
            xf = puntoP[0];
            yf = puntoP[1];
            linea(xi, yi, xf, yf, g);
        }
        fin = xf;
        if(xf>w) {
            area.width = xf+100;
            drawingPane.setPreferredSize(area);
            drawingPane.revalidate();
        }
    }
  
    public void iniciarReproduccion() {
        //setTocar(true);
        temporizador = 0;
        reloj.start();
    }

    public void detenerReproduccion() {
        reloj.stop();
    }

    public void reiniciarReproduccion() {
        temporizador = 0;
        reloj.stop();
    }

    public void save(File fichero) {
        BufferedImage imagen = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
        Graphics g = imagen.getGraphics();
        drawingPane.paint(g);
        // Escribimos la imagen en el archivo.
        try {
            ImageIO.write(imagen, "jpg", fichero);
        } catch (IOException e) {
            System.out.println("Error de escritura");
        }
    }

    public void ajustarDimension() {
        area.width=0;
        drawingPane.setPreferredSize(area);
        drawingPane.revalidate();
    }

    public void setDibujargrid(boolean dibujargrid) {
        this.dibujargrid = dibujargrid;
    }

    public void setGridcolor(Color gridcolor) {
        this.gridcolor = gridcolor;
    }

    /**
    *  Dibuja una linea desde (x1,y1) hasta (x2,y2).
    *  @param x1 Coordenada x del punto de origen.
    *  @param y1 Coordenada y del punto de origen.
    *  @param x2 Coordenada x del punto de destino.
    *  @param y2 Coordenada y del punto de destino.
    */
    public void linea(double x1, double y1, double x2, double y2, Graphics g) {
        g.drawLine((int)Math.round(x1+x0),
                (int)Math.round(y0-y1),
                (int)Math.round(x2+x0),
                (int)Math.round(y0-y2));
    }

    public void setInformacion(String informacion) {
        this.informacion = informacion;
    }

    public void setDibujarejes(boolean dibujarejes) {
        this.dibujarejes = dibujarejes;
    }

    public void setDibujarespectrograma(boolean dibujarespectrograma) {
        this.dibujarespectrograma = dibujarespectrograma;
    }

    public void setDatos(List<Double> datos) {
        this.datos = datos;
    }

    public void setIntervalo(int intervalo) {
        this.intervalo = intervalo;
    }

    public void setEscalaY(double escalaY) {
        this.escalaY = escalaY;
    }

    public void setEscalaX(double escalaX) {
        this.escalaX = escalaX;
    }
}

Los archivos que se pueden procesar de esta forma pueden tener el formato WAV o AIF como se había mencionado anteriormente.

Acá les dejo algunos screenshots de la aplicación que he escrito en java para graficar espectros de audio:

En la imágen que muestro a continuación se aprecia el árbol de clases del proyecto el cuál fué realizado en netbeans:

A continuación dejo el código fuente para que lo puedan leer y si es posible continuar con el trabajo puesto que hay muchas cosas por mejorar.

Y aquí algunos ejemplos para que puedan probar el programa

Pueden también visitar el blog un gran amigo, Jorge Valverde, quien es un destacado investigador. Ahí podrán encontrar una explicación un poco más detallada de este proceso.

Algoritmo de Lamport para la Sincronización de Relojes Lógicos en Sistemas Distribuidos. Simulación en Java

2009-12-07T23:53:00.002-05:00

La sincronización en sistemas distribuidos consiste en garantizar que los procesos se ejecuten en forma cronológica y a la misma vez respetar el orden de los eventos dentro del sistema. En el caso de sistemas de una sola CPU, este problema se resuelve usando semáforos, pero en sistemas de múltiples CPUs la solución ya implica el uso de otros métodos o algoritmos, para garantizar no solo la comunicación entre procesos sino también la forma como estos cooperan entre sí.

Esta sincronización, en sistemas distribuidos, se hace más compleja que en los sistemas centralizados puesto que la información y el procesamiento se mantienen en diferentes nodos.

La sincronización de relojes en sistemas distribuidos nos permite garantizar que los procesos se ejecutan cronológicamente y además respetar el orden de los eventos dentro del sistema.

Las computadoras poseen un circuito para el registro del tiempo conocido como dispositivo reloj. Es un cronómetro consistente en un cristal de cuarzo de precisión sometido a una tensión eléctrica.

Para una computadora y un reloj no interesan pequeños desfasajes del reloj porque:

Todos los procesos de la máquina usan el mismo reloj y tendrán consistencia interna.
Importan los tiempos relativos.

Para varias computadoras con sus respectivos relojes:

Es imposible garantizar que los cristales de computadoras distintas oscilen con la misma frecuencia.
Habrá una pérdida de sincronía en los relojes (de software), es decir que tendrán valores distintos al ser leidos.

La diferencia entre los valores del tiempo se llama distorsión del reloj y podría generar fallas en los programas dependientes del tiempo.

Luego de esta pequeña introducción a la sincronización vamos a hablar acerca del Algoritmo de Lamport. Y es que en este post hablaremos de la propuesta que hizo el científico en computación Dr Leslie Lamport.

Lamport señaló que la sincronización de relojes no tiene que ser absoluta.
Si 2 procesos no interactúan no es necesario que sus relojes estén sincronizados.
Generalmente lo importante no es que los procesos estén de acuerdo en la hora, pero sí importa que coincidan en el orden en que ocurren los eventos.

Y es aquí dónde aparece el concepto de reloj lógico. Un reloj lógico de Lamport es un contador software que se incrementa monótonamente, cuyos valores no necesitan tener ninguna relación particular con ningún reloj físico.

Para sincronizar los relojes lógicos, Lamport definió la relación ocurre antes de(happens-before):

Si “a” y “b” son eventos en el mismo proceso y “a” ocurre antes de “b”, entonces “a –> b” es verdadero.
“Ocurre antes de” es una relación transitiva:
Si “a –> b” y “b –> c”, entonces “a –> c”.
Si dos eventos “x” e “y” están en procesos diferentes que no intercambian mensajes, entonces “x –> y” no es verdadero, pero tampoco lo es “y –> x”:
Se dice que son eventos concurrentes.

Necesitamos una forma de medir el tiempo tal que a cada evento “a”, le podamos asociar un valor del tiempo “C(a)” en el que todos los procesos estén de acuerdo:

Se debe cumplir que:
o Si “a –> b” entonces “C(a) < C(b)”.
o El tiempo del reloj, “C”, siempre debe ir hacia adelante (creciente), y nunca hacia atrás (decreciente).

El algoritmo de Lamport asigna tiempos a los eventos.

Una vez descrito el algoritmo, pasaré a mostrar su implementación en java. La primera imágen corresponde a una simulación similar a la mostrada en la imágen anterior y que puede ayudarnos a comprender mejor el funcionamiento de este algoritmo.

En la imágen siguiente, vemos que al querer enviar un mensaje del proceso 3 en un instante de tiempo 4 al proceso 2 en un instante de tiempo 3, el algoritmo exige la sincronización de los relojes logicos de los CPUs donde se encuentran los procesos anteriormente numerados. Basta dar clic en el botón sincronizar para ver los cambios en los vectores de tiempo de ambos procesos, mientras que el resto de procesos no sufren alteración alguna, tal y como lo describe el algoritmo de Lamport.

Espero que la explicación y esta simulación(que puedes descargar aquí) te sean de utilidad. Muy pronto postearé acerca de otros algoritmos en sistemas distribuidos con sus respectivas simulaciones.

Como configurar Flex en Windows y no morir en el intento

2009-12-03T22:53:00.010-05:00

¿A cuántos de nosotros, durante nuestras carreras en la Universidad, nos han pedido como proyecto hacer un analizador léxico, hacer un compilador o cosas afines?, ¿A cuántos de nosotros se nos pasó el tiempo, y sobre la hora queremos desarrollar estos proyectos desde cero? ¿A cuántos de nosotros nos fascinaría estructurar nuestro propio lenguaje o quizás desarrollar nuestro propio compilador? ... Pues en este post les presentó la herramienta básica de quien se aventura (y también para quién solo está de pasada) en este maravilloso mundo de los compiladores y otros programas que no son exactamente compiladores, pero que presentan algunas características de estos como los coloreadores de código.
Flex es una herramienta para generar escáneres, es decir programas que reconocen patrones léxicos en un texto. En otras palabras, flex se encarga de convertir esos patrones léxicos en tokens que pueden servir para estructurar una gramática (en el caso de un compilador) o para colorear código (En caso de un coloreador de código).
A continuación mostraré un ejemplo de script para flex:

%{
#include <stdio.h>
#include <conio.h>
int num_lineas = 0, num_caracteres = 0;
%}
%option noyywrap
%option yylineno
letra [a-zA-Z]
digito [0-9]
binario [0-1]
ignora " "|\t|\n
operarit *|+|-|/
operlog &|$
comparador <|>|<=|>=|==|!=
%%
{ignora}+                   {;}
{letra}({letra}|{digito})*  {printf("IDENTIFICADOR\n");}
{letra}+                    {printf("CADENA\n");}
{binario}+                  {printf("BOOLEANO\n");} 
{digito}+                   {printf("ENTERO\n");}
{digito}+"."{digito}+       {printf("REAL\n");}
{comparador}                {printf("COMPARADOR\n");}
":="                        {printf("ASIGNADOR\n");}
";"                         {printf("PUNTO_COMA\n");}
"!="                        {printf("DIFERENCIA\n");}
","                         {printf("COMA\n");}
"=="                        {printf("IGUAL\n");}
"."                         {printf("PUNTO\n");}
">="                     {printf("MAYOR_IGUAL\n");}
"<="                     {printf("MENOR_IGUAL\n");}
"("                         {printf("OPEN_PARENTESIS\n");}
")"                         {printf("CLOSE_PARENTESIS\n");}
">"                      {printf("MAYOR\n");}
"<"                      {printf("MENOR\n");}
"{"                         {printf("OPEN_LLAVE\n");}
"}"                         {printf("CLOASE_LLAVE\n");}
"+"                         {printf("SUMA\n");}
"-"                         {printf("RESTA\n");}
"*"                         {printf("MUTIPLICACION\n");}
"/"                         {printf("DIVISION\n");}
"&"                         {printf("AND\n");}
"$"                         {printf("OR\n");}
\n                          ++num_lineas;
.                           {printf("ERROR LEXICO EN LINEA %d \n",yylineno);}
%%
int main(int argc,char *argv[])
{
char NomArch[30];
printf("Ingrese nombre de archivo: ");
gets(NomArch);
if ((yyin = fopen(NomArch, "rt")) == NULL)
{
printf("\nNo se puede abrir el archivo: %s\n", NomArch);
}
else
{
yylex();
}
fclose(yyin);
getch();
return 0;
}

Ahora bien, este script debemos enviarlo al Flex para que nos retorne un archivo en lenguaje C el cuál podemos integrar a nuestro proyecto que estamos realizando, de manera sencilla.

Lo primero que debemos hacer es descargar el archivo djgpp.rar, crear una carpeta llamada DJGPP en la unidad D:\ y descomprimir todos los archivos del *.rar aquí.

Luego debemos crear una carpeta en la unidad D:\ llamada PRUEBAS. Con esto será suficiente, pero es bueno recordar que las rutas son relativas. Eso sí, al momento de configurar las variables de entorno debemos tener cuidado de la ubicación de ambas carpetas.

Bueno, el siguiente paso es configurar el Flex para lo cuál haremos lo siguiente:
1. Presionar window+r y escribir cmd. Se abrirá la consola del windows, ahí debemos escribir lo siguiente:

d:
cd PRUEBAS
set djgpp=d:\djgpp\djgpp.env
set path=d:\djgpp\bin
flex -oanalisis.c FLE.L

Con esto se generará un archivo llamado analisis.c el cuál podemos integrarlo a nuesto proyecto en C. En este caso el archivo tiene su función main por lo que puede trabajar por si solo. Al ejecutar y enviarle un archivo con patrones léxicos veremos que nos devolverá los tokens correspondientes.

Acá les dejo un proyecto en Dev-C++, en la carpeta hay un archivo llamado test.txt el cuál es la entrada al programa.

Espero les sea de utilidad, y en un siguiente post explicaré como utilizar el Bison para analizar sintácticamente estructuraras más complejas como son las gramáticas.

Pueden revisar este post que explica cómo usar Bison en Windows:
http://rolandopalermo.blogspot.com/2010/01/configurando-bison-en-windows-para.html
O para algo más aplicativo puedes revisar esto:
http://rolandopalermo.blogspot.com/2010/10/lex-y-bison-en-un-solo-analizador.html

Skadedjur, un sistema experto, escrito en prolog, para la detección y control de plagas en sembríos de Tara

2009-12-02T10:32:00.001-05:00

Los Sistemas Expertos (SSEE), uno de los campos en que se divide la Inteligencia Artificial, han levantado un gran interés en los últimos cinco años entre los expertos de diversas áreas no relacionadas con la computación, como por ejemplo el sector agroindustrial. Las posibilidades de utilización de los SSEE en control agroindustrial, son amplias y esperanzadoras. Van desde la identificación de plagas que atacan un sembrío hasta la obtención de recomendaciones para el control de las mismas.

SKADEDJUR es un sistema experto diseñado con el fin de proporcionar consejos a los agricultores sobre las diferentes plagas que atacan a los cultivos de Tara. Las tareas implicadas en el cultivo de la Tara, que acotan el contexto de SKADEDJUR son:

El diagnóstico de plagas y su tratamiento.
El diagnóstico de plagas se realiza a partir de los síntomas observados.

En función de la plaga diagnosticada y de su grado de levedad, se dictamina un plan de tratamiento para la planta infectada. Un plan de tratamiento debe especificar un conjunto de recursos necesarios, un método de aplicación, un tiempo de aplicación y otros consejos adicionales. En principio pensamos modelar los “recursos necesarios” “métodos y tiempos de aplicación” “consejos adicionales” como conceptos diferenciados del “plan de tratamiento” porque se les supone una cierta complejidad, aunque al profundizar en las descripciones que manejamos decidimos modelarlos como atributos del concepto “plan de tratamiento”.

Evidentemente para poder llegar a un diagnóstico desde los síntomas, se asume la existencia de una relación causa-efecto, formando una estructura más o menos compleja, pero que permitiría por recubrimiento llegar a las causas/diagnóstico de los efectos/síntomas de entrada.

El código fuente del sistema experto ha sido escrito en prolog usando el entorno de SWI Prolog. Presenta una interfaz gráfica sencilla, la cuál fué estructurada gracias a las librerías XPCE que el entorno antes mencionado trae consigo.

El Manual de usuario lo puedes descargar aquí.
El Informe del proyecto lo puedes descargar aquí.
El Artículo referente al proyecto lo puedes descargar aquí.
El código fuente lo puedes descargar aquí.

Recuerden que dentro de la carpeta programa hay un archivo léeme!!!!.txt es cuál es muy importante que lo lean, o en todo caso lean estos tips para poder ejecutar el sistema experto y generar su respectivo ejecutable:

1. Primero debes crear una carpeta en tu unidad C:\ llamado programa.
2. Dentro de C:\programa descomprimes todos los archivos de programa.rar
3. Descarga
* swi prolog
* swi prolog editor
- Instala primero el swi prolog
- Luego dentro de setup.rar, que es el instalador del swi prolog editor, dale doble clic al archivo setup.exe
- Siguiente, siguiete y listo xD!
4. Abre el swi prolog editor y asegúrate de cerrar todos los archivos anteriormente trabajados haciendo clic en menú
Archivo y cerrar todo.
5. Abre el archivo proyectofinal.pl que está en C:\ llamado programa y luego en menú iniciar, dar clic a consultar.
6. En la parte inferior, en el editor de consultas escribe lo siguiente sin comillas: "main."
7. Listo, tenemos nuestro sistema experto ejecutándose.

JInti, una simulación de sistema operativo en java

2009-12-01T23:37:00.001-05:00

En este post quiero hablar de Sistemas Operativos, un área de interés para la comunidad informática puesto que es la base de todo lo que, sobre ella, se puede estructurar, desarrollar, implementar, programar o como se quiera decir al hecho de realizar una aplicación informática.

Durante el curso de Sistemas Operativos I que se imparte en mi escuela, se desarrolla una serie de algoritmos en sistemas operativos centralizados. Estos algoritmos están orientados a la gestión de procesos; como puede mecanismos de sincronización, priorización de procesos entre muchas otras cosas.

Y es justo la priorización de procesos uno de los temas bases y que se merecen un gran estudio puesto que de los algoritmos que seleccionemos para este hecho dependará en gran medida el rendimiento del sistema operativo que se esté implementando.

Para la gestión de procesos existen muchos algoritmos. La siguiente lista es una muestra de ello:
1. Planificación a Plazo Fijo
2. Planificación Garantizada
3. Planificación del Primero en Entrar Primero en Salir (FIFO)
4. Planificación de Asignación en Rueda (RR: Round Robin)
5. Tamaño del Cuanto o Quantum
6. Planificación del Trabajo Más Corto Primero (SJF)
7. Planificación del Tiempo Restante Más Corto (SRT)
8. Planificación el Siguiente con Relación de Respuesta Máxima (HRN)
9. Planificación por Prioridad
10. Colas de Retroalimentación de Niveles Múltiples
11. Política Versus Mecanismo de Planificación
12. Planificación de Dos Niveles

Ahora otro concepto importante es la paginación de memoria, que consiste en dividir los programas en páginas(pequeños segmentos de programa). Así mismo la memoria es dividida en trozos del mismo tamaño que las páginas llamados marcos de página. De esta forma, la cantidad de memoria desperdiciada por un proceso es el final de su última página, lo que minimiza la fragmentación interna y evita la externa.

Una vez defenidos estos conceptos básicos, paso a explicar lo que es JInti.

JInti es una simulación de sistema operativo que, basado en el algoritmo FIFO (First In, First Out "primero en entrar, primero en salir") para la gestión de procesos y en el algoritmo LRU ("Menos usada recientemente" o "Least Recently Used") para la determinación de qué páginas pueden ser sacadas de memoria cuando se necesita cargar una nueva y ya no hay espacio, muestra el funcionamiento de los mencionados algoritmos con procesos semi-reales cargados por el usuario en tiempo de ejecución y de manera concurrente. No es una una simulación completa, por lo que he decido liberar el código de JInti y volverlo OpenSource para que de ese modo alguién más pueda trabajar sobre esto e ir incrementando las capacidades de este simulador. A continuación muestro un screenshot de JInti:

La descarga la puedes realizar aquí, es un proyecto que ha sido realizado usando Netbeans, solo tienes que correr el proyecto y darle clic en los iconos de las aplicaciones que ahí aparecen. Para ver el administrador de procesos solo debes presionar F1 y verás como van cambiado los procesos que acceden al procesador y cómo se va realizando la paginación de los mismos.

Semana de la Ciencia de la Computación

2009-11-22T22:43:00.000-05:00

Y bueno, un poco tarde pero comentando sobre la SECICOMP. Para los que no saben, SECICOMP es Semana de la Ciencia de la Computación y se realiza anualmente en mi escuela, La Escuela de Informática.

Este año se realizó por cuarta vez y bueno, no fué la excepción para que presente algún proyecto (A excepción de la SECICOMP 2007).
A diferencia de otros años, la exposición de los trabajos se realizó frente al pabellón de la facultad de derecho con la finalidad de promocionar un poco más lo que se puede hacer en nuestra escuela.

La diversidad de proyectos y las áreas temáticas que estos expusieron dejó entrever la capacidad de los estudiantes de Informática, abordando temas desde puntos de vista tanto ingenieríl como científico, y algunos casos mezclando las capacidades de ambas perspectivas. Si bien es cierto no se logró la afluencia de público que se esperaba, la calidad del trabajo de mis compañeros organizadores y despliegue que este tuvo fué unos de los mejores que se ha visto.

Con ansias espero la SECICOMP 2010, aunque evidentemente ya no podré participar como estudiante y quizás ya no presente ningún proyecto de esos que parecen que van a estallar o que se desarmarán al primer movimiento, pero si espero poder apoyar en la organización, cosa que no hice en las versiones anteriores de la SECICOMP por cuestiones personales.

A través de este post dejo abierta la invitación a la gente que quiera participar en la SECICOMP 2010, para que vayan pensando algún proyecto y ¿por qué no? a los chicos que gustan de hacer cosas como las que solía hacer, para poder trabajar en conjunto o quizás brindándoles algunas ideas.

Cierro este post felicitando a la comisión organizadora de la IV SECICOMP y esperando con ansias la V SECICOMP.

Ciencia de la Computación

2009-11-19T16:19:00.001-05:00

Por ser este mi primer post quiero hablar de mi escuela, La Escuela de Informática de la Universidad Nacional de Trujillo. Y le dedico el post porque ocurre algo curioso, y es que cuando aún era un estudiante del 5 de secundaria del colegio San Juan estaba en el dilema de miles de jovenes peruanos: "¿Qué estudiar en la universidad?". Lógicamente la tecnología era lo que más me llamaba la atención y habían tres opciones: Ingeniería de Sistemas, Ingeniería Informática o Ingeniería Electrónica.

Ya cuando llegó el momento de la decisión la opción fué obviamente Ingeniería Informática en la UNT por supuesto. Al ingresar me di con la sorpresa que no era Ingeniería Informática lo que iba a estudiar, ni siquiera Informática, sino más bien Ciencia de la Computación. ¿Ciencia de la Computación? ... jamás había escuchado de eso, o sea estaba estudiando algo que no sabia que era. Lógicamente mi primera reacción fué informarme más pero la gente de ciclos superiores estaba tan confundida como yo. Luego un grupo de compañeros entro al salón de clases y nos habló de la ACM y de la Ciencia de la Computación. No me pareció mala opción y con tanta diapositiva terminé tranquilizándome y aceptando lo que estudiaría.

Bueno, los ciclos transcurrían y las ideas empezaban a aclararse, cursos por acá, cursos por allá, papers por acá, artículos por allá ... vaya que si empezaba a confundira la situación nuevamente. Y por si fuera poco hasta los mismos docentes se contradecían y se siguen contradiciendo. Cada profesor tiraba para su lado (o "área de investigación" como ellos suelen llamar) y nosotros cada vez más confundidos. Luego se empezó a organizar ferias dentro la escuela y, fiel a mi estilo, me animé a participar. Curiosamente en una de estas ferias llegó una "eminencia" de la Ciencia de la Computación y en una de sus charlas dijo ser Ingeniero de Sistemas pero que se ¡arrepentía! de serlo. Al escuchar esto me sentí avergonzado por los compañeros de ingeniería de sistemas que, estando presentes, no tuvieron el respeto que se merecen, más aún si están colaborando con nuestra feria. sobre todo por parte de este tipo ("científico") que siguió hablando y hablando de la "ciencia de la computación".

Con un montón de experiencias de este tipo ha transcurrido casi toda mi carrera, con compañeros que dicen hacer ciencia y criticando, destructivamente, a quien no siga su línea. Lo curioso de todo esto es que acabando sus tristes carreras no hacen nada de investigación y terminan siendo parte de la masa que tanto criticaban.

Es realmente lamentable todo lo que ocurre en mi escuela, cada vez peor. Quizás haya gente a quien no le guste lo que escribo pero, es la verdad. A este paso no se sabe a donde llegaremos con "investigadores" que solo saben criticar y que no hacen nada concreto por mejorar esta situación, puesto que su pensamiento tan cerrado, y hasta cierto punto tonto, ha sido transmitido a algunos compañeros que dicen hacer ciencia. Si ven un sistema informático dicen que es Ingeniería de Sistemas, si ven un circuito integrado dicen que es electrónica, si ven un motor dicen que es mecánica, para ellos ciencia de la computación es un paper o un algoritmo con entradas predefinidas, para ellos solo existen los paper y sus "complejos algoritmos". Es una pena que gente de este tipo siga contaminando nuestra escuela y siga fomentando sus ideologías a las futuras promociones. Es claro que acabando la universidad gente que se vió arrastrada por estos "personajes" tienen que seguir cursos técnicos puesto que no han recibido la correcta formación como científicos, salvo rescatables excepciones.

A todo esto, yo creo deberíamos empezar por cambiar el nombre de nuestra carrera y la currícula, que a pesar de ya haberse hecho los cambios en esta, está peor que antes, es una ofensa a la "Ciencia de la Computación" y a los alumnos que se basarán en ella.

Como primer post ya fue suficiente. Ya comenté mis ideas y siempre diré que yo estudio Ingeniería Informática.