sábado, 26 de noviembre de 2011

Brazo robotico con un sistema secuencial



Este es un trabajo realizado implementando un sistema se secuencial con una memoria (AT28C16), no utiliza un sistema microprocesado. Para la interface para computador se utilizo pinguino - processing.
Los motores en este robot son motores paso a paso, que también funcionan utilizando componentes digitales discretos MSI (registros, decodificadores)
este es el enlace del video  http://www.youtube.com/watch?v=OlpbUYW_npU

miércoles, 9 de noviembre de 2011

Motores DC con Pinguino




Montaje básico con un transistor para un motor pequeño de bajo consumo


Montaje utilizando en ULN2003. 


Puente H con el L298 la señal de enable esta conectada a 5V para habilitar permanentemente el motor. Vdd que hace referencia al voltaje de alimentacion del motor también esta a 5V para este ejemplo, en caso de requerir otro voltaje para el motor Vdd se conectara el voltaje requerido.

Aqui el terminal de enable se controla con la señal PWM de pinguino, esto es para manipular la velocidad del motor.

Este montaje corresponde al puente H utilizando los integrados LM386.

Para todos los montajes que corresponden al puente H, el sentido de giro se controla con los terminales 0 y 1 de pinguino.

Código correspondiente a los montaje con el L298 y LM386


void setup(){
 pinMode(0,OUTPUT);
 pinMode(1,OUTPUT);
}
void loop(){
 //giro en un sentido
 digitalWrite(0,HIGH);
 digitalWrite(1,LOW);
 delay(2000);
 //gira en el otro sentido
 digitalWrite(0,LOW);
 digitalWrite(1,HIGH);
 delay(2000);
 //para el giro motor
 digitalWrite(0,LOW);
 digitalWrite(1,LOW);
 delay(2000);
}


LDR con Pinguino


En este montaje se utiliza el terminal 13 de pinguino como entrada analógica para medir la intensidad de luz en el LDR. El potenciometro es de 5K y se utiliza para adecuar el rango de operación.
Se puede reemplazar el potenciometro y la resistencia de 330 por una resistencia de valor fijo ya sea de 5K o 10 sin que esto sea critico para el montaje.

Este montaje proporciona una salida digital, el ldr se configura en modo on - off, es decir enciende o apaga según registre o no luz. El potenciometro es de 5K y sirve para ajustar el rango de operación.
El LM339 es un amplificador operacional en la configuración de comparador de voltaje.

Esta es otra configuración en modo on - off con el cd40106, el potenciometro es de 5k.

Los gráficos se realizaron utilizando
 http://fritzing.org/
 http://inkscape.org/?lang=es

CNY70 con Pinguino



Esta es la conexión modo on - off para el CNY70 como sensor para un robot seguidor de linea. La salida digital se indica como RC0 y también hace referencia al terminal 10 de pinguino, el que sera configurado como entrada digital.

Este es el esquema de montaje, se utiliza el terminal 10 configurado como entrada digital. Se eligió el terminal 10 para poder  probar este montaje desde processing.


Con este gráfico se pueden identificar los terminales del cny70 visto desde arriba
Esta es otra configuración utilizando un LM339 como comparador de voltaje. El potenciometro es de 5K

martes, 6 de septiembre de 2011

Conexión motor paso a paso


Componentes Sin Cableado

Cableado del motor

Cableado de pulsadores

Cableado Display De 7 Segmentos

Robot hexapodo con pinguino


Plataforma Pinguino

Robot hexapodo
Este es un robot hexapodo construido también por estudiantes de la UNIAJC.
El robot esta controlado con la plataforma pinguino, se utilizo un sistema optoacoplado para separar las fuentes de alimentación del microcontrolador y la de los servos.
Aquí dejo el primer vídeo del robot caminando, estamos en proceso de cambiar los servos y de las pruebas de los algoritmos de marcha del robot.
http://www.youtube.com/watch?v=DkLKOvaoAzI

lunes, 29 de agosto de 2011

Robot cartesiano con pinguino


Este es otro de los trabajos realizados por mis estudiantes empleando el sistema pinguino.
Robot Paletizador

