Mostrando entradas con la etiqueta Programación. Mostrar todas las entradas
Mostrando entradas con la etiqueta Programación. Mostrar todas las entradas

domingo, 6 de diciembre de 2015

SOFTWARE - Programa de Contabilidad para Bar Escolar

UN PROGRAMA DESARROLLADO EN JAVA PARA MANEJAR EL STOCK DE PRODUCTOS, CUADRAR LA CAJA Y CALCULAR RÁPIDAMENTE EL DINERO EN MONEDAS. ADEMAS ALMACENA LA INFORMACIÓN EN UN ARCHIVO DE EXCEL. POR ULTIMO SE CONSTRUYE UN EJECUTABLE DEL PROGRAMA.

Después de elegir el archivo de Excel(.xls), el programa se divide en dos secciones. La primera para el control de inventario, en donde a través de una tabla se lista las características de cada producto existente y permite ingresar nuevo stock así como dar de baja stock. También tiene opciones para editar nombre y precio de un producto y agregar un nuevo producto al inventario.

Con el stock al día, se utiliza la segunda parte. En esta sección se ingresa el stock sobrante del día para calcular la cantidad vendida; en las columnas de fiados y cobros se ingresa los valores($) para calcular el monto total de fiados y de cobros de fiados. Por ultimo en esta sección se ingresa la cantidad de monedas y billetes para calcular el dinero total y cuadrar la caja.

Como extra, el programa da la posibilidad de calcular el monto total de las monedas. Esto con el fin de calcular rápidamente la cantidad de monedas que se quedaran en caja chica para vueltos.

Toda la información del dinero fiado, cobrado, vendido en efectivo se guarda en una hoja de Excel, mientras que el stock de los productos se guarda en otra hoja de Excel dentro del mismo libro.

Por ultimo, con ayuda del programa LAUNCH4J se construyó el ejecutable del programa para correrlo en cualquier computador que tenga instalado JRE.

*Se utiliza como monto fijo en caja chica de 25$

En el siguiente link les dejo el CÓDIGO del programa en Java:
CÓDIGO FUENTE







sábado, 31 de enero de 2015

MICROONDAS - Enlace Punto a Punto y Análisis del Espectro

UN PROGRAMA DESARROLLADO EN MATLAB CAPAZ DE CALCULAR TODOS LOS PARAMETROS DE UN ENLACE PUNTO A PUNTO ENTRE DOS ANTENAS, UBICANDOLAS EN UN MAPA DE GOOGLE MAPS. ADEMAS EL CONTROL DE TABLAS DE EXCEL DESDE MATLAB Y TODOS LOS TIPOS DE GRAFICOS ESTADISTICOS PARA MOSTRAR LOS DATOS PROCESADOS.

El programa consta de dos partes, la primera parte muestra el control completo de 4 bases de datos hechas en Excel (.xls y .xlsx), por medio de los nombres de los campos de la base de datos se hace un recorrido, conteo y análisis estadístico para representar los resultados de forma gráfica utilizando:

    -Diagramas de sectores
    -Diagramas de sectores 3D o Pasteles
    -Diagramas de barras
    -Diagramas de barras con datos agrupados.
    -Histogramas.

La segunda parte del programa es un enlace punto a punto, con las posiciones de las antenas, la potencia, frecuencia, ganancia entre otros campos de perdidas como datos de ingreso, para calcular todos los datos sobre el enlace como:
     -Longitud de Onda
     -Distancia
     -Azimuths
     -PIRE
     -FSL
     -Margen de Enlace
     -Perdidas Atmosféricas
     -Perdidas por Nubes
     -Perdidas por Reflexión
     -Perdidas por Lluvia
     -Perdidas por Fresnel

Entre otras, ademas el programa utiliza la función plot_google_map para graficar en un mapa la ubicación de las antenas, así también graficar el perfil topográfico para hacer el análisis de las zonas de Fresnel.

En el siguiente link les dejo el CÓDIGO del programa en Matlab:
CÓDIGO FUENTE







domingo, 26 de octubre de 2014

OpenCV. Primeros Pasos

Qué todavía no has escuchado de OpenCV??? Bien en parte es responsabilidad nuestra.

Y qué tal acerca del Kinect? No solo para jugar videojuegos sino por todos estos proyectos: Los de aquí y los de acá. La mayoría de estos proyectos que  son de desarrolladores independientes usan OpenCV y los proyectos que son de empresas grandes usan un software parecido.

