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

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

 }

Como convertir la entradas digitales a su equivalente decimal

Con la libreria diseñada para operar a pinguino desde processing se obtienen los valores digitales uno a la vez,
pero quizá sea útil en la aplicación obtener el dato equivalente de las entradas digitales, en este ejemplo se toman las entradas digitales y se obtiene su equivalente en decimal.

 /*************************************************************************

*Manejo de la plataforma pinguino                                        * 

*Autor:                                                             *

*           Julio Fabio De La Cruz Gomez                                 *

*                                                                        *

*Ejemplo 011: Entradas Digitales                                         *

*                                                                        *

*Descripcion:                                                            *

*            Convertir las entradas digitales en su equivalente decimal  *

**************************************************************************/

import hypermedia.pinguino.*;

Pinguino pinguino;

int bit0,bit1,bit2,bit3,bit4;

int dato;

void setup(){

    Pinguino.log( true );              

    pinguino = new Pinguino( this );  

}

/*=========================================================================

  Ciclo principal

        Los terminales configurados como entradas digitales son 8,9,10,11,12

        Para obtener el dato digital sumo las multiplicaciones del dato

        digital leido por su correspondiente potencia de 2

        la relacion que convierte el dato binario a su equivalente decimal es:

        dato = bit4*16 + bit3*8 + bit3*2 + bit1*2 + bit0;

 ===========================================================================*/

 void draw(){

   bit0 = pinguino.digitalRead(8);

   bit1 = pinguino.digitalRead(9);

   bit2 = pinguino.digitalRead(10);

   bit3 = pinguino.digitalRead(11);

   bit4 = pinguino.digitalRead(12);

   dato = bit4*16 + bit3*8 + bit3*2 + bit1*2 + bit0;

   println("Dato = " + dato); 

 }

Torres de Hanoi en processing

Aquí dejo la solución que envía el profesor Carlos Lino del problema de la torres de hanoi en processing, es un muy buen ejemplo de la utilización de matrices y recursividad.
https://sites.google.com/site/camachomedia/home/archivos/hanoigrafico.zip?attredirects=0&d=1

Para mas información sobre el problema de las torres de hanoi dejo estos enlaces.
http://es.wikipedia.org/wiki/Torres_de_Han%C3%B3i
http://www.aulademate.com/contentid-99.html
http://www.psicoactiva.com/juegos/hanoi/jg_hanoi.htm
http://www.uterra.com/juegos/torre_hanoi.htm

Proyectos con pinguino para campus

Robot de Duvan

Robot de Duvan

Robot de Alejandra

Estos son los prototipos ya funcionales que presentaron los estudiantes de tecnología en mecatronica de la UNIAJC.

Alejandra Forero presento un brazo robotico que utiliza servo motores que controla desde la tarjeta pinguino, esta en proceso su interfase con Lazarus para controlarlo desde el PC.

Duvan Acosta presento un robot inspirado en los robots de theo jansen, esta en proceso la parte de implementación de diversos sensores y la comunicación con el PC.

Para referencia de los robots de theo jansen aquí dejo algunos enlaces.

http://es.wikipedia.org/wiki/Theo_Jansen

http://www.youtube.com/watch?v=38iyEttxc44

http://www.youtube.com/watch?v=4ZK4V2YUA5U

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

Utilización de la memoria 28c16 para sistemas secuenciales

Esquema con flipflop

Diagrama flip flop

Diagrama de terminales 28c16

Enlace para descargar el datasheet
https://sites.google.com/site/camachomedia/home/archivos/28c16.pdf?attredirects=0&d=1
Vídeo de ejemplo de direccionamiento de la memoria con un microcontrolador
http://www.youtube.com/watch?v=J-q2yECfhj0
Esta es una hoja de calculo que realice para que puedan ingresar los datos en la memoria, tiene la ventaja que pueden ingresar el dato en formato binario y obtener el equivalente en hexadecimal, el formato esta tal como lo muestra el programador.
https://sites.google.com/site/camachomedia/home/archivos/mapamemoria.xls?attredirects=0&d=1

Modulación de ancho de pulso

Aquí dejo unos vídeos complementarios sobre el tema de modulación de ancho de pulso.
http://www.youtube.com/watch?v=YmPziPfaByw
Este es un vídeo sobre PWM en arduino, pero las mismas instrucciones aplican a pinguino
http://www.youtube.com/watch?v=sNsAIAXtLK0

Guia para soldar la tarjeta

Colocar y soldar componentes

Soldar conector

Soldar base para el integrado

Colocar integrado

El cuarzo debe ser del pequeño, pues el otro no por ser tan alto no permite colocar el integrado, tambien sirve el cuarzo que es mas pequeño, solo que solda inclinandolo, para que quede de lado y no moleste su altura.
En el led el catodo es el terminal corto.
El conector USB es hembra y se conecta al computador utilizando una extensión macho - macho USB 

Control PID De Posición Análogo

En este enlace se puede encontrar la explicación de este sistema didáctico de control de posición de un motor, este esquema aplica también a otros procesos a controlar.
http://www.automatas.org/hardware/teoria_pid.htm