En su desarrollo se utilizo equipos reciclados, para el eje Y un scanner, para el eje X una impresora y el Z un floppy.
No utilizamos simuladores, todo se realizo con el montaje real y la programación bajo la versión para Linux de pinguino.
Este es el enlace de un vídeo del sistema en funcionamiento
http://www.youtube.com/watch?v=GUQ07DXiXV4

viernes, 12 de agosto de 2011

Videos explicativos sobre microcontroladores

Enlaces de videos sobre microcontroladores, muy buenos para explicar los principios basicos de funcionamiento.
Serie clases en DVD
Que es un microcontrolador
http://www.youtube.com/watch?v=lkJBOZkawF0&feature=related
Los microcontroladores PIC
http://www.youtube.com/watch?v=waUvm-3Ctjs&feature=related
Arquitectura del los pic de 8 bits
Circuito de alimetacion
Circuito de RESET
Memoria de los PIC16
Puerto del PIC16
Oscilador del PIC16
Pines de programación
Contador de programa del PIC16
Registro de status PIC16
EEPROM
http://www.youtube.com/watch?v=HzhXCTNZs0Q&feature=related
Comparador Analogico
http://www.youtube.com/watch?v=voF4JgbrXK8&feature=related
Temporizadores
Modulo PWM
Modulo CCP
http://www.youtube.com/watch?v=aZXo3j0JjoM&feature=related
Modulo CCP en modo comparador
 http://www.youtube.com/watch?v=p4mlY-uoUY8&feature=related
USART
Modulo SPI PIC16
Comunicacion I2C
Memoria del PIC18
Puertos del los PIC18
http://www.youtube.com/watch?v=Iliq9zjkGxU&feature=related
KOF9w&feature=related
Oscilador PIC18
Registro de STATUS PIC18
Encender un led
http://www.youtube.com/watch?v=Q7lTuLlt1qc&feature=related
Practica pulsador
http://www.youtube.com/watch?v=RNN2sDzI4J0&feature=related
Practica contador
http://www.youtube.com/watch?v=3aCq20ZWc2M&feature=related
Aquí esta otra serie de vídeos explicativos
Parte 1
http://www.youtube.com/watch?v=Q_CqOmeiyZk&feature=related
Parte 2
http://www.youtube.com/watch?v=JnsCGtLdKFA&feature=related
Parte 3
http://www.youtube.com/watch?v=fUjBNoEPIrs&feature=related

martes, 9 de agosto de 2011

Herramientas para elaboración de diagramas de flujo.

Este es el enlace para DIA, una herramienta para hacer todo tipo de diagramas, entre ellos los diagramas de flujo.
Pagina Principal http://projects.gnome.org/dia/
Descarga de la versión portable http://portableapps.com/apps/office/dia_portable

Este es el enlace de para DFD una herramienta para aprender a programar utilizando diagramas de flujo.
Descarga http://freedfd.googlecode.com/files/FreeDFD-1.1.zip
Pagina principal http://wiki.freaks-unidos.net/freedfd/index
Vídeos tutoriales de DFD
http://www.youtube.com/watch?v=3o0h0TEtV5g
http://www.youtube.com/watch?v=xSVN-sgsXUU&feature=related
http://www.youtube.com/watch?v=tNOw86vkKyE&feature=related
http://www.youtube.com/watch?v=b7kgCYsS60E&feature=related

Este es el enlace para PSEINT, una herramienta para enseñar a programa empleando seudocodigo y diagramas de flujo. Recién salio una nueva versión.
Pagina principal http://pseint.sourceforge.net/
Descarga http://prdownloads.sourceforge.net/pseint/pseint-w32-20110801.exe?download
Videos sobre Pseint http://www.youtube.com/results?search_query=pseint&aq=f

viernes, 22 de julio de 2011

Vídeo presentación de pinguino en campus party y robot

Presentación en Campus Party
Este es el enlace de nuestra presentación de pinguino processing en campus party, al inicio no muestra nada (sera editarlo....)
http://www.youtube.com/watch?v=qlx2wjfIVRQ&list=UUE9YxBI-jzbs&index=468