OpenCV es una librería originalmente escrita para C/C++, pero actualmente también se la puede usar con los lenguajes Java, C# y Python, que son derivados de C++. Se puede usar en Windows, Linux, Mac Os, iOs y Android. (Es decir, en casi todo lo que tenga una pantalla).  Así es, no es más que un montón de código fuente que sirve para hacer algo de magia con imágenes y vídeos:
Nacido en los laboratorios de Intel en 1998, es ahora soportado principalmente por Itseez, donde continúan trabajando cuatro personas del equipo de desarrollo original.
Para usar su potencial se necesita descargar desde aquí. La última versión estable es la 2.4.10 pero la documentación para Python es para la versión alpha 3.0, sin embargo también es válida para la versión 2.4.10

Casi seguro ya tienes instalado Python en tu PC, pero por si no es así, basta con ir a: https://www.python.org/downloads/  para descargarlo. Descarguen la version 2.7 que es compatible con la versión 2.4.10 de OpenCV.
Para obtener OpenCV igualmente solo es necesario ir a Download opencv-2.4.10.exe (367.3 MB) si tienes Windows o ir a http://sourceforge.net/projects/opencvlibrary/ en caso de tener otro sistema operativo.
Además se necesita descargar e instalar Numpy (http://sourceforge.net/projects/numpy/)  y Matplot  (http://sourceforge.net/projects/matplotlib/).

Adermás si bien se puede usar varios editores de código, recomiendo PyCharm en su versión Community (https://www.jetbrains.com/pycharm/download/)

Con todos eso instalado podemos empezar a usar OpenCV. Por si falta algún paso pueden pasarse por aqui .


 Para probar que todo esta bien conecten su cámara web y poner esto dentro de un archivo y llamenlo pruebas.py o como deseen pero preferiblemente con la extensión ".py"

import numpy as np
import cv2
import cv2.cv as cv 
#Creamos un objeto que maneje la camara
cap = cv2.VideoCapture(0)
cap.open(0) 
#Repetimos hasta que se cierre el programa
while(True):
   #Capturamos la imagen actual 
   ret, img = cap.read()
   #Si la captura es correcta entonces la mostramos
   if ret:
       cv2.imshow('img',img)
   #Eperamos que  el usuario presione alguna tecla, en este caso la  letra "q" 
   # que nos servirá para cerrar el programa.
   key=cv2.waitKey(1)
   if  key == ord('q'):
       break
#Al salir del bucle infinito cerramos la ventana y dejamos de utilizar la cámara.
cap.release()
cv.DestroyWindow("img")

Recuerden que ne Python la indentación o tabulación es importante, al igual que los dos puntos al final de las instrucciones de ciclos o comparación como en este caso if y while.

Eso es todo. Pueden probar los ejemplos que vienen junto a OpenCV y también leer tutoriales en OpenCV-Python Tutorials o si gustan en español en Tutorial-OpenCV
Y claro no nos olvidemos de Youtube, fuente inagotable de ideas y proyectos realizados alrededor del mundo. 









lunes, 16 de junio de 2014

REDES NEURONALES - BACK PROPAGATION PERCEPTRON CON UNA CAPA OCULTA

Una de las bases de la inteligencia artificial es la neurona artificial. Las capas ocultas en una red neuronal permite resolver problemas no linealmente separables. A continuacion se muestra el esquema, codigo y programa en MATLAB para resolver la compuerta logica XOR a traves del entrenamiento por el metodo de BACK PROPAGATION de una red neuronal con una capa oculta.

Esta red neuronal se compone de dos entradas, una capa oculta con 2 neuronas y una salida en la ultima capa. El esquema de la red neuronal se muestra en la siguiente figura:


El programa calcula los pesos del esquema utiiliando el metodo de Back Propagation con el metodo de aprendizaje delta.

PERCEPTRON CON UNA CAPA OCULTA Back Propagation XOR


%BOTON ENTRENAR.
function btEntrenar_Callback(hObject, eventdata, handles)
    %Obtener Datos de Tabla
    datos=get(handles.Tabla,'Data');
    x1=datos(:,1);
    x2=datos(:,2);
    yd=datos(:,3);

    %Otener datos iniciales de pesos y bias
    w110= str2double(get(handles.w110,'String'));
    w120= str2double(get(handles.w120,'String'));
    w210= str2double(get(handles.w210,'String'));
    w220= str2double(get(handles.w220,'String'));
    v10= str2double(get(handles.v10,'String'));
    v20= str2double(get(handles.v20,'String'));
    u210= str2double(get(handles.u210,'String'));
    u220= str2double(get(handles.u220,'String'));
    u30= str2double(get(handles.u30,'String'));
    alfa= str2double(get(handles.alfa,'String'));
 
    %Otener datos de iteraciones y error
    iteracionmax = str2double(get(handles.Iteraciones,'String'));
    errormax = str2double(get(handles.Error,'String'));

    %ENTRENAMIENTO
    w11= w110;
    w12=w120;
    w21= w210;
    w22= w220;
    v1= v10;
    v2= v20;
    u21= u210;
    u22= u220;
    u3= u30;
    condicion = 0;
    iteracion = 0;
    error_Total = zeros(1,iteracionmax+1);
    while(condicion == 0)
        for j = 1 : 4
            %Calcular la yObtenida
            %Capa Entrada
            z1 = x1(j);
            a11 = z1;
            z2 = x2(j);
            a12 = z2;

            %Capa Oculta
            z3 = a11*w11+a12*w21 + u21;
            a21 = funcion_activ(z3);
            z4 = a11*w12+a12*w22 + u22;
            a22 = funcion_activ(z4);

            %Capa Salida
            z5 = a21*v1 + a22*v2 + u3;
            yObtenida = funcion_activ(z5);

            %Calculamos error yObtenida*(1-yObtenida)*
            err = (yd(j)- yObtenida);

            %Correccion pesos Capa 2-3
            z= v1*a21+v2*a22+u3;
            d3 = err*derivada_fun_act(z);
            v1 = v1 + alfa*d3*a21;
            v2 = v2 + alfa*d3*a22;
            u3 = u3 + alfa*d3;

            %Correccion pesos Capa 1-2
            d21 = derivada_fun_act(z3)*v1*d3;
            w11 = w11 + alfa*d21*a11;
            w21 = w21 + alfa*d21*a12;
            u21 = u21 + alfa*d21;

            d22 = derivada_fun_act(z4)*v2*d3;
            w12 = w12 + alfa*d22*a11;
            w22 = w22 + alfa*d22*a12;
            u22 = u22 + alfa*d22;

            %Contar error total
            error_Total(iteracion+1) = error_Total(iteracion+1)+abs(err);
        end
        iteracion = iteracion +1
        if(iteracion >= iteracionmax)
            condicion =1;
        end
        if (error_Total(iteracion) <= errormax)
            condicion =1;
        end
    end

    %Mostrar los Resultados
    set(handles.w11,'String',num2str(w11));
    set(handles.w12,'String',num2str(w12));
    set(handles.w21,'String',num2str(w21));
    set(handles.w22,'String',num2str(w22));
    set(handles.v1,'String',num2str(v1));
    set(handles.v2,'String',num2str(v2));
    set(handles.u21,'String',num2str(u21));
    set(handles.u22,'String',num2str(u22));
    set(handles.u3,'String',num2str(u3));

    %Dibujar el error
    axes(handles.axes1);
    x=0:1:iteracionmax;
    plot(x,error_Total,'color','r', 'LineWidth', 2);
end

function f = funcion_activ(z)
    %SIGNOIDE
    f = 1/(1+exp(-z));
end

function fp = derivada_fun_act(z)
    %SIGNOIDE
    fp = (1-funcion_activ(z))*funcion_activ(z);
end

lunes, 12 de mayo de 2014

ML II: Asunción de Markov y Redes Bayesianas.

Siguiendo con el ejemplo del artículo anterior que pasa si agregamos una nueva medida del sensor de luz, representada por la variable aleatoria Luz2. Queremos ahora conocer p(Puerta=abierta|Luz1, Luz2).
Usando Bayes tenemos:
Ahora sabemos que Luz1 no afecta a la medida de Luz2, por tanto son variables independientes y condicionalmente independientes dado Puerta.
Esto es llamado la Asunción de Markov, pues no depende del estado anterior.

Realizando el cálculo al reemplazar valores resulta:

P: Puerta, L1: Luz1, L2: Luz2
Con datos:

Como conclusión se nota que el conocer Luz2 merma la probabilidad de que la puerta este abierta en comparación a cuando solo se conocía Luz1.

Asunción de Markov. Más formalmente se define, asumiendo que se tienen medidas Zn condicionalmente independientes a otra variable X.



Ahora llevemos el ejemplo a  Sensar y Actuar, es decir el robot conoce si la puerta esta abierta o cerrada y actúa en consecuencia cerrándola o abriéndola. (Un sencillo Agente Inteligente)

Para esto modelemos la acción como una variable aleatoria U=u, y queremos conocer la probabilidad condicional de p(Puerta|U). 
 El gráfico de arriba muestra las probabilidades de transición de pasar de la puerta abierta a cerrada, un 90%, viceversa o que se mantenga en el mismo estado.

Donde P: Puerta, PA: Puerta en su estado anterior, U: acción. Y con los datos del último ejemplo se tiene
Al final interesa la p(Puerta=cerrada|u) por que con el sensor tratábamos de conocer si la puerta está abierta  y el objetivo es cerrar la puerta.

Por eso hasta ahora logramos conseguir el estado del sistema mediante la actualización por el sensor y por la acción realizada. Ahora tratemos de combinar ambas.
Para eso definiremos la creencia (Belief). 
Podemos describir el proceso general mediante una Red Bayesiana Dinámica:

Esto incorpora las siguientes Asunciones de Markov:
Con estas ultimas expresiones usando Bayes se llega a:
Dado que la creencia es recursiva es posible realizar su calculo mediante un algoritmo:

 Algoritmo Filtro de Bayes (Bel(x),d)


 El filtro de Bayes es principalmente usado en: 
  • Filtro de Kalman.
  • Filtro de Partículas.
  • Modelos Ocultos de Markov
  • Redes  Bayesianas Dinámicas.
  • Procesos de Decisión de Markov Parcialmente Observables.

Que a su vez son usados en clasificación de patrones y seguimiento de objetos en imágenes.

En resumen:
• El razonamiento probabilístico es necesaria para hacer frente a la información incierta, por ejemplo, mediciones de sensores 
• Usando la regla de Bayes, podemos hacer el razonamiento de diagnóstico basados en el conocimiento causal 
• El resultado de las acciones de un robot se puede describir mediante un diagrama de transición de estado. 
• La estimación de estado probabilístico se puede hacer de forma recursiva mediante el filtro de Bayes usando un sensor y una actualización de movimiento 
• Una representación gráfica para el problema de estimación de estado es la Red Bayesiana Dinámica.

Scilab
Ahora como ejercicio en Scilab crearemos una función Normal de probabilidad e implementaremos una integral. Para la integral usaremos simplemente su definición que es la de una suma de la función tomada en pequeños intervalos.

Primero abrimos Scilab y dentro de este a SciNotes.
En este editor escribiremos el siguiente código:

//Función de una densidad de probabilidad normal
//x: es un arreglo unidimensional del dominio de la función. Arreglo(float) 
//u: es el valor esperado o media. float
//s2: es la varianza de la densidad. float  
function fnormal = normal(x, u, s2 )
    fnormal=1/(sqrt(2*%pi*s2))*exp(-(x-u).^2/(2*s2));
endfunction    

Y guardamos como norma.sci. Ejecutamos con el símbolo de Play

Luego en un nuevo archivo copiamos el siguiente código:

//Función para calcular una integral definida
//x: es un arreglo(vector) unidimensional del dominio de la función
//fx: es la función. Arreglo(float)
//a: limite inferior de la integral. float
//b: limite superior de la integral. float
function F=integral(x,fx,a,b)
    delta=x(2)-x(1); //Separación en el eje x
    F=0; //Valor inicial
    j=1; //Variables auxiliares
    inf=1;
    sup=length(x);
//Primero comprobamos que los limites dados estén dentro del dominio
    if x(1)>a | x(1)>b then
        messagebox("Limite inferior erroneo, funcion no definida", "Error", "error");
    end
    if b>x(length(x))| a>x(length(x)) then
        messagebox("Limite superior erroneo, funcion no definida", "Error", "error");
    end

//Segundo encontramos los limites en nuestro arreglo x.
//sup indicara el indice del limite superior e inf el indice del limite inferior
    if b>a then
        while(x(j)<b & j<length(x))
            if x(j)<=a then
                inf=j;  
            end
        j=j+1;
        end
    sup=j;
//Calculamos la integral sumando los valore, como delta es constante se multiplica al final    
for i=inf:sup
        F=F+fx(i)
    end
    F=F*delta;

elseif b<a then
    while(x(j)<a & j<length(x))
        if x(j)<=b then
            inf=j;  
        end
        j=j+1;
    end
    sup=j;
    for i=inf+1:sup
       F=F-fx(i); 
    end
    F=F*delta;
    
    end

endfunction

//Función para obtener la función resultante de integra fx, 
//es la integral indefinida o pues no tiene limites definidos
//x: es un arreglo(vector) unidimensional del dominio de la función
//fx: es la función. Arreglo(float)
function IndF=fintegral(x,fx)
   delta=x(2)-x(1); 
IndF=zeros(length(x));
IndF(1)=fx(1)*delta;
//IndF ya no es un valor sino otro vector que tiene como datos los valores la integral
 for i=2:length(x)
        IndF(i)=IndF(i-1)+fx(i)*delta;
    end
return IndF
endfunction

Guarda como integral.sci y ejecuta.

Finalmente copia esto en la interfaz principal y presiona enter o crea un nuevo archivo y ejecuta

clc
//Dominio de las funciones
x=-30:0.01:30;
//Ejemplos de Densidades
pdf1=normal(x,0,1);
pdf2=normal(x,0,49);
pdf3=normal(x,4,1);
pdf4=normal(x,-10,9);
//Dibujar
plot(x,pdf1,'r-.',x,pdf2,'b--',x,pdf3,'g-',x,pdf4,'m:');
//r=rojo, b=azul, g=verde, m=magenta
//Probabilidad de que X de pdf1 este entre 0 y 1
Prob=integral(x,pdf1,0,1);
PDF=fintegral(x,normal(x,3,40));
figure();
plot(x,PDF);
disp(Prob, "La probabilidad de X es de ");

Si te salen estas figuras lo has hecho todo bien:



Con relación a la figura 2 se puede observar que PDF es una función creciente que empieza en su parte izquierda con 0 y en la parte más a la derecha tiene el valor de 1. A esto se le llama la función de distribución de probabilidad.

Como ultimo punto ingresa estas lineas  una por una en la interfaz principal, sin punto y coma para que se muestre el resultado
Prob1=integral(x,pdf1,-1,1)
Prob2=integral(x,pdf1,-2,2)
Prob3=integral(x,pdf1,-3,3)
Prob4=integral(x,pdf1,-4,4)
Prob5=integral(x,pdf1,-5,5)
Prob6=integral(x,pdf1,-6,6)
Estas son las probabilidades de la gaussiana normalizada, con media cero y varianza uno, para 1,2,3,4,5 y 6 varianzas o . Esto nos sirve para verificar nuestra integral ya que segun wikipedia los valores exactos de la llamada función error son:
Como punto adicional puedes ver cual es el error de nuestro método para integrar, pues existen otros métodos numéricos diseñados para realizar justamente este tipo de integrales que son casi imposibles de realizar manualmente.


miércoles, 30 de abril de 2014

Lenguaje de Programación C

C es un lenguaje de programción creado en 1972 por Dennis M. Ritchie y también Kernighan, en los Laboratorios Bell (La electrónica moderna se desarrolló en gran parte en estos laboratorios). 

Es un lenguaje que permite acceder al hardaware por lo que es usado ampliamente en la creación de sistemas operativos (GNU-Linux, Windows, OSX)  y en sistemas embebidos que usan microprocesadores (celulares, dvds, etc). 

Se creo pensando en que sirva para cualquier plataforma o arquitectura y en lo posible facilmente portable, por ejemplo que el código que sirve para leer un dvd en un computador sirva para el reproductor de dvd conectado al televisor.

Es un lenguaje de programación estructurada, por lo que tiene subrutinas (llamadas también funciones o métodos), bloques condicionales y bucles. Se espera que cada linea de código se ejecute inmediatamente después de la anterior a menos que se llame a un subrutina. Esto a diferencia que en ensamblador existe el comando goto que permite ir a cualquier linea del programa pero puede causar errores si no se llega a la linea correcta.  El llamado a subrutinas permite también realizar programación funcional.   
Para la programación orientada a objetos (POO) se creo C++. Actualmente JAVA que imita bastantes características de C++ es más usado en POO.


Entre las principales características de cualquier programa escrito en C están:

  • La inclusión de bibliotecas( librerías , cabeceras):

#include <stdio.h> /*añade un librería que se encuentra en la carpeta por default, suelen ser las mas usadas*/ 
#include "micarpeta/milibreria" /*añade una librería que se encuentra en otra carpeta del programador.*/

  • La definición de contantes y macros:
#define hola hello //reemplaza todos los "hello" por "hola" en todo el código a continuación. 
#define pi  3.141592 //reemplaza la palabra pi por su valor numérico.
#if, #else, #elif, #endif    /*sirven para crear bloques condicionales para que el codigo sea distinto segun ciertas condiciones de la pataforma pero se encuentre en un solo archivo de codigo fuente*/ 
#ifdef, #ifndef   /*comprueba si se ha definido una constante o nombre, se usa para lo mismo que las cuatro anteriores. */


  • La declaración de funciones:

void main(); /*Una función que no devuelve ningún valor y no necesita ningún valor de entrada. */
int suma(int sumando_a, int sumando_b); /*Una función que devuelve un valor entero y necesita como argumentos dos valores enteros.*/


  • La declaración de variables: 
Se declaran usando la sintaxis: tipo nombre;


int a; //una variable numérica entera. 
char b; //una variable numérica de 0 a 256 usada generalmente para representar texto en ascii. 
float c; //una variable numérica decimal. 

Si se declaran antes de la función main() son llamadas variables globales, las declaradas dentro de cada función son variables locales. Una buena practica es colocar nombres distintos a las globales de las locales para corregir errores con mayor facilidad.


  • El código de las funciones :
Ejemplo: Para la función "suma" declarada arriba el código sería:

int suma(int sumando_a, int sumando_b){ 
int resultado=sumando_a+sumando_b; /*Se puede asignar valor a las variables en su declaración */ 
return resultado; /*toda función no declarada como void necesita tener al menos un sentencia return */  
}
Recordar: Toda sentencia termina con " ; ".


  • La función principal main():
Todo programa escrito en C, necesita por lo menos la función main() para ejecutarse (funcionar).


  • La función if: 
Se usa para realizar condicionantes: Si x entonces y, caso contrario z. No necesariamente se usa el caso contrario. 
  
if (a<b) {  
//Lo que tiene que suceder si en efecto "a" es menor a "b" 
} 
else { 
// Lo que tiene que suceder si "b" es menor o igual a "a" 
}

  • La función switch:
Se usa si una variable puede tener múltiples valores y cada valor necesita una distinta acción a realizar.

switch (x){ 
case 1: //Lo que debe suceder si x es 1;  break; 
case 2: //Lo que debe suceder si x es 2;  break; 
default: // Lo que debe suceder si x no es 1 ni 2;  break;  
}
  • La función while:
Se usa para repetir un bloque de sentencias (lineas de programa) hasta que se cumpla una condición. Se puede usar while(1) para crear un bucle infinito. (La mayoría de programas embebidos corren desde que se prende el equipo hasta su apagado)   

int y=0; 
while(y<10){ 
//Esto se repetirá 10 veces; 
y++; /*Una forma de hacer y=y+1, en este caso se suma al después de la linea, ++y suma antes de realizar el resto de lo que se encuentre en la misma linea. Existen ademas y--, --y */ 
}

  • La función for:
Se usa para repetir un bloque de sentencias un numero definido de veces o para cambiar secuencialmente de valor una variable. El uso de arreglos hace inevitable el uso de la función for.

for (int i=0; i<10; i++){ 
//Esto se repetirá 10 veces 
}

El código de ejemplo de la función while y la función for hacen exactamente lo mismo pero con for resumimos en una linea lo escrito en tres con while. La función while en la practica se usa para condiciones mas complejas.


  • Comentarios
Si todo lo que esta despues de // si ocupa solo una linea o dentro de /* */ para comentarios de varias lineas.
Es una buena practica iniciar el programa con: 

/* Nombre del archivo: 
Proyecto o Programa principal al que pertenece:
Descripción básica:  
Autor:
Licencia: 
Fecha de creación:
Fecha de modificación: 
Logotipo en Ascii "|\/| (()) ~|~ [[-" ;-D, existen verdaderos artistas en esto. No es necesario pero le da un toque de dedicación y originalidad.   */

miércoles, 16 de octubre de 2013

Impresora 3D, Parte III: Software de Terceros

Para obtener un objeto impreso en 3D se necesita moldearlo en el computador con algún programa dedicado a ello como  Blender, y se pueden lograr cosas como estas:


E incluso en Blender se puede realizar también animación y realizar vídeos como:

Una vez que se tiene el modelo realizado en computadora es necesario transformarle en coordenadas que puedan ser enviadas como instrucciones a la impresora 3D, para esto es necesario guardarlo en formato .stl (desde cualquier programa de modelado 3D), en Blender se  logra seleccionando el submenú "Export" del menú "File":


Un lugar donde se puede encontrar una gran cantidad de modelos en 3d en formato .stl es  www.thingiverse.com.


Con el archivo .stl en mano es hora de usar otro programa para transformarlo en código G, que es un estándar de máquinas de prototipo rápido y de control numérico computarizado (CNC). Un programa que es muy usado por su facilidad de uso y que es gratis es Slic3r, además que  está diseñado para crear código G listo para ser usado en impresoras 3D.
Logo de Slic3r, para no confundirse con 3D Slicer.
 El código G son instrucciones que indican a la maquina principalmente la posición requerida y la velocidad a la cual debe moverse. Además indica la temperatura, cambio de herramienta (por ejemplo en Impresoras 3D que imprimen a colores, o que imprimen en múltiples materiales), etc.

Código G visto en Notepad++

En el extracto de arriba se pueden ver comandos que empiezan con las letras G y M, explicado cada uno brevemente:
M107: Enciende un ventilador de disipación de calor.
M104: Indica la temperatura del extrusor, S200 coloca la temperatura en 200 C.
G28: Mueve el extrusor a una posición predeterminada de origen. 
M109: Hace lo mismo que M104.
G90: Indica que las distancias usadas para el espacio(X, Y, Z) son absolutas.
G21: Indica que las coordenadas están dadas en milímetros.
G92:  Coloca en el software las coordenadas en 0, E0 coloca las coordenadas del extrusor en 0.
M82: Indica que las distancias dadas para el extrusor (E) son absolutas.
G1: Indica que se debe hacer un movimiento y las coordenadas de destino. Lo que esta después de F es velocidad, después de X coordenada X y así sucesivamente con Y, Z y E.

Nuestro propio software lo que realizara es la interpretación del código G y su transmisión vía comunicación serial con un microcontrolador.
En el microcontrolador se recibirán ordenes para mover adecuadamente los motores y controlar la temperatura. El detalle de esto en el próximo articulo.


No viene mal que ya descarguen y jugueteen con alguno de estos programas.

sábado, 21 de septiembre de 2013

Impresora 3D, Parte II: Microcontrolador

En la primera parte presentamos a estos dispositivos. Ahora nos dedicaremos ha describirlo en detalle. Es importante dado que se les puede utilizar en muchísimas aplicaciones,y que la impresión 3D es solo una más de tantas.


¿Pero qué es un microcontrolador?

Un procesador digital con periféricos integrados o como lo dice la Wikipedia:  Un circuito integrado programable, capaz de ejecutar las órdenes grabadas en su memoria. Está compuesto de varios bloques funcionales, los cuales cumplen una tarea específica. Un microcontrolador incluye en su interior las tres principales unidades funcionales de una computadora: unidad central de procesamiento, memoria y periféricos de entrada/salida.
Desmenuzando el concepto encontramos palabras como procesador o unidad central de proceso, memoria y periféricos de entrada/salida.

Procesador: Es la cabeza del microcontrolador, lee instruciones de la memoria, las ejecuta y el resultado lo vuelve a guardar en memoria y/o lo envía a los periféricos. 
En comparación a los procesadores usados en computadoras son mucho más "lentos". Además se dedican a una tarea específica. Lejos de ser desventajas, implica menor consumo de energía y menor costo. 

Memoria: Ya que el propósito de un procesador es seguir instrucciones, estas se almacenan en una memoria. Estas instrucciones es lo que llamamos programa al ejecutarse en un orden pre-establecido. Para obtener dicho orden requiere de un contador de programa y una pila (fila) para este contador. La memoria que almacena estas instrucciones es de solo lectura y de allí su nombre en inglés ROM (Read Only Memory).
  
Dentro de la memoria además se encuentran registros reservados para el funcionamiento correcto del microcontrolador y variables de usuario, datos que varían durante la ejecución del programa. La memoria que almacena esto es más grande y se necesita de acceso aleatorio, de alli sun nombre en inglés RAM (Random Access Memory).

Periféricos de Entrada/Salida: Un sistema digital que no posee interacción con el mundo físico no sirve de mucho. Está es la principal ventaja de los microcontroladores, poseen en un solo chip todo lo necesario para interactuar con el mundo físico y con otros sistemas digitales. Más que los periféricos como tal, que pueden ser una pantalla, un teclado, un motor, un micrófono, un parlante, etc, el microcontrolador posee los puertos (físicamente las patitas o pines) para conectarlos y lo necesario para comunicarse mediante estándares como I2C, SPI, UART, USB incluso ETHERNET. 

Ejemplo de comunicaciones SPI, el Master es una computadora básica y utiliza un microcontrolador en una placa Arduino para controlar la Pantalla LCD

¿Como funciona un microcontrolador?

El microcontrolador esta diseñado para dedicarse a una tarea específica. Esta tarea es definida por el programa, el cual puede ser escrito en diversos lenguajes de programación: ensamblador(el cual es distinto según el fabricante del microcontrolador, pero permite usarlo completamente), en C (el más usado y cumple un estándar, por lo que pasar el programa de un microcontrolador a otro, ya sea de distinto modelo o marca, es más fácil.) o en Basic (el más sencillo pero puede no estar disponible para algunos microcontroladores). 

Una vez que esta listo el programa debe ser grabado en el microcontrolador. Esto se puede hacer mediante un grabador dedicado para el microcontrolador según el fabricante o cargando previamente un programa llamado "bootloader", mediante dicho grabador, para luego poder modificar el programa mediante conexión USB. Tal vez no hace falta mencionar que hasta este punto una computadora es imprescindible para el proceso, de aquí en adelante la necesidad de un computador dependerá del uso que le demos al microcontrolador.

Una vez con el programa cargado en el microcontrolador, debemos energizarlo y darle una señal de reloj para que el programa inicie a ejecutarse, además conectarle a los periféricos con los que se va a trabajar.
Esto podemos realizarlo ya sea en un protoboard o en una placa impresa previamente realizada.
Como es más seguro hacerlo en una placa impresa pero también podemos desear grabarle otro programa, o de plano utilizar el microcontrolador en otra tarea entonces es muy útil hacer una placa llamada Entrenadora, con conexiones para todos los puertos. 
Entrenadora para un PIC18F2550
(Queda pendiente subir el diseño de una entrenadora y un tutorial para crear tus propias placas impresas, puedes adelantarte buscando en Internet.
Esto hasta encontrar un programa libre para realizar placas y la mejor opción de microcontrolador. El PIC16F887 de Microchip es en el cual esta desarrollado actualmente la impresora.
Como se ve en las imagen anterior el PIC18F2550/4550, también de Microchip, o en la imagen siguiente una placa Arduino traen directamente conexión USB, pero Arduino no es de Microchip sino de Atmel*.
Tal como se comenta antes, pasar el programa escrito en C a cualquier microcontrolador no representa dificultad mayor, sin embargo el compilador [que es libre en ambos casos*] y el hardware necesario para grabar el microcontrolador son totalmente distintos.)



<Publicidad>Tal vez hoy en día la placa entrenador más famosa es Arduino, que la pueden comprar hecha, además trae el microcontrolador ya cargado con el bootloader y el software necesario para escribir el programa.</Publicidad>
Placa Arduino UNO

Y eso es todo.

Bueno no todo, si no sabes programar o si no tienes un poco de conocimientos en electrónica, pero para eso esta Internet. 
Actualmente es relativamente fácil aprender la programación y electrónica necesarias para un proyecto específico con un poco de esfuerzo y dedicación. 
En el resto de artículos nos dedicaremos a estos dos temas en referencia a la Impresión 3D. Además se tratará de conceptos de código G y modelado 3D, también necesarios para la impresión 3D.



*Conseguir microcontroladores de Atmel en mi ciudad "Cuenca, Ecuador" no es fácil.
**Arduino es un proyecto de hardware y software libre. Software de compilación para Microchip lo proporciona la misma empresa pero es más largo el desarrollo en comparación de realizarlo con software de pago.