Introducción

Pingüino es un dispositivo electrónico, basado en el uso de un único, pero poderoso y complejo Chip Microcontrolador, que es capaz de actuar como un Controlador Lógico de Procesos Embebido, pues puede recibir y procesar datos del exterior a través de sensores o transductores conectados a sus entradas (de luz, temperatura, sonido, otros), para procesarlos lógicamente, y en función de ello, generar cambios sobre su entorno a través de actuadores o transductores conectados a sus salidas (lámparas, motores, pistones, otros) con total autonomía de un computador personal, aunque puede permanecer conectado a éste, aún luego de ser programado, para enviar y recibir datos desde y hacia el mismo.

Pingüino es Software Libre y Hardware de Fuentes Abiertas
Los Planos del Hardware y el Código Fuente del Software de Pingüino se desarrollan y distribuyen bajo el modelo de Software Libre, que permite a cualquier persona, darle uso para cualquier propósito, estudiarlo, realizar modificaciones y redistribuirlo, bajo éstos mismos términos.
Ésta característica fundamentalmente, hace de Pingüino un dispositivo de especial interés para aficionados, entusiastas, estudiantes, docentes, profesionales y emprendedores que pueden hacer uso pleno de estas libertades, para acceder al conocimiento tecnológico que sustenta su creación, y a partir de éste, desarrollar nuevos conocimientos, tecnologías y/o dispositivos para dar solución a necesidades individuales y grupales.

Pingüino está derivado de Arduino
Pingüino fué creado a finales del año 2008 por el Ing. Electrónico Francés Jean Pierre Mandon, como parte de los proyectos de su empresa HackingLabs, y de su labor docente en la Universidad Aix Provence en Francia. Jean Pierre observó la posibilidad de diseñar un dispositivo similar a Arduino, pero "portándolo" desde la plataforma de Microcontroladores ATMEGA de ATMEL (de Arduino) a los Microcontroladores

PIC de Microchip.
La intención principal de éste cambio fué aprovechar sus conocimientos en la plataforma PIC, y la excelente oportunidad que representaba que algunos modelos de PICs (PIC18F2550 y 4550) integran ya una interfaz USB, que en el caso de Arduino se implementa a través de un chip adicional que actúan como adaptador/convertidor Serial (RS-232) a USB (Bus Serial Universal).

En el diseño de Pingüino, J.P. Mandón también decantó por otras alternativas respecto a Arduino a nivel de Software, optando por el Lenguaje de Programación Python y la Biblioteca de Interfáces Gráficas WxWidgets para el desarrollo del IDE o Entorno de Programación (versus Java para Arduino), y por GPUTILS (Utilidades GNU para PICs) y SDCC (Small Device C Compiler) basado en GNU gcc (versus AVR-GCC para Arduino).

Construcción

Materiales
1 Resistencia 10 k
2 Resistencia 470
1 Resistencia 220
2 Condensador 22pF ceramico
1 Condensador 220nF poliester
2 Condensador 100uF electrolitico
1 Condensador 100nF ceramico
1 Led rojo
1 Led verde
1 Cristal 20MHz
1 Diodo 1N4007
1 Pulsador
1 Conector USB
1 Conector para bateria
1 Zocalo 40 pines
1 PIC18F4550
1 LM7805CT


Circuito

Placa impresa


Algunas imágenes del Pinguino PIC terminado

Instalación

Para la instalación del IDE de Pinguino

Paso 1. Primero instalaremos los drivers setup.exe en C:/LibUSB

Paso 2. Instale el Python python-2.6.6.msi

Paso 3. Descomprime el IDE y ejecutalo x4-easy-rev857.rar

Abra el programa en el pinguino_start.bat


Paso 4. Conecte el Pinguino y cuando le pida los drivers seleccione la ruta C:/LibUSB/Driver

Tiene que quedar reconocido de esta manera

Paso 5. Por ultimo configure en el IDE que trabajara con el Micro 4550 esto en el menú Pinguino - Seleccionar tarjeta

version 11 - linux
antes instalar las librerias
python-pyside
python-pip
python-wheel
python-setuptools
python-bs4
python-usb

instalar
pinguino-ide.deb
pinguino-libraries.deb
pinguino-linux32-sdcc-mpic16.deb

Led

void setup()
{               
    pinMode(7, OUTPUT);    
}

