Presentación proyecto final de POO

Breve demostración de lo que trata mi proyecto de POO.

Presentación POO

View more presentations from colli03.

Códigos G en arduino

Este post trata de como cargar códigos g en arduino, para poder controlar una máquina cnc de tres ejes.

Los links que se muestran en el video son:

http://arduino.cc/playground/Linux/Ubuntu
Todo el software necesario para instalar arduino en nuestra computadora

http://www.contraptor.org/motion-control
El script de python que nos permite mandar códigos g al arduino

http://reprap.org/wiki/Arduino_GCode_Interpreter#Implementation
Una lista de los códigos g que soporta el arduino.

Algunos comandos que pueden no verse bien en la pantalla.
mv *.deb arduinoFiles/
sudo dpkg -i *.deb


Los archivo se llaman:
nc2serial.py (es el que copiamos de la página de contraptor).
prueba.nc (el nombre de este no importa mucho).
Los dos archivos se guardan en la carpeta cnc que creamos en Desktop

Video...




Nota: El arduino Duemilanove y uno, no llaman igual al puerto serial (usb)
El arduino Duemilanove tiene nombres como /dev/ttyS0
El arduino uno tiene nombres como /dev/ACM

De tal manera que tienes que cambiar el nombre del puerto de comunicación en el archivo nc2serial.py al nombre del puerto que tengas en tu arduino.

Una imagen de que es lo que tienes que modificar...

Bueno por ahora eso es todo, disculpen la tardanza en poner el post.
Cualquier comentario es bien recibido.

Patrones de diseño (clase)

Los patrones de diseño en programación ayudan a resolver problemas que se presentan muy a menudo en el desarrollo de un programa. Podemos referirnos a los patrones de diseño en base a :
1.- Nombre: usado para describir el patrón.
2.- Synopsis: nos da una breve descripción sobre los  problemas a los que se puede aplicar el  patrón.
3.- Solución: breve descripción de la solución.
Existen varios tipos de patrones de diseño, pero yo les voy  a mostrar unos cuantos que me parecieron muy importantes.

Adapter
Este patron se usa cuando se tienen dos objetos los cuales queremos que interactuen, pero ambos tienen interfaces distintas el uno al otro. Uno de nuestros objetos puede ser el cliente (quien recibe servicios) y el otro el servidor (quien presta servicios). Como tenemos metodos que pertenecen a la interfaz del cliente los cuales no son los mismos que los metodos que pertenecen a la interfaz del servidor y en nuestro programa queremos conservar ambas interfaces, necesitamos una manera de comunicar el servidor con el cliente. Esto se realiza por medio de un adaptador el cual permite que los metodos del objeto cliente puedan ser entendidos por el objeto servidor y la tarea que se le encargo a este ultimo se lleve a cabo.
La siguiente imagen sirve para ilustrar la manera en que se aplica este patron de diseño.


Iterator
Se usa cuando tenemos un objeto que contiene una colección de datos de un cliente, los cuales son guardados en estructuras de datos (arboles, listas enlazadas, vectores, etc) y el cliente quiere acceder a ellos sin preocuparse sobre como son guardados los datos. Por lo cual tenemos que proveer una interfaz que permita acceder a los datos de una manera amigable.
Imaginemos que el cliente quiere realizar un ciclo sobre los datos, como le hemos proveido una interfaz el cliente realiza un ciclo usando los componentes de la interfaz la cual a su vez realiza el trabajo de pasar los datos. De esa manera facilitamos la manipulación de los datos.

Composite
Trata con el problema de la creación de objetos complejos a partir de objetos mas simples, lo cual se soluciona usando una colección de elementos simples pero que puedan ser unidos entre ellos de varias maneras.
Un ejemplo muy conocido son las ventanas graficas de los programas, las cuales basicamente estan formadas por contenedores y componentes y agrupados de tal manera que se forma la ventana que se desea.


Flyweight
Cuando se tienen muchos objetos que tienen la misma información, se puede ahorrar espacio en memoria creando una clase que se encargue de manejar la información que es común a varios objetos y haciendo que esos objetos obtengan su información la un objeto de la clase anterior.


