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

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

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

Montaje del Pinguino 18F4550 en protoboard

Este es el esquema de montaje, fue realizado utilizando

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

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

http://www.youtube.com/watch?v=hsiVomOyD2Y&feature=related

Circuito de alimetacion

http://www.youtube.com/watch?v=mW9sxrOZm-M&feature=related

Circuito de RESET

http://www.youtube.com/watch?v=JufE8nvDAcA&feature=related

Memoria de los PIC16

http://www.youtube.com/watch?v=J0zk4elkI9A&feature=related

Puerto del PIC16

http://www.youtube.com/watch?v=SRCk5EiEtkQ&feature=related

Oscilador del PIC16

http://www.youtube.com/watch?v=Yia3dt

Pines de programación

http://www.youtube.com/watch?v=ElI5zh_5pOU&feature=related

Contador de programa del PIC16

http://www.youtube.com/watch?v=qD4-NFEMciE&feature=related

Registro de status PIC16

http://www.youtube.com/watch?v=ffiR2lZg7so&feature=related

EEPROM
http://www.youtube.com/watch?v=HzhXCTNZs0Q&feature=related
Comparador Analogico
http://www.youtube.com/watch?v=voF4JgbrXK8&feature=related
Temporizadores

http://www.youtube.com/watch?v=nGk1UPnF_nM&feature=related

Modulo PWM

http://www.youtube.com/watch?v=oHRcGoES38U&feature=related

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

http://www.youtube.com/watch?v=PmlrflSxWZU&feature=related

Modulo SPI PIC16

http://www.youtube.com/watch?v=P3tSLgdWa-E&feature=related

Comunicacion I2C

http://www.youtube.com/watch?v=tGu5rkrNl7c&feature=related

Memoria del PIC18

http://www.youtube.com/watch?v=TRHWplMNeWw&feature=related

Puertos del los PIC18
http://www.youtube.com/watch?v=Iliq9zjkGxU&feature=related
KOF9w&feature=related
Oscilador PIC18

http://www.youtube.com/watch?v=G-9Lw_wRVS8&feature=related

Registro de STATUS PIC18

http://www.youtube.com/watch?v=ZqRrg8ZUURg&feature=related

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

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

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

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.

guía pinguino processing

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.

http://ubaa.net/shared/processing/pinguino/

Aqui se descarga processing 1.5.1

http://processing.org/download/

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

Pinguino en Campus Party Colombia

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

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;
}

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);
}

Ejemplos básicos de 3D en Processing

Estos son unos ejercicios realizados por los estudiantes de la UNIAJC realizados en unos de los cursos dictados por el profesor victor viera.
Aquí esta el enlace de descarga.
https://sites.google.com/site/camachomedia/home/archivos/processing_3D_PROYECTOS_ESTUDIATES.zip?attredirects=0&d=1

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

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
  }
}

Archivo que se descarga a pinguino para comunicacion con processing

Aqui esta el archivo que se descarga desde el pinguino IDE para que la tarjeta se pueda comunicar con processing.
el archivo es usbprocessing
https://sites.google.com/site/camachomedia/home/archivos/usbprocessing.pde?attredirects=0&d=1

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


}

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); 
 }