Aquí dejo el enlace del robot que realizo el estudiante Duvan Acosta, este se mostró durante la charla sobre pinguino y processing que realizamos en campus party.
http://www.youtube.com/watch?v=njbBypdA7KI

miércoles, 22 de junio de 2011

Guía Y Ejemplos de Pinguino Con Processing 1.5.1


Tarjeta para pruebas con pinguino y processing
Este es el enlace para descargar la guía.



Este es el programa que se descarga en pinguino.
https://sites.google.com/site/camachomedia/home/archivos/usbprocessing.pde?attredirects=0&d=1

Esta es la librería para processing.
https://sites.google.com/site/camachomedia/home/archivos/pinguino.zip?attredirects=0&d=1
para la nueva versión de processing se pega y descomprime dentro de la carpeta sketchbook/libraries/
en caso de no existir la carpeta libraries, se crea y allí se descomprime la librería pinguino.


Este es el enlace del creador de la librería que comunica pinguino con processing.

Aqui se descarga processing 1.5.1

martes, 21 de junio de 2011

Banda transportadora


Esta es una proyecto de una banda transportadora utilizando una maquina de estados implementada en una memoria y empleando pinguino y processing para indicar los procesos en el PC.
Realizado por los estudiantes:
DEIVY ROSERO
JOSE A. MOSQUERA
Aqui esta el enlace del video donde se muestra su funcionamiento.
http://www.youtube.com/watch?v=BCrqw15OmVM

Robot seguidor de linea con pinguino


Este es un robot seguidor de linea, realizado con pinguino.

Fue realizado por los estudiantes:
JESÚS HERNAN CANCIMANSE FAJARDO 
OSCAR CIFUENTES
MARCOS RIASCOS
de la UNIAJC http://www.uniajc.edu.co/
Aqui esta el enlace del video donde se muestra su funcionamiento. 
http://www.youtube.com/watch?v=xawdLUsFAl8

lunes, 20 de junio de 2011

Pinguino en Campus Party Colombia

Ya esta confirmada la pequeña charla demostrativa que haremos en el barcamp de campus party colombia.

domingo, 19 de junio de 2011

Otra forma de acceder a los terminales en PINGUINO

Buscando varias formas de acceder a los puertos, encontré la siguiente publicación en la que se accede al terminal donde esta conectado el led de RUN, para hacerlo encender y apagar cada 250 ms
http://pinguino.walii.es/?p=106

Ejemplo1
En este ejemplo se hará encender y apagar el led de RUN cada segundo, se puede ver que este led esta el bit 4 del Puerto A. En este caso el terminal ya esta configurado por defecto como salida, por eso no se configuro en el void setup()

//Julio Fabio De La Cruz G. 2011
//Acceder a los terminales de los puertos
//Encender y apagar el led de RUN
void setup(){
 }
void loop(){
  //Enciendo el LED
  PORTAbits.RA4=1;
  delay(1000);
  //Apago el LED
  PORTAbits.RA4=0;
  delay(1000);
}

Ejemplo2
Otro ejemplo con el Puerto B, en este caso se configura el Puerto B con sus 4 bits menos significativos como entradas y los 4 mas significativos como salidas. Los 4 bits menos significativos leídos son escritos en los 4 mas significativos del Puerto B.
TRISB = 00001111 binario
TRISB = 0x0F         Hexadecimal

//Julio Fabio De La Cruz G. 2011
//Acceder a los terminales de los puertos
//Acceder al Puerto B
uchar b0,b1,b2,b3;
void setup(){
   TRISB=0x0F;
}
void loop(){
  //Leo Datos
  b0=PORTBbits.RB0;
  b1=PORTBbits.RB1;
  b2=PORTBbits.RB2;
  b3=PORTBbits.RB3;
  //Escribo datos
  PORTBbits.RB4=b0;
  PORTBbits.RB5=b1;
  PORTBbits.RB6=b2;
  PORTBbits.RB7=b3;
}

viernes, 17 de junio de 2011

Leer y escribir directamente en los puertos del PIC en Pinguino