void loop()
{
    toggle(7);            // alternate ON and OFF
    delay(1000);        // wait for a second
}

pulsador

const int buttonPin = 2;
const int ledPin =  7;
int buttonState = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);    
}

void loop(){
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
}
  else {
digitalWrite(ledPin, LOW);
  }
}

leds secuenciales

int compteur;                                    // definit une variable entiere pour le compteur
int i;                                            // variable servant a l'initialisation

void setup(void)
{
    for (i=0;i<8;i++)
    {
        pinMode(i,OUTPUT);                        // definit les broches 0 a 7 en sortie
        digitalWrite(i,LOW);                    // fixe un niveau 0 sur les sorties
    }
}



void loop(void)
{
    for (compteur=0;compteur<8;compteur++)        // pour compteur variant de 0 a 7
    {
        digitalWrite(compteur,HIGH);            // allume la led compteur
        if (compteur==0)
            digitalWrite(7,LOW);                // si led courante=0 eteindre la led 7
        else
            digitalWrite(compteur-1,LOW);        // sinon eteindre la led d'indice -1
        delay(500);                                // attendre 500 milli-Secondes
    }
}

rgb

#define a1 11
#define a2 12
int valu = 0;

void setup()
{

}
void loop(){
analogWrite(a1, 255);
analogWrite(a2, 0);
delay(1000);
analogWrite(a1, 0);
analogWrite(a2, 255);
delay(1000);
}

Entrada analogica

int sensorPin = 0;   
int ledPin =7;     
int sensorValue = 0; 
void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  sensorValue = analogRead(sensorPin); 
  digitalWrite(ledPin, HIGH);
  delay(sensorValue);       
  digitalWrite(ledPin, LOW);
  delay(sensorValue);               
}

lcd

void setup() {
  // initialize the library with the numbers of the interface pins
  lcd.pins(0, 1, 2, 3, 4, 5, 0, 0, 0, 0); // RS, E, D4 ~ D8   
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Hola mundo!");
}

void loop() {
  // Turn off the blinking cursor:
  lcd.noBlink();
  delay(3000);
   // Turn on the blinking cursor
//lcd.printf("Pinguino: %d", millis()/100);
  lcd.blink();
  delay(3000);
}

bluetoo

char caractere;
void setup()
{
    pinMode(7, OUTPUT);
    Serial.begin(9600);
}

void loop()
{

    if (Serial.available())
    {

        caractere=Serial.read();
   if(caractere=='1'){
    digitalWrite(7,LOW);
    }
if(caractere=='2'){
    digitalWrite(7,HIGH);
    }
    }
}

Sensor de distancia

// Los pines a donde se conectará el sensor
int trig = 7; //23
int echo = 6; //24
int dist = 0;

int distancia() {
int centimetros = 1;

while (digitalRead(echo) == LOW) {
digitalWrite(trig, HIGH);
delayMicroseconds(50);
digitalWrite(trig, LOW);
}
while (digitalRead(echo) == HIGH) {
centimetros++;
delayMicroseconds(27);
}
delay(50);
return centimetros;
}

void setup() {
pinMode(trig, OUTPUT);
pinMode(echo, INPUT);
lcd.pins(0, 1, 2, 3, 4, 5, 0, 0, 0, 0); // RS, E, D4 ~ D8   
lcd.begin(16, 2);
}

void loop() {
dist = distancia();
lcd.home();
lcd.print("Distancia: ");
lcd.printNumber(dist, 10);
lcd.print("cm.");
delay(20);
}

ethernet

/*-----------------------------------------------------
Author:  --<>
Date: 28/Oct/2012
Description:

-----------------------------------------------------*/
#include <ethernet/ip_arp_udp.h>
#define BUFFER_MAX    224

static u8 buf[BUFFER_MAX+1]; // the received message
u16 len; // the length of the received messages

void setup() {
 // put your setup code here, to run once:
 // this is the enc28j60 ip address
 u8 myip[4] = { 192, 168, 2, 2 };
 // this is the enc28j60 mac address
 u8 mymac[6] = { 0x02, 0x04, 0x08, 0x10, 0x12, 0x14 };
 init_ip_arp_udp (mymac, myip);
 enc28j60Init (mymac);
 }

