domingo, 11 de febrero de 2018

NODEMCU. Placa de desarrollo para aprender a programar el ESP8266

NODEMNCU es un kit de desarrollo basado en el chip ESP8266. tiene la gran ventaja de conectividad WIFI lo que lo  hace ideal para realizar proyectos conectados internet

A continuacion citaremos la principales caracteristicas de este KIT:

  • Incorpora un MCU de 32-bit de bajo consumo (Tensilica L106)
  • Módulo WiFi de 2.4 GHz
  • RAM de unos 50 kB
  • 1 entrada analógica de 10-bit (ADC)
  • 17 pines de entrada y salida GPIO (de propósito general)

 

Correspondencia entre el PINOUT del ESP8266 y el NODEMCU LOLIN V3.

GPIO   Pin I/O 

GPIO0  D3

GPIO1  D10

GPIO2  D4

GPIO3  D9

GPIO4  D2

GPIO5  D1
GPIO6  N/A
GPIO7  N/A
GPIO8  N/A
GPIO9  D11
GPIO10 D12
GPIO11 N/A
GPIO12 D6
GPIO13 D7
GPIO14 D5
GPIO15 D8
GPIO16 D0

Modos de Trabajo del ESP8266

Básicamente son tres los modos que puede trabajar el ESP8266:
  • MODO AP. El ESP8266 actúa como punto de acceso para que los clientes tales como: PCs, Smartphones, Tablets, etc. se conecten a él
  • STATION. El ESP8266 se configura para conectarse a un punto de acceso, en este caso actuaria como cliente del ROUTER
  • AP+STATION. Es la combinación de los dos modos anteriores el ESP8266 actúa como punto de acceso y también como cliente de un ROUTER

 

PRACTICA # 1. Parpadeo de LEDs (Blink)

El siguiente código que hará parpadear dos LEDS conectados a las salidas D1(GPIO5) y D2(GPIO4) del ESP8266.


/*
Practica #1. Parpadeo de LEDS
 */
int LED_aparpadear = D1; //tambien pude haber puesto el numero 5 en lugar de D1 porque corresponde al GPIO5
int LED_aparpadear2 = 4; //tambien hubiera dado igual escribir D2 en lugar del numero 4             
void setup() {                       
  pinMode(LED_aparpadear, OUTPUT);
  pinMode(LED_aparpadear2, OUTPUT);}
void loop() {                         
  digitalWrite(LED_aparpadear, HIGH); 
  digitalWrite(LED_aparpadear2, LOW); 
  delay(1000);                       
  digitalWrite(LED_aparpadear2, HIGH); 
  digitalWrite(LED_aparpadear, LOW); 
  delay(1000);}       
   
             


PRACTICA #2. Servidor web. Encender/Apagar un LED desde un PC o SmartPhone

El siguiente código permite que el ESP8266 trabaje en modo ACCESS POINT, y envía una pagina web sencilla hasta el cliente la misma que servirá para encender o apagar un LED conectado al pin D2. 

El Cliente debe conectarse a la red llamada "dinoelectro" cuya contrasena es ABCD1234

En el navegador escribir la direccion 192.164.4.1

/* NodeMCU Access Point  Servidor Web en modo Access Point  Enciende/Apaga un LED conectado a la salida D2 (GPIO04). */

#include <ESP8266WiFi.h>                  
const char ssid[] = "dinoelectro";        //SSDI (nombre de red) 
const char password[] = "ABCD1234";       //Contraseña  
WiFiServer server(80);                    //Puerto de comunicaciones
int LED = D2;                             //Pin de salida - GPIO4 int LedStatus = LOW;                         