Se puede utilizar los registros de configuración de puertos para configurar los terminales de los puertos ya sea como entradas o salidas, en los PIC estos registros son los TRIS, donde un 0 representa una salida y un 1 una configuración como entrada.
Correspondencia entre puertos y terminales
Por ejemplo si quiero configurar los primeros 4 bits del puerto B como salida y los 4 últimos bits del puerto B como entradas hariamos lo siguiente:
TRISB = 11110000  Binario
TRISB = 0xF0          Hexadecimal
TRISB = 240            Decimal

Para escribir los datos en el puerto utilizamos los registros PORT, como ejemplo si el puerto B esta configurado como salida y queremos colocarlo todo en alto haríamos lo siguiente.
PORTB = 11111111  Binario
PORTB = 0xFF          Hexadecimal
PORTB = 255            Decimal

//Julio Fabio De La Cruz 2011
//Escritura de datos en el registro PORTB
void setup(){
   //configuro puerto B como salida
   TRISB=0x00;
}
void loop(){
   //Coloco en alto todos los terminales del puerto B
   PORTB=0xFF;
   delay(1000);
   //Coloco en bajo todos los terminales del puerto B
   PORTB=0x00;
   delay(1000);
}

domingo, 5 de junio de 2011

viernes, 3 de junio de 2011

Mas sobre la funcion Millis en pinguino

Aquí esta el enlace que hace referencia a los tipos de datos utilizados en pinguino.
http://wiki.pinguino.cc/index.php/Data_types
Para ver la función en detalle esta es la ruta donde se encuentra el archivo millis.c






Aquí esta el código de la función, lo interesante esta en que se puede modificar el prescaldor y obtener otras unidades de tiempo. Para esto podemos modificar el registro T0CON


// millis library for pinguino
// Jean-Pierre MANDON 2009
#ifndef __MILLIS__
#define __MILLIS__
#define MILLIS 1
long _millis;
void millis_init(void)
{
T0CON=0x80; // TMR0 on, 16 bits counter, prescaler=2
INTCON|=0xA0; // set GIE and TMR0IE
_millis=0;
}
long Millis()
{
return(_millis);
}
#endif

jueves, 26 de mayo de 2011

La función millis en pinguino

Esta función puede ser muy útil para el manejo de tiempo. Tambien para generar señales digitales en función del tiempo como modulación de ancho de pulso.
el siguiente es el enlace la fuente consultada.
http://wiki.pinguino.cc/index.php/Millis
Explicación
millis - retorna el tiempo trancurrido desde que inicia el programa. 
Cuando el programa comienza el timer interno TMR0 es inicializado en 0. TMR0 es un registro de 16 bits que se incrementa en uno cada milisegundo. Al ser de 16 bits llega a overflow despues de incrementarse cada milisegundo hasta 65536 lo que corresponde a 65.536 segundos. Como funcion millis() retorna el valor actual de TMR0.
Declaración
El valor que retorna es de tipo long (32bits). reinicia a 0 al llegar a 65536 

millis();
Instrucción para reiniciar la cuenta de la funcion

_millis = 0;
Ejemplo

void setup(){
   pinMode(0,OUTPUT);
   digitalWrite(0,LOW);
 }
void loop(){
   if (millis()>1000) {
     digitalWrite(0,HIGH); // enciende el led por un segundo
  }
  if (millis()>2000){
     _millis=0; // reinicia el contador despues de dos segundos
    digitalWrite(0,LOW); // Apaga el led
  }

}

domingo, 22 de mayo de 2011

Graficación de funciones y animaciones básicas en processing

Estos son ejemplos de como graficar funciones matemáticas con processing, como hacer animaciones básicas y como cargar imágenes
Aquí pueden descargar los archivos
https://sites.google.com/site/camachomedia/home/archivos/claseprocessingciclos.zip?attredirects=0&d=1

Ejemplo programa para encuesta en pseint

Este es un ejemplo para la realización de una encuesta para saber el grado de satisfacción de un producto.
El programa emplea el uso del ciclo para y condicionales.
este es el enlace de descarga
https://sites.google.com/site/camachomedia/home/archivos/menu02.psc?attredirects=0&d=1

Procesamiento de imágenes en processing

El profesor Carlos Lino manda unos ejemplos en processing para hacer una introducción al procesamiento digital de imágenes.
Aquí esta el enlace para la descarga de los archivos
https://sites.google.com/site/camachomedia/home/archivos/procesamientodeimgenesenprocessing.zip?attredirects=0&d=1

Plantilla en Processing para sistemas secuenciales con diagramas de estado

Esta es una plantilla para programar un sistema secuencial con processing utilizando pinguino y processing.
con pinguino obtengo las estradas digitales para generar las transiciones entre estados y a su vez generar las salidas digitales que controlan el proceso.
La plantilla esta realizada para 4 estados y dos entradas digitales.
Las salidas y los cambios de estado se realizan sengun el problema


/*=========================================================================
  Librerias
     import hypermedia.pinguino.*;
        Llamo la libreria para trabajar con la plataforma pinguino
     Pinguino pinguino;
        Creo el objeto pinguino
  Variables
===========================================================================*/
import hypermedia.pinguino.*;
Pinguino pinguino;
/*=========================================================================*/
//variable que monitorea los estados
int nEstado;
//los nombres de los estados
int nEstadoA,nEstadoB,nEstadoC,nEstadoD;
//las entradas
int nSensor0,nSensor1,nSensor2,nSensor3,nSensor4;
// variables donde se guardan los bits capturados
int bit0,bit1,bit2,bit3,bit4;
void setup(){
  size(400,200);
  Pinguino.log( true );              
  pinguino = new Pinguino( this );
  //Doy valores para identificar los estados
  nEstadoA=0;
  nEstadoB=1;
  nEstadoC=2;
  nEstadoD=3;
  //Indico los terminales de pinguino como entradas digitales
  //los terminales 8,9,10,11,12 de pinguino
  nSensor0=8;
  nSensor1=9;
  nSensor2=10;
  nSensor3=11;
  nSensor4=12;
  //Inicio en el estado A
  nEstado=nEstadoA;
}
void draw(){
   //leo las entradas digitales
   bit0 = pinguino.digitalRead(nSensor0);
   bit1 = pinguino.digitalRead(nSensor1);
   bit2 = pinguino.digitalRead(nSensor2);
   bit3 = pinguino.digitalRead(nSensor3);
   bit4 = pinguino.digitalRead(nSensor4);
   //obtengo el valor digital equivalente de las entradas digitales
   dato = bit4*16 + bit3*8 + bit3*2 + bit1*2 + bit0;
   println("Dato de entrada es " + dato);


  //verifico si esta en el estado A
  if (nEstado==nEstadoA){
    //verifico las condiciones para las entradas que ocasionan cambio
    //de estado como ejemplo se tiene los valores de entrada 0,1,2,3
    //para evaluar solo dos sensores, el sensor0 y el sensor1
    println("Estado A");
    if(dato==0){


    }
    if(dato==1){


    }
    if(dato==2){


    }
    if(dato==3){


    }
  }//fin del estado A


  //verifico si esta en el estado B  
  if (nEstado==nEstadoB){
    println("Estado B");
    if(dato==0){


    }
    if(dato==1){


    }
    if(dato==2){


    }
    if(dato==3){


    }
  }//fin del estado B


  //verifico si esta en el estado C  
  if (nEstado==nEstadoC){
    println("Estado C");
    if(dato==0){


    }
    if(dato==1){


    }
    if(dato==2){


    }
    if(dato==3){


    }
  }//fin del estado C


  //verifico si esta en el estado D  
  if (nEstado==nEstadoD){
    println("Estado D");
    if(dato==0){


    }
    if(dato==1){


    }
    if(dato==2){


    }
    if(dato==3){


    }
  }//fin del estado D


}

sábado, 21 de mayo de 2011

Obtener el equivalente digital de varias entradas análogas

Podemos utilizar varias entradas análogas como binarias y obtener el dato digital equivalente a estas entradas.



/*************************************************************************
*Manejo de la plataforma pinguino                                        * 
*Autor:                                                             *
*           Julio Fabio De La Cruz Gomez                                 *
*                                                                        *
*Ejemplo 013: Entradas Digitales y analogas                              *
*                                                                        *
*Descripcion:                                                            *
*            Como utilizar las entradas analogas como digitales          *
*            y obtener el equivalente decimal                            *
**************************************************************************/