Model View Controller (MVC)
Es una manera de descomponer una aplicación en tres partes: el modelo, la visualización y el controlador. originalmente diseñado para la aplicación de una GUI. Se comporta de la siguiente forma.
Entrada --> Procesamiento --> Salida
Controlador --> Modelo --> Visualización

Este patrón es el que pienso usar, en donde la visualización es la ventana donde se ve el laberinto, las entradas son los datos que el robot pasa a el contenedor el cual modela a los muros y guarda sus posiciones y la del robot(s).

Bibliografía:
An Introduction to Object-Oriented Programming,(3rd Edition)
Timothy Budd
http://ootips.org/mvc-pattern.html
http://www.go4expert.com/forums/showthread.php?t=5127#prototype

Demostraciones de avance parcial

Taller de programación orientada a objetos
Semana 8

Esta vez voy a mostrar un poco del avance que he tenido con el código en mi programa.

Por el momento el programa solo inicia el sistema principal, que a su vez trata de comunicarse con dispositivos bluetooth ( lo cual aun no he codificado) y se apaga automaticamente dado un tiempo preestablecido por el usuario ( en este caso son 4 iteraciones del programa).

Para poder tener tiempo de ver lo que el programa hace, agregue un retardo con en while y un for anidados, iterando numeros mayores a 1000, por el momento los retardos representan los tiempos en que se realizan las comunicaciones y demas funciones del sistema.

package oop;

/*
 *clase base de la mayoria de las clases que se usan en el 
 *proyecto de oop
*/

public class Comun {

    //atributos
    int id;
    int estado;

    //constructor
    public Comun(int valorId, int valorActivado){
 id = valorId;
 estado = valorActivado;
 System.out.println("Creando objeto con valores definidos por el usuario");
    }

    //constructor vacio
    public Comun(){
 id = 0;
 estado = 1;
 System.out.println("Iniciando objeto con valores predefinidos");
    }

    //atributos
    public int verId(){
 System.out.println("Viendo id del objeto");
 return id;
    }

    public int verEstado(){
 System.out.println("Viendo estado del objeto");
 return estado;
    }

    public void Activar(){
 System.out.println("Estado");
 estado = 1;
    }

/*
 *clase principal del programa, se encarga de coordinar todas las 
 *demas clases del proyecto, hereda de la clase comun
 */

package oop;

public class Sistema extends Comun {
    
    //atributos
    int idContador, modo,tiempoMuestreo,contadorMuestreo;
    int tiempoPrendido, contadorPrendido, apagar;
    String[] nombres={"Sistema","Informacion","Graficos",
       "Comunicador","Usuario"};


    //constructor vacio
    public Sistema(){
 super();
 tiempoPrendido = -1; //tiempo indefinido
 tiempoMuestreo = 5000; //cada 5000 iteraciones toma un valor
 modo = 1; //modo automatico 
 aumentarIdContador();
 apagar = 0; //inicialmente el programa esta prendido
    }

    //constructor con elementos
    public Sistema(int prendido, int muestreo, int modo){
 super();
 tiempoPrendido = prendido;
 tiempoMuestreo = muestreo;
 this.modo = modo;
 aumentarIdContador();
 apagar = 0;
    }

    
    //aumenta el valor del contador de muestreo
    public void aumentarContadorMuestreo(){
 if((++contadorMuestreo%tiempoMuestreo)== 0){
     System.out.println("******Conectando con el dispositivo*****");
 }
 return ;
    }

    //aumenta el valor del contador de prendido
    public void aumentarContadorPrendido(){
 //System.out.println("Entrando a aumentarContadorPrendido");
 if(tiempoPrendido == -1){
     System.out.println("El tiempo de prendido esta indefinido");
 }else{
     //el programa va a ser apagado
     if(++contadorPrendido>= tiempoPrendido){
  apagar = 1;
  System.out.println("Apagando el sistema");
  return;
     }else{ // el programa sigue prendido
  //contadorPrendido++;
  //System.out.println("Aumentamos el contador de prendido");
  System.out.print("Valor de tiempo prendido -- ");
  System.out.println(contadorPrendido);
     }
 }
 //System.out.println("Saliendo de aumentarContadorPrendido");
 return ;
    }

 


    //metodo que pausa el sistema para que no termine muy pronto
    public void delay(int repeticion){
 int i = 0;
 //System.out.println("Iniciando delay");
 System.out.println("........");
 while (i < repeticion){
     for(int j=0;j<10000;j++){
     }
     i++;
 }
 //System.out.println("Delay finalizado");
 return ;
    }


    //metodo principal
    public static void main(String[] args){

 System.out.print("--> ");
 System.out.println("Sistema prendido");
 Sistema principal = new Sistema(4,2,1);
 
 //mantiene el programa activo mientras no se de la orden de apagar el programa
 System.out.println("Valores del sistema");
 System.out.print("id--");
 System.out.print(principal.id);
 System.out.print(", tiempoPrendido--");
 System.out.print(principal.tiempoPrendido);
 System.out.print(", tiempoMuestreo--");
 System.out.print(principal.tiempoMuestreo);
 System.out.println("");
 while (principal.apagar != 1){
     principal.delay(100000);
     principal.aumentarContadorMuestreo();
     principal.aumentarContadorPrendido();
 }
 System.out.print("--> ");
 System.out.println("Systema apagado");
    }
    //fin del programa
} 

La implementación del código da como resultado:

Como se puede ver el sistema se inicia, luego muestra las variables del sistema.
Después nos muestra el valor de cada iteración con valor de tiempo prendido y cada cierto tiempo
trata de conectar con el dispositivo bluetooth.
Cuando llega al número de iteraciones que tiene que realizar termina el programa.
Por el momento esto es todo lo que tengo, pero conforme pasen los dias pienso agregar la comunicación
bluetooth y la funcionalidad de usuario, usando los eventos y luego guardar datos en un
archivo de texto por el momento.


Todos los comentarios y sujerencias son bien recibidos.

Diagramas de clase y secuencia de UML

Diagramas de mi proyecto de software.

Diagramas uml2

View more presentations from colli03

Herramientas para diagramas de clase y secuencia de UML; autogeneración de código

Existen muchas herramientas que permiten la creación de diagramas UML, de las cuales yo utilize umbrello.
La instalación en Ubuntu es muy sencilla, basta con teclear desde terminal:
sudo apt-get install umbrello

Para correr el programa, se puede hacer desde terminal tecleando:
umbrello &

Una imagen de como se ve un diagrama en el programa.  

 

Código generado en base al diagrama de clases de la foto anterior.

 

 

// 
/**
 * Class elemento
 */
public class elemento {

  //
  // Fields
  //

  public boolean activo;  /**

   * Clase principal del sistema
   *    */

  public String nombre;
  
  //
  // Constructors
  //
  public elemento () { };
  
  //
  // Methods
  //


  //
  // Accessor methods
  //

  /**
   * Set the value of activo
   * @param newVar the new value of activo
   */
  public void setActivo ( boolean newVar ) {
    activo = newVar;
  }

  /**
   * Get the value of activo
   * @return the value of activo
   */
  public boolean getActivo ( ) {
    return activo;
  }

  /**
   * Set the value of nombre
   * Clase principal del sistema
   * 
   * @param newVar the new value of nombre
   */
  public void setNombre ( String newVar ) {
    nombre = newVar;
  }

  /**
   * Get the value of nombre
   * Clase principal del sistema
   * 
   * @return the value of nombre
   */
  public String getNombre ( ) {
    return nombre;
  }

  //
  // Other methods
  //

  /**
   */
  public void apagarElemento(  )
  {
  }


  /**
   */
  public void prenderElemento(  )
  {
  }

}

Documentación sobre el uso de umbrello.

http://docs.kde.org/stable/en/kdesdk/umbrello/working-with-umbrello.html

Documentación para leer sobre diagramas UML.

http://www.agilemodeling.com/artifacts/

Presentación del proyecto

Esta es la presentación de mi proyecto, donde muestro una breve descripción sobre lo que trato de hacer.

Proyecto final de POO

View more presentations from colli03.