void setup() {  
pinMode(LED, OUTPUT);                     
digitalWrite(LED, LOW);                   
server.begin();                         //Inicializamos el servidor   
WiFi.mode(WIFI_AP);                     //Modo Access Point  WiFi.softAP(ssid, password);            //Red con clave, en el canal 1 y visible  }

void loop() {  
// Comprueba si el cliente ha conectado  
WiFiClient client = server.available();    
if (!client) {    
return;  
}  
// Espera hasta que el cliente envíe alguna petición  while(!client.available()){  
delay(1);  
}  
// Lee la peticion y la almacena en la variable peticion  
String peticion = client.readStringUntil('r');  
client.flush();  
// Comprueba la petición  
if (peticion.indexOf('/LED=ON') != -1) {    LedStatus = HIGH;    }   if (peticion.indexOf('/LED=OFF') != -1){    LedStatus = LOW;    }  //Enciende o apaga el LED en función de la petición  digitalWrite(LED,LedStatus);  

/*El siguiente Codigo Crea Pagina HTML y la envia al Cliente que puede ser un PC, Tablet, //SmartPhone, etc)*/
      
client.println("HTTP/1.1 200 OK");    
client.println("");                                       client.println("<!DOCTYPE HTML>");    
client.println("<meta charset='UTF-8'>");    
client.println("<html>");    
client.print("<h1>dinoelectro.blogspot.com:<\h1>");      
client.print("<h2>Estado del LED: ");      
if(LedStatus == HIGH){    
client.print("ENCENDIDO</h2>");      //Crea un Boton para manipular al LED con la etiqueta "APAGAR"    
client.print("<button type='button' onClick=location.href='/LED=OFF'> APAGAR </button>");    
}else{    
client.print("APAGADO</h2>");    //Crea un Boton para manipular al LED con la etiqueta "ENCENDER"    
client.print("<button type='button' onClick=location.href='/LED=ON'> ENCENDER </button>");    }      
client.println("</html>");     
}

Practica #3. Un Servidor Web mas Avanzado.

Utilizando el IDE de Arduino grabamos el siguiente código para encender o apagar un LED conectado al pin D2. desde un PC, Tablet o Smartphone. El ESP8266 actua en modo Access Point y Ademas cuenta con depuracion por puerto serie.

El Cliente debe conectarse a la red llamada "dinoelectro" cuya contrasena es ABCD1234

En el navegador escribir la direccion 192.164.4.1

/*
 NodeMCU Access Point 
 Servidor Web en modo Access Point 
 Enciende/Apaga un LED conectado a la salida D2 (GPIO04).
 */

#include <ESP8266WiFi.h>                  
const char ssid[] = "dinoelectro";        //SSDI (nombre de red) 
const char password[] = "ABCD1234";       //Contraseña  
WiFiServer server(80);                    //Puerto de comunicaciones
int LED = D2;                             //Pin de salida - GPIO4 D2
int LedStatus = LOW;                      //Definimos la variable que va a recoger el estado del LED

void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);                   
  digitalWrite(LED, LOW);                 
  server.begin();                         //Inicializamos el servidor 
  WiFi.mode(WIFI_AP);                     //Modo Access Point
  WiFi.softAP(ssid, password);            //Red con clave, en el canal 1 y visible
  }

void loop() 
{
  // Comprueba si el cliente ha conectado
  WiFiClient client = server.available();  
  if (!client) {
    return;
  }
  // Espera hasta que el cliente envíe alguna petición
  while(!client.available()){
    delay(1);
  }
  // Lee la peticion y la almacena en la variable peticion
  String peticion = client.readStringUntil('r');
  client.flush();
  // Comprueba la petición
  if (peticion.indexOf('/LED=ON') != -1) {
    LedStatus = HIGH;
    } 
  if (peticion.indexOf('/LED=OFF') != -1){
    LedStatus = LOW;
    }

  //Enciende o apaga el LED en función de la petición
  digitalWrite(LED, LedStatus);
  
/*El siguiente Codigo Crea Pagina HTML y la envia al Cliente que puede ser un PC, Tablet, 
SmartPhone, etc)*/
  
    client.println("HTTP/1.1 200 OK");
    client.println("");                                   
    client.println("<!DOCTYPE HTML>");
    client.println("<meta charset='UTF-8'>");
    client.println("<html>");
    client.print("<h1>dinoelectro.blogspot.com:<\h1>");  
    client.print("<h2>Estado del LED: ");  
    if(LedStatus == HIGH){
    client.print("ENCENDIDO</h2>");  
    //Crea un Boton para manipular al LED con la etiqueta "APAGAR"
    client.println("<button type='button' onClick=location.href='/LED=OFF' style='margin:auto; background-color:red; color:#F6D8CE; padding:5px; border:2px solid black; width:200;'><h2> APAGAR</h2> </button>");
    }else{
    client.print("APAGADO</h2>");
    //Crea un Boton para manipular al LED con la etiqueta "ENCENDER"
    client.println("<button type='button' onClick=location.href='/LED=ON' style='margin:auto; background-color:green; color:#A9F5A9; padding:5px; border:2px solid black; width:200;'><h2> ENCENDER</h2> </button>");
   }  
    client.println("</html>"); 
    Depurar();
    }

    void Depurar(){
    Serial.printf("Direccion IP Access Point - por defecto: ");      //Imprime la dirección IP
    Serial.println(WiFi.softAPIP()); 
    Serial.printf("Direccion MAC Access Point: ");                   //Imprime la dirección MAC
    Serial.println(WiFi.softAPmacAddress()); 
    Serial.printf("Clientes conectados al Access Point: %d", WiFi.softAPgetStationNum());
    Serial.println("");
    Serial.println("*******");

    }