void loop() {
 len = enc28j60PacketReceive(BUFFER_MAX, buf);
 CDC.printf("received! len: %d\n", len);
   
 if (len == 0) {
  return;
  }
 if(eth_type_is_arp_and_my_ip(buf, len)) {
  make_arp_answer_from_request(buf, len);
  return;
  }
 if(eth_type_is_ip_and_my_ip(buf, len)==0) {
                return;
                }

 if(buf[IP_PROTO_P]==IP_PROTO_ICMP_V && buf[ICMP_TYPE_P]==ICMP_TYPE_ECHOREQUEST_V) {
  // the ping reply
  make_echo_reply_from_request(buf, len);
  return;
  }
 }

Comunicación con Java

este ejemplo nos permite prender y apagar un led desde la PC, para esto descarge el programa en java arduino.rar  luego grabar el programa ejemplo en el pinguino

Ejemplo 1

char dato;
unsigned char receivedbyte;
unsigned char rxstr[8];


void setup(){
    pinMode(28, OUTPUT);
}

void loop(){
while((receivedbyte = CDC.read(rxstr)) == 0);
if(receivedbyte > 0){
dato = rxstr[1];
if(dato == '1'){
        digitalWrite(28, 1);
}
    if(dato == '0'){
        digitalWrite(28, 0);
}
}
 }

sr04

Code for 8 bit PICs

/*----------------------------------------------------- 
File:        hc-sr04_p8.pde
Author:      Edermar Dominguez <Edermar_12[_at_]hotmail.com>
Date:        31 Jan 2013
Changes by:  Oliver Göpferich <pinguplus[_at_]live.de>
Date:        Sat Mar 22 09:47:36 2014
Description: Measure the distance to an obstacle using
             the Ultrasonic sensor HC-SRC04
PIC:         PIC18F25k50
Should also work with any other 8 bit PIC18F
-----------------------------------------------------*/
 
int trig = 3;
int echo = 4;
unsigned long pulse;
float distance;
 
void setup() {
    Serial.begin(9600);
    pinMode (USERLED,OUTPUT);
 
    pinMode (echo,INPUT);      // Declare the echo pin as INPUT
    pinMode (trig,OUTPUT);     // Declare the trigger pin as OUTPUT
 
    digitalWrite(USERLED,LOW);
    }
 
 
// I'm using my own pulseIn() function, because builtin pulseIn()
// provides to high values with the 25k50
 
unsigned long myPulseIn(unsigned char pin, unsigned char state, unsigned long timeout)
{
 unsigned long width = 0; // keep initialization out of time critical area
 
 // convert the timeout from microseconds to a number of times through
 unsigned long numloops = 0;
 unsigned long maxloops = timeout / 10; //We have a microsecond by 10 loops (mean).
 
 
 // wait for any previous pulse to end
 while (digitalRead(pin) == state) {
  if (numloops++ == maxloops) {
   return 0;
    }
  }
 
 // wait for the pulse to start
 while (digitalRead(pin) != state)
  if (numloops++ == maxloops) {
   return 0;
    }
 
 // wait for the pulse to stop
 while (digitalRead(pin) == state) {
  width++;
  }
 
 //There will be some error introduced by the interrupt handlers.
 //At last loop, each interaction have 12us + 60us from digitalRead() instructions
 
   //return width * 12 + 60;
 
   return width * 9;
}
 
 
void medirdistance() {
    // set the trigger for 2 ms low
    digitalWrite(trig, LOW);
    delayMicroseconds(2);
 
    // Set the trigger for 15 ms high (minimum 10 ms)
    digitalWrite(trig, HIGH);
    delayMicroseconds(15);
 
    // Set the trigger low. This starts the measuring procedure.
    digitalWrite(trig, LOW);
 
    // Measure the length of the input signal
    pulse = myPulseIn(echo, HIGH, 3000);
 
    // The speed of sound is 29 cm/second (/29). The ultrasonic pulse travels
    // the distance to the obstacle and back (/2).
    distance = (float)(((pulse)/29.0/2.0));
 
    Serial.printf("Puls: %d\r\n", pulse);
    Serial.printf("distance: %f cm\r\n", distance);
 
    toggle(USERLED);
 
    // Just wait for a second
    delay(1000);
}
 
 
void loop() {
    //run repeatedly:
    medirdistance();
}