import hypermedia.pinguino.*;
Pinguino pinguino;


int an0,an1,an2,an3,an4,an5,an6,an7;
int bit0,bit1,bit2,bit3,bit4,bit5,bit6,bit7;
int dato;
void setup(){
    Pinguino.log( true );              
    pinguino = new Pinguino( this );  
}
/*=========================================================================
  Ciclo principal
        Los terminales configurados como entradas analogas son 13,14,15,16,
        17,18,19,20
        El ADC es de 10 bits asi que los valores leidos van de 0 - 1023
        Los valores de voltaje van de 0v - 5v
        Un 1 Logico corresponde aproximadamente a 5V
        Un 0 Logico corresponde aproximadamente a 0v
        Un valor leido mayor a 700 corresponderia a un 1 logico, de lo
        contrario en un 0 logico.
 ===========================================================================*/
 void draw(){
  an0=pinguino.analogRead(13);
  an1=pinguino.analogRead(14);
  an2=pinguino.analogRead(15);
  an3=pinguino.analogRead(16);
  an4=pinguino.analogRead(17);
  an5=pinguino.analogRead(19);
  an6=pinguino.analogRead(19);
  an7=pinguino.analogRead(20);
  // Obtengo el bit 0  
  if(an0 > 700)
    bit0 = 1;
  else
    bit0 = 0;
  // Obtengo el bit 1     
   if(an1 > 700)
    bit1 = 1;
  else
    bit1 = 0;
  // Obtengo el bit 2     
  if(an2 > 700)
    bit2 = 1;
  else
    bit2 = 0;
  // Obtengo el bit 3     
   if(an3 > 700)
    bit3 = 1;
  else
    bit3 = 0;
  // Obtengo el bit 4     
  if(an4 > 700)
    bit4 = 1;
  else
    bit4 = 0;
  // Obtengo el bit 5     
   if(an5 > 700)
    bit5 = 1;
  else
    bit5 = 0;
  // Obtengo el bit 6     
  if(an6 > 700)
    bit6 = 1;
  else
    bit6 = 0;
  // Obtengo el bit 7     
   if(an7 > 700)
    bit7 = 1;
  else
    bit7 = 0;
   //obtengo el equivalente decimal de los datos leidos 
   dato = bit4*16 + bit3*8 + bit3*2 + bit1*2 + bit0; 
   println("Dato = " + dato); 
 }

Como utilizar las entradas análogas como digitales

Con la libreria diseñada para operar a pinguino desde processing se obtienen valores analogos pero tambien puede ser necesario que necesitemos mas entradas digitales, asi que se pueden utilizar estas entradas y obtener el dato digital de entrada.

/*************************************************************************
*Manejo de la plataforma pinguino                                        * 
*Autor:                                                               *
*           Julio Fabio De La Cruz Gomez                                 *
*                                                                        *
*Ejemplo 012: Entradas Digitales y analogas                              *
*                                                                        *
*Descripcion:                                                            *
*            Como utilizar las entradas analogas como digitales          *
**************************************************************************/

import hypermedia.pinguino.*;
Pinguino pinguino;

int an0;
int bit0;
void setup(){
    Pinguino.log( true );              
    pinguino = new Pinguino( this );  
}
/*=========================================================================
  Ciclo principal
        Los terminales configurados como entradas analogas son 13,14,15,16,
        17,18,19,20
        El ADC es de 10 bits asi que los valores leidos van de 0 - 1023
        Los valores de voltaje van de 0v - 5v
        Un 1 Logico corresponde aproximadamente a 5V
        Un 0 Logico corresponde aproximadamente a 0v
        Un valor leido mayor a 700 corresponderia a un 1 logico, de lo
        contrario en un 0 logico.
 ===========================================================================*/
 void draw(){
  an0=pinguino.analogRead(13);
  // Obtengo el equivalente bianario segun la entrada analoga  
  if(an0 > 700)
    bit0 = 1;
  else
    bit0 = 0;
  println("El equivalente binario es: " + bit0);

 }