Practica #4. EN MODO STATION NODEMCU SE CONECTA AL ROUTER,


En esta ocacion el ESP8266 se conectara a un router indicando su ssid y contraseña ademas aprovechara la conectividad a internet del router para cargar imagenes desde una pagina web externa.

El Cliente debe conectarse al router indicando el nombre y contraseña de dicho router.

Para saber que dirección se debe escribir en el navegador consultar en el puerto COM correspondiente

/*

 NodeMCU Server - Conexión en modo Station   

 encender y apagar un LED conectado a la salida D2 del módulo NodeMCU.

 Aprovecha la conexion a internet para cargar imagenes

 */



#include <ESP8266WiFi.h>                   

const char* ssid = "Raul";          //Nombre de la red WiFi (SSID) a la que queremos conectarnos.

const char* password = "dino1979";  //Contraseña de de red WiFi

WiFiServer server(80);              //Puerto de comunicaciones



int PinLED = D2;               

int estado = LOW;                         


void setup() {
  pinMode(PinLED, OUTPUT);                
  digitalWrite(PinLED, LOW);              
  WiFi.begin(ssid, password);             //Inicializamos  la conexión del NodeMCU con la red WiFi
  
  //Verifica el estado de la conexión hasta que conecta 
  while (WiFi.status() != WL_CONNECTED) { 
    delay(500);
  }
  server.begin();                         
 } 

void loop() 
{
   // Comprueba si el cliente ha conectado
  WiFiClient client = server.available();  
  if (!client) {
    return;
  }

  while(!client.available()){
    delay(1);
  }

  // Lee la petición
  String peticion = client.readStringUntil('\r');
  client.flush();

  // Comprueba la petición
  if (peticion.indexOf('/LED=ON') != -1) {
    estado = HIGH;
  } 
  if (peticion.indexOf('/LED=OFF') != -1){
    estado = LOW;
  }

  //Enciende o apaga el LED en función de la petición
  digitalWrite(PinLED, estado);

// Envía la página HTML de respuesta al cliente
  client.println("HTTP/1.1 200 OK");
  client.println("");                         
  client.println("<!DOCTYPE HTML>");
  client.println("<meta charset='UTF-8'>");
  client.println("<html>");
  client.print("<h1 align='center'>dinoelectro.blogspot.com:<\h1>");  
  client.print("<h2 align='center'>Estado del LED: ");  
 if(estado == HIGH) {
 client.println("<br><br>");
 client.print("ENCENDIDO</h2>"); 
 client.print("<img src='http://www.clker.com/cliparts/y/D/L/V/s/t/led-off-hi.png' alt='Bombilla encendida' style='display:block; margin:auto' width='15%'>");
 client.println("<br><br>");
 client.print("<input type='image' src='http://www.clker.com/cliparts/0/K/4/q/M/Y/power-button-off-hi.png' style='display:block; margin:auto' width='25%' onClick=location.href='/LED=OFF'>"); 
 } else {
 client.println("<br><br>");
 client.print("APAGADO</h2>");
 client.print("<img src='http://www.clker.com/cliparts/r/h/y/I/T/X/white-led-off-md.png' alt='Bombilla apagada' style='display:block; margin:auto' width='15%'>");
 client.println("<br><br>");
 client.print("<input type='image' src='https://cdn1.iconfinder.com/data/icons/media-controls/32/circle-power-512.png' style='display:block; margin:auto' width='25%' onClick=location.href='/LED=ON'>");
 }
 client.println("</html>");
 delay(1);


}


Practica#5. Enviando Recibiendo paquetes UDP

En esta practica nos conectaremos al router para enviar y recibir paquetes UDP

UDP es un protocolo muy sencillo y útil para hacer practicas con ARDUINO, sin embargo no es recomendado en ambientes críticos puesto que no se tiene la seguridad de que los paquetes lleguen esa su destino. pero para proyectos caseros o donde la seguridad de la comunicación no muy relevante funciona perfecto.

para probar que todo anda bien, podemos utilizar el programa Packet Sender que lo puedes descargar en la siguiente dirección
https://packetsender.com/download




/*UDP monitor*/
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
/*Creamos un objeto UDP*/
WiFiUDP Udp;
const char* ssid = "Raul";//nombre del router
const char* password = "dino1979";//contraseña del router

unsigned int localUdpPort = 4210; //puerto para escuchar mensajes UDP
char incomingPacket[255];         //buffer donde se almacena el mensaje recibido
char  replyPacekt[] = "Hola! he recibido el mensaje! :-)";  //buffer donde se almacena el mensaje a enviar

void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.printf("Connectando a %s ", ssid);
  WiFi.begin(ssid, password);
  /*Ciclo que se repite hasta conseguir conexion con la red WIFI*/
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println(" conectado");

  Udp.begin(localUdpPort);  // nos ponemos a la espera de mensajes UDP
  Serial.printf("Estamos escuchando en la direccion IP %s, puerto UDP %d\n", WiFi.localIP().toString().c_str(), localUdpPort);
}

void loop() {
  int packetSize = Udp.parsePacket();
  if (packetSize)
  {
    // recibimos paquetes UDP
    Serial.printf("Recividos %d bytes desde %s, puerto %d\n", packetSize, Udp.remoteIP().toString().c_str(), Udp.remotePort());
    int len = Udp.read(incomingPacket, 255);
    if (len > 0)
    {
      incomingPacket[len] = 0;
    }
    Serial.printf("Contenido del paquete UDP: %s\n", incomingPacket);
    // respondemos a la direccion IP que nos envio el paquete
    Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
    Udp.write(replyPacekt);
    Udp.endPacket();
  }

}

SISTEMA DE ADQUISICION Y CONTROL DE DATOS

“Los componentes hardware y software están siendo cada vez más potentes y más rentables. Las tareas automatizadas de control y visualización que antes se efectuaban con PLC y paneles de control ahora están siendo reemplazados por sistemas de monitoreados por PC, utilizando tarjetas de adquisición y control de datos”

Procesamiento Digital de Señales Analógicas.


En el mundo real, los fenómenos físicos cambian de manera analógica. La temperatura, la velocidad, la distancia… etc. cambian en forma continua y gradual, pudiendo asumir un valor cualquiera dentro de un rango definido de valores. Las variables analógicas, asociadas a tales fenómenos, se obtienen por lo general mediante el uso de transductores, los cuales se encargan de sensar al fenómeno o variable de interés, para entregar a su salida un voltaje o una corriente cuya variación es análoga a la del fenómeno sensado.

El proceso de conversión se resume en dos pasos:
  1. Obtener los valores de la variable a ser convertida 
  2. Llevar estas muestras de corriente o de voltaje, a la entrada del dispositivo que se encargará de convertir el dato analógico a un dato digital. 
En sistemas controlados por computadora, una vez que la información de los sensores ha sido ingresada a la máquina, esta opera sobre los datos recibidos emitiendo los comandos necesarios para que el sistema se comporte de acuerdo con lo deseado. Los comandos emitidos por la computadora son igualmente digitales; en ocasiones pueden ser sencillos, ordenando simplemente el cierre o apertura de un interruptor. No obstante, algunos de los comandos deberán, por ejemplo regular el flujo de combustible en un automotor, lo que requiere de un voltaje análogo que controle qué tanto debe abrir o cerrar una válvula en particular.

Interface a sensores y actuadores 


Los sensores y actuadores son los intermediarios que hay entre los distintos elementos físicos y las unidades de control que son el cerebro del sistema. Por regla general en el sensor hay un circuito de adaptación que convierte las señales del transductor en una señal entendible para la unidad de control. Los sensores deben ser sellados a prueba de polvo, humedad y otros contaminantes, para su correcto funcionamiento, se debe asegurar que los datos que llegan a la unidad de control tengan un alto grado de precisión. Por otra parte los actuadores son elementos activos porque actúan sobre el medio exterior. Ejecutan las ordenes obtenidas mediante las entradas del sistema, convirtiendo una magnitud eléctrica en otra de otro tipo (mecánica, térmica, óptica, acústica, etc.) Se puede decir que realizan de alguna manera un proceso inverso a los sensores.

Interface Hombre Maquina (IHM) 


Los sistemas de interfaz entre usuario y planta, basados en paneles de control repletos de indicadores luminosos, instrumentos de medida y pulsadores, están siendo sustituidos por sistemas digitales que implementan el panel sobre la pantalla de un ordenador. El control directo lo realizan los controladores autónomos digitales y/o autómatas programables y están conectados a un ordenador que realiza las funciones de diálogo con el operador, el tratamiento de la información y control de la producción, utilizando sistemas SCADA (adquisición supervisión y control de datos).

  •  Adquisición de datos, para recoger, procesar y almacenar la información recibida 
  •  Supervisión, para observar en un monitor la evolución de las variables de control 
  •  Control, para modificar la evolución del proceso, actuando bien sobre los reguladores autónomos básicos (consignas, alarmas, menús, etc.) o bien directamente sobre el proceso mediante los actuadores conectados a las salidas de la unidad de control

sábado, 24 de junio de 2017

Juego de PONG utilizando ARDUINO UNO

Hola amigo, le invito a revisar este brevisimo articulo donde se explica como hacer el famoso juego de PONG publicado por primera vez en el año 1973 por la industria ATARI Interactive;

El juego se desarrolla en dos dimensiones y fue todo un éxito de ventas en aquella época



Bueno, vamos ahora a ver como construir uno similar:

MATERIALES:

Placa Arduino Uno R3
Matriz P10 de 32x16 Pixels
Un Potenciometro de 10K

CIRCUITO:

El circuito es bastante simple, además del arduino he utilizado una matriz LED de 16x32 pixels, un potenciometro para mover la paleta hacia arriba y hacia abajo y un buzzer que emite un sonido cada vez que la pelota rebota



SKETCH:
/*
//JUEGO PONG CON ARDUINO UNO Y MATRIZ LED 16X32 P10
//MAS INFORMACION LA ENCUENTRAS EN MI BLOG:
//dinoelectro.blogspot.com
//
//PENDIENTE:
//   MARCADOR DE PUNTAJE
//   MODO DE DOS JUGADORES
//
//CONEXIONES:
//  ARDUINO________________DMD
//  PIN9___________________OE
//  PIN6___________________A
//  PIN7___________________B
//  PIN13__________________SLK
//  PIN8___________________SCLK
//  PIN11__________________SPI
//  CANAL A0_______________Pot 10K
//  PIN5___________________Zumbador
*/

#include <DMD.h>
#include <TimerOne.h>
#include "SystemFont5x7.h"

int width=31,height=15; //DIMENSION DEL AREA DE JUEGO 
int x1=width/2,y1=height/2,speedx=1,speedy=1; //POSICION Y VELOCIDAD DE LA BOLA
int paddlex=2,paddley=height/2,paddleh=3,paddles=1; //POSICION ANCHURA Y VEOCIDAD DE LA PALETA
DMD display(1,1); 

void ScanDMD()
{ 
   display.scanDisplayBySPI();
}

void setup() {
   Timer1.initialize( 3000 );           
   Timer1.attachInterrupt(ScanDMD);    
   pinMode(5, OUTPUT); //aqui conectamos el zumbador
  // welcomeScreen();
}

void loop(){
   delay(50);
   display.clearScreen(true);
   analogWrite(5, 0); //APAGO EL SONIDO DE REBOTE
   display.writePixel(x1,y1,GRAPHICS_NORMAL,1); //DIBUJA LA PELOTA EN EL CENTRO
   x1=x1+speedx; //MUEVE LA PELOTA EN LA DIRECCION X
   y1=y1+speedy; //MUEVE LA PELOTA EN LA DIRECCION Y
   if(x1>=width){
    speedx=-speedx;//SI LA PELOTA TOCA EL LADO LATERAL CAMBIA DE DIRECCION
    analogWrite(5, 20); //EMITE SONIDO DE REBOTE
    }else if(x1<=0){
      speedx=-speedx;//SI LA PELOTA TOCA EL LADO LATERAL CAMBIA DE DIRECCION
      analogWrite(5, 20); //EMITE SONIDO DE REBOTE
      }
  if(y1>=height){
    speedy=-speedy;//SI LA PELOTA TOCA EL LADO SUPERIOR CAMBIA DE DIRECCION
    analogWrite(5, 20); //EMITE SONIDO DE REBOTE
    }else if(y1<=0){
      speedy=-speedy;//SI LA PELOTA TOCA EL LADO SUPERIOR CAMBIA DE DIRECCION
      analogWrite(5, 20); //EMITE SONIDO DE REBOTE
      }
    paddley=map(analogRead(A0),0,1023,0,12);  
    //GRAFICAMOS LA PALETA EN LA POSICION TOMANDO COMO REFERENCIA LA LECTURA DEL
    //POTENCIOMETRO
    display.drawLine(paddlex,paddley,paddlex,paddley+paddleh,GRAPHICS_NORMAL);   
    //SI LA PELOTA TIENE CONTACTO CON LA PALETA, CAMBIA DE DIRECCION
    if(x1==paddlex && y1<=paddley+paddleh && y1>paddley-paddleh/3){
      speedx=-speedx;
      speedy=-speedy;
      analogWrite(5, 20); //EMITE SONIDO DE REBOTE
      } else if(x1==0){
      //SI LA PELOTA ALCANZA LA POSICION X=0, EL JUEGO TERMINA
      //ESCRIBE GAME OVER
      analogWrite(5, 0); //APAGO
      SONIDO GAME OVER
      display.clearScreen(true);
      display.selectFont(System5x7);                     
      display.drawString(5,0,"GAME",4, GRAPHICS_NORMAL); 
      display.drawString(5,9,"OVER",4, GRAPHICS_NORMAL);  
      delay( 2000 );
      //REINICIA VARIABLES 
      x1=width/2;
      y1=height/2;
      paddlex=2;
      paddley=height/2;
      display.clearScreen(true);
      //ESCRIBE PONG DUINO
      display.drawString(5,0,"PONG",4,  GRAPHICS_NORMAL);
      display.drawString(1,9,"DUINO",5, GRAPHICS_NORMAL); 
      delay(2000);
      display.clearScreen(true);
      //ESCRIBE "READY" 
      display.drawString(2,4,"READY",5,  GRAPHICS_NORMAL);        
      delay(2000);
      display.clearScreen(true);
      //ESCRIBE GO!!!
      display.drawString(5,4,"GO!!!",5,  GRAPHICS_NORMAL);        
      delay(500);
      }
      }

COSAS POR IMPLEMENTAR

Aunque el juego está totalmente funcional; Queda como reto añadirle algunas características:
  • Poner en modo de dos jugadores
  • Poner un Marcador de Puntaje
Dejo a continuación las fotos que he tomado:







y por ultimo dejo un vídeo que muestra como funciona:



Esperando que le haya sido de utilidad, me despido hasta una próxima ocasión.

lunes, 19 de junio de 2017

Tarjeta PINGUINO basada en el microcontrolador PIC 18F2550

En este articulo trataré de explicar como construir una tarjeta electrónica "open source" que tiene su propio entrono de programación y además dispone de un bootloader para subir programas sin necesidad de programador; Otra de las características importantes es que es multi-plataforma; Es decir que trabaja en los sistemas operativos WINDOWS, LINUX y MAC OS X.





Los elementos necesarios para su construcción son los siguientes:
  • PIC 18F2550 
  • REGULADOR DE VOLTAJE 7805 
  • DIODO 1N4007 
  • CAPACITOR de 470nF, 1uF 10uF, 22pF X 2 
  • RESISTENCIAS DE 330, 10K 1M 
  • DIODO LED 
  • CONECTOR USB TIPO B 
  • PULSANTE NORMALMENTE ABIERTO 
  • CRYSTAL 20Mhz 
  • VARIOS ESPADINES (CONECTORES EN LINEA) 


Debido a la sencillez de este circuito fácilmente puede ser montado en un protoboard; o si prefiere puede construir una placa; Para ello descargue los archivos CAD en el siguiente enlace:


El Entorno de programación y el bootloader son gratuitos y los puede descargar en la siguiente dirección:


Pin-Out de la tarjeta Pinguino

Este hardware dispone de: 18 entradas/salidas digitales, 1 modulo UART para comunicaciones seriales, 2 salidas PWM de 3 KHz, 5 entradas analógicas, 1 Pulsador de Reset que permite iniciar en modo bootloader durante los primeros cinco segundos; luego de ello pasará a modo RUN

Al igual que en ARDUINO, los pines de la tarjeta PINGUINO son numerados desde el 0 al 17; en la siguiente tabla se describen algunas características que poseen los mismos: 

Nombre del PinE/S DigitalesEntrada analógicaOtrasPin en el chipNombre Microchip
0SinohwI2C I/O - SPI SDI21RB0/AN12/INT0/FLT0/SDI/SDA
1SinohwI2C SCL - SPI SCK22RB1/AN10/INT1/SCK/SCL
2Sinohw-23RB2/AN8/INT2/VMO
3Sinohw-24RB3/AN9/CCP2/VPO
4Sinohw-25RB4/AN11/KBI0
5Si--26RB5/KBI1/PGM
6Si--27RB6/KBI2/PGC
7Si--28RB7/KBI3/PGD
8Si-Serial Tx17RC6/TX/CK
9Si-Serial Rx - SPI SDO18RC7/RX/DT/SDO
10Si--11RC0/T1OSO/T13CK
11Si-PWM12RC1/T1OSI/CCP2/UOE
12Si-PWM13RC2/CCP1
13SiSiall-2RA0/AN0
14SiSiall-3RA1/AN1
15SiSiall-4RA2/AN2/VREF-/CVREF
16SiSiall-5RA3/AN3/VREF+
17SiSiall-7RA5/AN4/SS/HLVDIN/C2OU
RUNSolo salida-MODO RUN run6RA4/T0CKI/C1OUT/RCV
USB+--USB16RC5/D+/VP
USB---USB15RC4/D-/VM
Vusb--USB14VUSB
Reset--Interruptor de reinicio1MCLR/VPP/RE3
Vdd (5V)---20Vdd
Vss (GND)---8Vss
Vss (GND)---19Vss
OSC1--Quartz9OSC1/CLKI
OSC2--Quartz10OSC2/CLKO/RA6
  • Note hwEntrada analógica disponible en hardware, pero no soportada en software.
  • Note allSi un pin entre el 13 y el 17 es usado como entrada analógica, todos estos pines son configurados como entradas analógicas.
  • Note run: Si conectas una resistencia de 330 ohm en serie con un LED indicará MODO RUN/STOP no lo puedes usar como salida digital.

El Entrorno de Programacion de PINGUINO



El lenguaje de programación de PINGUINO, esta basado en Python y es muy similar al de ARDUINO que está basado en JAVA; Sin embargo, sigue en fase de desarrollo y no ha alcanzado la madurez que tiene ARDUINO; Las librerías disponibles son pocas y dejan mucho que desear, hay que tener en cuenta que es un compilador gratuito y que su código fuente esta abierto para que los desarrolladores lo vayan mejorando. Una de las novedades que esta llamando la atención es que la plataforma permite también programar mediante diagramas de bloques al estilo de Flowcode o Visualino.


Existen también algunas librerías estándar que facilitan mucho la programación y cada día van apareciendo nuevos aportes que hacen los usuarios de PINGUINO; esperemos que este proyecto no muera, sino que por el contrario siga enriqueciéndose. Si esas interesado en como crear librerías para PINGUINO y así contribuir a que este proyecto avance te invito a que revises el siguiente articulo:


A continuación se muestra un listado de librerías disponibles para la plataforma PINGUNO:

1
1wire Library
B
Bluetooth Library
Bulk Library
C
CDC Library
D
DCF77 Library
DS1306 Library
DS18B20 Library
E
EEPROM Library
Ethernet Library
Examples
F
Flash Library
G
GLCD Library
I
I2C Library
Interrupt Library
K
Keypad Library
KS DHTxx Library
L
LCD (I2C) Library
Lcdlib Library
M
MMC Library
P
PID Library
Port Expander Library
PS/2 Keyboard Library
PWM Library
R
RTCC Library
S
SD Library
SD8 Library
Serial Library
Servo Library
Sound Library
SPI Library
Stepper Library
System Library
U
USB Library
Z
ZigBee Library

Algunas librerías de ARDUINO también son soportadas por PINGUINO, pero otras no han sido desarrolladas todavía, no porque el microcontrolador PIC no pueda soportarlas sino más bien por la falta de interés que han tenido los usuarios en este proyecto; esperemos sin embargo que vaya evolucionando a través de los años y que vayan apareciendo nuevos aportes: dejo a continuación un listado de librerías que son y no son soportadas por las ambas plataformas: 

Librería Standard 

✔ EEPROM - reading and writing to "permanent" storage
✖ Ethernet - for connecting to the internet using the Arduino Ethernet Shield
✔ LiquidCrystal - for controlling liquid crystal displays (LCDs)
✔ SD - for reading and writing SD cards
✔ Servo - for controlling servo motors
✔ SPI - for communicating with devices using the Serial Peripheral Interface (SPI) Bus
✔ Stepper - for controlling stepper motors
✔ Wire - Two Wire Interface (TWI/I2C) for sending and receiving data over a net of devices or sensors.

Comunicación (networking y protocolos)

✔ OneWire - control devices (from Dallas Semiconductor) that use the One Wire protocol.
✔ XBee - for communicating with XBees in API mode
✔ Debounce - for reading noisy digital inputs (e.g. from buttons)
✔ Improved LCD library fixes LCD initialization bugs in official Arduino LCD library
✔ GLCD - graphics routines for LCD based on the KS0108 or equivalent chipset.
Generación de Frecuencias y AUDIO
✔ Tone - generate audio frequency square waves in the background on any microcontroller pin
Motores y PWM
✖ TLC5940 - 16 channel 12 bit PWM controller.

Relojes

✔ DateTime - a library for keeping track of the current date and time in software.

Utilidades

✔ PS2Keyboard - read characters from a PS2 keyboard.
✖ TextString aka String - handle strings
✖ PString - a lightweight class for printing to buffers
✖ Streaming - a method to simplify print statements

Librerías Especificas para PINGUINO

✔ Interrupt - Simple interrupt manipulation library (OnEvent, OnTimer0, OnChange, ...)
✔ PWM - Native PWM hardware support
✔ DS18B20 - specific one-wire temperature sensor library
✔ Zigbee - MRF24J40 wireless module
✔ Android ADB - provides an Android class to use Pinguino 32 with devices with Android 1.6 and up
✖ Android ADK - provides an Android class to use Pinguino 32 with devices with Android 2.3.4 and up
✔ RTCC - Real Time Clock and Calendar library
✔ USB - Native USB hardware support with CDC (USB-Serial), host and OTG (On-The-Go) support
✔ PCF8574 - I2C I/O expander library
✔ LCDI2C - for controlling liquid crystal displays (LCDs) with I2C protocol
✔ List - High-level library to manipulate lists
✔ DCF77 - Read and decode the atomic time broadcasted by the DCF77 radiostation
✔ printf - Print formatted data to output (CDC, LCD, Serial, ...)
✖ Charge Time Measurement Unit - Interface with capacitive touch sensors, Capacitance Measurement
✔ Oscillators - change CPU clock frequency on-the-fly
✔ Low-power - Run your Pinguino in low power modes (Watchdog, Sleep and Deep Sleep)
✔ ST7565
✔ PID 

Librerias de ARDUINO no Soportadas por PINGUINO (Tarea por hacerse)

✖ Firmata - for communicating with applications on the computer using a standard serial protocol.
✖ SoftwareSerial (NewSoftSerial) - for serial communication on any digital pins (Pinguino32 gives you up to 9 serial channels)
✖ Matrix - Basic LED Matrix display manipulation library
✖ Sprite - Basic image sprite manipulation library for use in animations with an LED matrix
✖ Messenger - for processing text-based messages from the computer
✖ Simple Message System - send messages between Arduino and the computer
✖ SSerial2Mobile - send text messages or emails using a cell phone (via AT commands over software serial)
✖ Webduino - extensible web server library (for use with the Arduino Ethernet Shield)
✖ X10 - Sending X10 signals over AC power lines
✖ SerialControl - Remote control other Arduinos over a serial connection
✖ LedControl - for controlling LED matrices or seven-segment displays with a MAX7221 or MAX7219.
✖ LedControl - an alternative to the Matrix library for driving multiple LEDs with Maxim chips.
✖ LedDisplay - control of a HCMS-29xx scrolling LED display.
✖ Metro - help you time actions at regular intervals (supported in Interrupt library)

Bien Amigos; espero que la información aquí expuesta haya resultado de utilidad, me despido hasta una próxima ocasión.

CONSTRUYA UN ANALIZADOR DE ESPECTRO CON ARDUINO Y WINAMP

Este articulo explica como hacer un analizador de espectro utilizando el reproductor de música WINAMP y el Plugin "gen_crownsoft_lcd...