cheat sheet para pinguino pic


Pues navegando por ahí me he encontrado con unas cheat sheet (hojas de ayuda de código) para Pinguino Pic, muy parecidas a la que he posteado anteriormete sobre Arduino en este blog. Espero que os sirva de ayuda para vuestros proyectos.

Estas Cheat Sheet han sido diseñadas por la gente de www.pinguino.org.ve, gracias al proyecto PinguinoVE.

Cheat Sheet en A4:


Cheat Sheet en Formato Cubo:


Y aquí os dejo el enlace para descargar las cheat sheet tanto en pdf como en formato svg:

http://www.mediafire.com/?vs6d6cw1zb39sci

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

pinguino pic y processing el comienzo


Estoy empezando a aprender a utilizar processing, para poder realizar aplicaciones para el Pinguino PIC, así que en esta entrada explicaré una aplicación que he modificado y he ido comentando para poder entenderla mucho mejor para los que como yo estan empezando en esto de unir Pinguino PIC con Processing.

Empiezo contando un poco lo que es processing:

Processing es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java, de fácil utilización, y que sirve como medio para la enseñanza y producción de proyectos multimedia e interactivos de diseño digital. Fue iniciado por Ben Fry y Casey Reas a partir de reflexiones en el Aesthetics and Computation Group del MIT Media Lab diriguido por John Maeda.

Processing es desarrollado por artistas y diseñadores como una herramienta alternativa al software propietario. Puede ser utilizado tanto para aplicaciones locales así como aplicaciones para la web (Applets).

Se distribuye bajo la licencia GNU GPL. Además al estar basado en Java, puede heredar todas sus funcionalidades, convirtiéndose en una herramienta poderosa a la hora de encarar proyectos complejos.

Aquí podeis ver que el IDE de Processing es similar al de Arduino y al de Pinguino PIC:

La programación es bastante sencilla en un principio y bastante fácil de entender, de momento lo que he mirado ha sido así, según vaya aprendiendo más iré contando mis experiencias. Ahora os muestro un ejemplo para comunicar el Pinguino PIC mediante USB y una aplicación en Processing (es una modificación de una aplicación realizada por http://pinguino.walii.es).

Este es la aplicación gráfica realizada en Processing:

Gracias a esta aplicación podemos controlar tanto las entradas digitales y analógicas como las salidas digitales mediante el USB del Pinguino PIC, en una descripción breve lo que se puede hacer es lo siguiente:

  • Activar o desactivar las salidas digitales (‘1’o ‘0’) mediante los cuadrados rojos pulsando con el ratón sobre ellos.
  • Activar o desactivar las salidas digitales (‘1’o ‘0’) mediante las teclas correspondientes del teclado del ordenador ‘0’ a ‘9’.
  • Visualización de los cambios de las entradas digitales (’10’, ’11’ y ’12’) , activadas mediante pulsadores en la protoboard.
  • Visualización de las entradas analógicas, en mi caso 2 de ellas modificables mediante potenciometro y la otra mediante una ldr.

Os dejo el video de funcionamiento:

Aquí os dejo los archivos de la aplicación y del programa para el Pinguino PIC:

http://www.mediafire.com/?dvtujt6i4gsr66e

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

SHIELD TECLADO V1.1 PARA ARDUINO CON 1 PIN


He estado mejorando la shield del teclado para el Arduino, añadiendo un condensador de 100nF para mejorar las lecturas del pin de salida que va conectado al pin A0. Os pongo unas imagenes realizadas con el Eagle3D y un ejemplo de código para que veais como funciona, además os subo el esquemático, la pcb y el fotolito.

Esquemático de la Teclado Shield v1.1:

La imagen 3D realizada con Eagle3D:


Un ejemplo para utilizar el teclado con la placa Arduino:

/*Programa realizado para tallerarduino.wordpress.com por Javier Couto Rego (Regata) para
apertura de puerta mediante password de 4 digitos*/

/*
 El circuito:
 * LCD RS pin a pin digital 12
 * LCD Enable pin a pin digital 11
 * LCD D4 pin a pin digital 5
 * LCD D5 pin a pin digital 4
 * LCD D6 pin a pin digital 3
 * LCD D7 pin a pin digital 2
 * LCD R/W pin a masa
 * Potenciometro de 10K:
 * patilla a +5V y la otra a masa
 * Patilla central al pin LCD VO (pin 3 del LCD)
*/
//
#include <LiquidCrystal.h>

// Indicamos los pines a los que tenemos conectado el lcd
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//Indicamos los pines donde tenemos conectados los actuadores
int buzzer = 6;  //En el pin 6 tenemos un buzzer
int puerta = 1;  //En el pin 1 conectamos la salida para un relé 
int errores=0;   //Variables para comprobar si hay errores
int error=0;
int i;
//Arrays donde guardamos el pass y un pass por si bloqueamos el
//circuito por pasarnos de intentos
int pass[4] = {1,2,3,4};
int desbloqueo[4] = {4,3,2,1};
int password[4];
//Variable donde guardaremos el valor que nos devuelva la función de lectura de tecla
int tecla=0;

void setup() {
  // Indicamos numero de columnas y filas del LCD e iniciamos
  lcd.begin(20, 4);
  lcd.setCursor(0,0);
  //Mostramos en pantalla el mensaje Password:
  lcd.print("Password:");
  //Indicamos como salidas el relé y el buzzer (pines 1 y 6)
  pinMode(1,OUTPUT);
  pinMode(6,OUTPUT); 
}

void loop() 
{
  //Comprobamos si se han producir 3 intentos errores de introduccion de pass
  if (errores<3)
  {
      //Posicionamos el cursor en el LCD
      lcd.setCursor(8,1);
      for(i=0;i<4;i++) //Pass para cuatro caracteres
      {
         tecla=teclado();  //asiganmos a tecla el valor que nos devuelve la función teclado()
         if (tecla>=0 && tecla<=9) //Comprobamos que el valor de las teclas esten comprendidas entre 1 y 9
                                   //para evitar introducir letras
         {
           password[i] = tecla;  //En la posición correspondiente del array guardamos el valor introducido
           lcd.print("*");      //En pantalla mostramos un * para evitar que vean el código
           delay(20);          //retardo de 20mseg
         }
         else    //Si introducimos un valor que no este entre 1 y 9 restamos 1 a i, esto es para volver a
                 //introducir el caracter en esa posicion otra vez
         {
           i=i-1;
         }       
      }
      //En este bucle comprobamos que la contraseña que hemos introducido coincida con la que teniamos configurada
      for(i=0;i<4;i++)
      {
         if (pass[i]!=password[i]) //Se comprueba caracter a caracter y si no coinciden
         {
            i = 4;  //Asignamos a i 4 para salir del bucle for
            error = 1;  //Indicamos que hay error
            errores = errores + 1;  //Sumamos 1 intento a errores
         }
       }
       if (error==0)  //Si no hubiera error
       {
         //Mostrariamos en pantalla Pantalla Password: Done
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("Password:");
          lcd.setCursor(8,1);
          lcd.print("Done");
          //Activamos las salidas de buzzer y rele durante 500 mseg
          digitalWrite(buzzer,HIGH);
          digitalWrite(puerta,HIGH);
          delay(500);
          //Desactivamos las salidas de buzzer y rele
          digitalWrite(buzzer,LOW);
          digitalWrite(puerta,LOW);
          //Limpiamos el LCD y mostramos Password:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("Password:");
          lcd.setCursor(8,1);
       }
       else //Si hay error
       {
          //Mostramos ERROR en pantalla durante 50 mseg
          lcd.setCursor(8,1);
          lcd.print("ERROR");
          delay(50);
          //Borramos pantalla y mostramos Password:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("Password:");
          lcd.setCursor(8,1);       
       }
  }
  //Si se producen 3 intentos erroneos de introducir clave
  else
  {
      //Mostramos en pantalla BLOQUEADO
      lcd.setCursor(6,1);
      lcd.print("BLOQUEADO");
      lcd.setCursor(8,2);
      //Bucle donde introducimos el pass para DESBLOQUEAR el sistema
      for(i=0;i<4;i++)
      {
         tecla=teclado();  //asiganmos a tecla el valor que nos devuelve la función teclado()
         if (tecla>=0 && tecla<=9)  //Comprobamos que el valor de las teclas esten comprendidas entre 1 y 9
                                   //para evitar introducir letras
         {
           password[i] = tecla;  //En la posición correspondiente del array guardamos el valor introducido
           lcd.print("*");      //En pantalla mostramos un * para evitar que vean el código
           delay(20);          //retardo de 20mseg
         }
         else     //Si introducimos un valor que no este entre 1 y 9 restamos 1 a i, esto es para volver a
                 //introducir el caracter en esa posicion otra vez
         {
           i=i-1;
         }       
      }
      //En este bucle comprobamos que la contraseña que hemos introducido coincida con la que teniamos configurada
      for(i=0;i<4;i++)
      {
         if (desbloqueo[i]!=password[i])  //Se comprueba caracter a caracter y si no coinciden
         {
            i = 4;  //Asignamos a i 4 para salir del bucle for
            error=1;  //Indicamos que hay error
         }
         else
         {
             error=0; //Indicamos que no hay error en ese caracter
         }
       }
       //Si no hubiera error
       if (error==0)
       {
         //Reiniciamos el contador de intentos
          errores=0;
          //Mostramos por pantalla DESBLOQUEADO durante 50mseg
          lcd.clear();
          lcd.setCursor(4,1);
          lcd.print("Desbloqueado");
          delay(50);
          //Limpiamos el LCD y mostramos por pantalla Password:
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("Password:");
          lcd.setCursor(8,1);
       }
       //Si hay error
       else
       {  
         //Mostramos en pantalla Password: para seguir introduciendo pass de desbloqueo
          lcd.clear();
          lcd.setCursor(0,0);
          lcd.print("Password:");
          lcd.setCursor(8,2);
       }         
  }
}

//Funcion que devuelve la tecla pulsada
int teclado()
{
    int tecla;
    int valoradc=analogRead(5);  //Leemos el pin analogico 5 del arduino
                                //donde tenemos conectado el teclado de 1 pin
    switch (valoradc)  //Según el valor que nos da la lectura asignamos una tecla
    {
      case 865: return 7;  //Devuelve tecla 7
        break;
      case 650: return 8;  //Devuelve tecla 8
        break;
      case 508: return 9;  //Devuelve tecla 9
        break;
      case 339: return 10;  //Devuelve tecla 10
        break;
      case 803: return 4;  //Devuelve tecla 4
        break;
      case 614: return 5;  //Devuelve tecla 5
        break;
      case 486: return 6;  //Devuelve tecla 6
        break;
      case 329: return 11;  //Devuelve tecla 11
        break;
      case 735: return 1;  //Devuelve tecla 1
        break;
      case 574: return 2;  //Devuelve tecla 2
        break;
      case 460: return 3;  //Devuelve tecla 3
        break;
      case 317: return 12;  //Devuelve tecla 12
        break;
      case 698: return 14;  //Devuelve tecla 14
        break;
      case 551: return 0;  //Devuelve tecla 0
        break;
      case 445: return 15;  //Devuelve tecla 15
        break;
      case 310: return 13;  //Devuelve tecla 13
        break;
      default: return 16;  //Devuelve tecla 16
    }
}

Y aquí os dejo los archivos de la Teclado Shield v1.1: http://www.mediafire.com/?xk8ake4e1x5gbd4
Espero que os sirva esta Shield.

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Mi placa pinguino pic


Como dije en el anterior post os enseño la placa Pinguino PIC que he montado, se trata de una versión realizada por los chicos de la asociación de robotica y domotica de España, cuya web es: http://foro.webdearde.com/

Esta versión con respecto a la original tiene de distinto que solo trae un pulsador de reset, en lugar de los dos pulsadores para reset y run que traía la placa original. Por tanto una vez presionado el pulsdor tras 5 segundos arranca de nuevo el programa.

Lo bueno de esta placa es que se le puede instalar un bootloader que permite grabar el programa en el PIC sin necesidad de un grabador externo (solo se necesita una única vez para cargar el bootloader en el PIC, yo uso el Pickit 2 de Microchip).

En próximos post iré explicando el uso y mis experimentos con el software libre Processing para comunicación con el Pinguino PIC desde el PC mediante USB, de momento he estado practicando con como encender y apagar leds, desde el pc con el ratón, pulsando teclas determinadas del teclado, así como lectura de puertos analógicos, lectura de pulsadores, etc. Según vaya realizando cosas las iré posteando por aquí.

Aquí os dejo el enlace a los archivos necesarios para montaros la placa Pinguino PIC: http://www.mediafire.com/?hn6ejh2gth8u5ln

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

PINGUINO PIC


En busca  de un sistema con el que desarrollar mis proyectos de una forma económico me he topado por la web con este gran proyecto que se llama Pinguino Pic. En que consiste Pinguino pic, pues basicamente en esto:

Pinguino es una placa similar a la placa Arduino pero basado en un microcontrolador PIC. El objetivo de este proyecto es construir un entorno de desarrollo integrado de fácil uso en Linux, Windows y Mac OS X. Partiendo de que Arduino es una poderosa herramienta con unos valores predeterminados, uno de sus inconvenientes es el de tener una interfaz USB no nativa en el chip, y debido a esto un código muy extenso para realizar la comunicación. Pues con Pinguino PIC esto no es así porque trae USB nativo ya que se construye en base a los PIC18F2455/18F2550 en formato 28 pines y en los PIC18F4455/18F4550, además presenta una UART para conexión serie.

El IDE de Pinguino se construye con Python y es muy similar al de Arduino. Decir también que es totalmente compatible con el código de Arduino y con la mayoria de sus librerias. En el IDE un preprocesador integrado traduce las instrucciones especifícas de Arduino directamente a C. Este preprocesador reduce la longitud del código y la velocidad de ejecución.

Por último, el IDE Pinguino es una aplicación independiente con un compilador de C (SDCC), ensamblador, enlazador (gputils) y un gestor de arranque basado el proyecto VASCO.

Además Pinguino es de hardware y software libre.

Este es el esquema original de la placa Pinguino PIC:

Los pasos para instalar el IDE y la placa Pinguino en Windows son los siguientes:
1.- Instalar Python 2.6

2.- Instalar wxpython

3.- Instalar PYUSB

4.- Instalar LIBUSB-WIN32

5.- Descomprimir e instalar Pinguino beta 9.05

Una vez conectada la placa PINGUINO al ordenador preguntará por los drivers, descomprimir en el escritorio
la carpeta driver pinguino windows y seleccionar el archivo.

Pinguino ya estará listo para usarse, arrancaremos el programa pinguino 9.05 y probamos su funcionamiento.

  • En primer lugar, haga clic en el botón de Upload to Pinguino en el IDE de Pinguino
  • Esperar unos segundos a que aparezca la ventana del Vascobootloader.
  • Ahora pulse el botón de reset en la placa Pinguino y espere unos 3 segundos.
  • Haga clic en “escribir” en el VascoBootLoader.
  • Deberia dar un mensaje de Pic found, si este mensaje no aparece y en cambio aparece Pic no found vuelve al paso anterior.

En el próximo post os enseñare la versión que me he montado de la placa de Pinguino PIC y como se graba el bootloader y un programa para comunicar con el pc.

Más información sobre Pinguino PIC en: http://www.hackinglab.org/pinguino/index_pinguino.html

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Puerto Serie con Arduino y VB 6.0


He estado cacharreando algo estos días con el arduino y me he puesto a aprender a controlar y comunicar el arduino con el portátil, os subo un ejemplo de como encender y apagar el led 13 mediante una aplicación realizada en visual basic 6.

Esta es una imagen de la aplicación:

Esta aplicación consiste en controlar el arduino mediante el puerto serie (en mi caso es el COM6, ya lo puse directo en el control del VB 6.0, también se podría hacer para seleccionar el puerto), lo primero que debemos hacer es darle al botón CONECTAR para que se abra el puerto serie y se habiliten los botones de LED ON y LED OFF. Al presionar el botón LED ON el led 13 se encenderá y al presionar el botón LED OFF el led se apagará, para cerrar el puerto serie basta con presionar el botón DESCONECTAR (deshabilitando los botones de encendido y apagado de los leds). Está pequeña aplicación sirve de aprendizaje para futuros proyectos en los que queramos controlar determinados actuadores o sensores. Espero que os sirva de ayuda, a continuación os dejo los códigos y un video del funcionamiento.

Aquí os dejo el código del Arduino:

void setup() {
 //Definimos la velocidad de transferencia a 9600 baudios
 //y el pin 13 como salida
 pinMode(13,OUTPUT);
 Serial.begin(9600);
}

void loop() {
 //Mientras el puerto serie este accesible
 while (Serial.available())
 {
 //Guardamos en dato el valor leido del puerto serie
 byte dato = Serial.read();
 switch (dato){
 //Si es '1' encendemos el led
 case '1':
 digitalWrite(13,HIGH);
 break;
 //Si es '2' apagamos el led
 case '2':
 digitalWrite(13,LOW);
 break;
 }
 }
}

Aquí el código de la aplicación en VB 6.0:

Option Explicit

'Boton de conectar
Private Sub cmdConectar_Click()
 Serie.PortOpen = True   'Abrimos el puerto serie
 cmdON.Enabled = True    'Habilitamos los botones para trabajar con el led
 cmdOFF.Enabled = True
End Sub

Private Sub cmdDesconectar_Click()
 Serie.PortOpen = False  'Cerramos el puerto serie
 cmdON.Enabled = False   'Deshabilitamos los botones
 cmdOFF.Enabled = False
End Sub

Private Sub cmdOFF_Click()
 Serie.Output = "2"      'Mandamos un "2" para apagar el led
End Sub

Private Sub cmdON_Click()
 Serie.Output = "1"      'Mandamos un "1" para encender el led
End Sub

Y aquí os dejo el video del funcionamiento:

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Teclado para Arduino que emplea solo un pin


Hola de nuevo, después de unos días inactivo debido a los examenes de la Universidad estoy por aquí para presentaros una placa que he hecho con el software Eagle (una maravilla), se trata de un teclado 4×4 controlado solo por un pin analógico de nuestro Arduino. Ya tengo diseñada la placa y comprados todos los componentes, así que una vez que tenga insolada la placa procederé a soldar todos los pulsadores y resistencias me pondré a hacer pruebas con ella.  Una vez comprobado el buen funcionamiento sobre el Arduino os subiré los archivos del eagle para que la podáis mejorar o para poder haceros este teclado que sin duda nos ayudará en nuestros proyectos.

Aquí os dejo el esquema de conexión del teclado a nuestro Arduino:

En esta imagen podeis comprobar los valores que se producen en el pin que va conectado a la entrada analógica de nuestro Arduino:

Nota: Los valores del teclado analógico no son precisos debido a las tolerancias de las resistencias pero son valores muy próximos, con el monitor serie del IDE de arduino podeis ver los valores exactos y apuntarlos.

 

 

Para comprobar si eran exactas he montado el circuito en Proteus y las pruebas fueron exitosas. Ahora tocar probar si funciona realmente sobre nuestro Arduino. Os dejo para que veais más o menos como será la placa real unas fotos de las placas que he hecho del teclado en Eagle, una para conectar encima de Arduino como una shield y la otra para conectar con 3 pines (Vcc, Out, Gnd).

Espero que os sirvan de ayuda, en cuanto tenga montada la placa (me voy a decantar por la que va encima de Arduino, es decir, la primera) os enseño las fotos.

P.D: En un post posterior he realizado una mejora para esta shield, allí encontrareis los archivos de la shield teclado.

Si te ha servido de ayuda esta entrada, puedes realizar un donativo para agradecer el tiempo que dedico al blog y ayudar a hacer más entradas.

donativo_paypal

Arduino y Pinguino PIC en particular Electrónica en general

A %d blogueros les gusta esto: