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.

domingo, 11 de junio de 2017

CONTROL DE PANELES P10 CON ARDUINO.

El panel P10 es un arreglo de 512 pixels que forman una matriz de 16 filas x 32 columnas, gracias a las librerías que disponemos para ARDUINO, resulta muy fácil que empecemos a experimentar con el. En este articulo se explican algunos detalles que te ayudaran a conectar y programar el panel P10 con la tarjeta ARDUINO UNO.


empecemos...

Materiales:
  • Arduino UNO R3 BOARD
  • Juego de cables DUPONT (macho-hembra)
  • Panel P10

PASO 1: Conectar el panel a la placa ARDUINO;

Puede utilizar cable DUPONT


Opcionalmente puede construirse un conector como se muestra en la figura siguiente:


La conexión entre el ARDUINO y la matriz se muestra en la figura siguiente:




PASO 2: Instalar las librerías DMD-master.h, DMD2.h y timerOne.h utilizando el IDE de ARDUINO; 


PASO 3: Abrir ejemplo DMD DEMO y grabarlo en ARDUINO UNO



Si todo salió bien la matriz deberá mostrar algunos caracteres números y figuras; como se ve en el siguiente vídeo:



PASO 4: Si nota que los LED en su matriz están parpadeando demasiado, ajuste mediante código el tiempo de desborde del timer1; experimente con valores entre 1000 y 5000 hasta encontrar el punto donde mejor trabaja su matriz



Como conectar más paneles para formar una matriz más grande

Puede seguir conectando más paneles uno detrás de otro. Sin embargo; debe tener en cuenta que le hará falta alimentar a las matrices con una fuente de alimentación externa de 5V y que la corriente necesaria para alimentar el circuito se calcula por cada matriz 2A. Por ejemplo si desea alimentar cuatro matrices P10 necesitara una fuente de alimentación externa de 5V/8A.


Algunas instrucciones soportadas por la librería DMD.h

1. Código para programar uno, dos, tres, etc. panéles horizontales
#define DISPLAYS_ACROSS 1 // para un panel horizontal
#define DISPLAYS_ACROSS 2 // para dos paneles horizontales
#define DISPLAYS_ACROSS 3 // para tres paneles horizontales, etc…
#define DISPLAYS_DOWN 1 // para un panel vertical
#define DISPLAYS_DOWN 2 // para dos paneles verticales
#define DISPLAYS_DOWN 3 // para tres paneles verticales, etc…
DMD dmd(DISPLAYS_ACROSS, DISPLAYS_DOWN);
2. Limpiar (Borrar) Pantalla
dmd.clearScreen(true); //Apaga todos los pixels
dmd.clearScreen(false); //Enciende todos los pixels
3. Seleccionar un Tipo de Letra
#include "SystemFont5x7.h"
#include "Arial_black_16.h"
dmd.selectFont(SystemFont5x7) //Para fuente pequeña
dmd.selectFont(Arial_Black_16); //Para fuente grande
4. Dibujar un carácter en la posición (x, y) 
dmd.drawChar(x,y,'B',GRAPHICS_NORMAL ); //Dibuja el carácter “B” en la posición (x,y)
dmd.drawChar( 10, 5, 'A', GRAPHICS_NORMAL ); //Dibuja el carácter “A” en la posición (10,5)
5. Dibujar N caracteres en la posición (x, y)
dmd.drawString( 0,0, "Hello,", 5, GRAPHICS_NORMAL ); //Escribe 5 caracteres empezando por la posición 0,0
dmd.drawString( 2,9, "world,", 5, GRAPHICS_NORMAL ); //Escribe 5 caracteres en la posición 2,9
6. Encender/Apagar un pixel en la posición (x, y)
dmd.writePixel( 5,6, GRAPHICS_NORMAL,1);// Enciende el pixel
dmd.writePixel( 5,6, GRAPHICS_NORMAL,0); // Apaga el pixel
7. Gráfico de Círculos, lineas y rectángulos
dmd.drawCircle( x, y, r, GRAPHICS_NORMAL ); //Dibujar un circulo con centro (x, y) y radio r
dmd.drawLine( x1, y1, x2, y2, GRAPHICS_NORMAL );// Dibujar una línea desde (x1, y1) hasta (x2, y2)
dmd.drawBox(x1, y1, x2, y2, GRAPHICS_NORMAL ); //Dibujar una caja rectangular con esquinas (x1, y1) y (x2, y2)
dmd .drawFilledBox (x1 , y1 , x2 , y2 , GRAPHICS_NORMAL ); //Dibujar un rectángulo relleno con esquinas (x1, y1) y (x2, y2)

Ejemplos  de programas para ARDUINO utilizando la libreria DMD.h

A continuación muestro un video conteniendo tres ejemplos que le permitirá iniciarse con la matriz y su respectivo código




Ejemplo 1. Gráfico de lineas, rectángulos y círculos.

/* Este código hace una demostración de como gráficar figuras utilizando una matriz P10 y ARDUINO UNO
//CONEXIONES
//ARDUINO________________DMD
//PIN9___________________OE
//PIN6___________________A
//PIN7___________________B
//PIN13__________________SLK
//PIN8___________________SCLK
//PIN11__________________SPI
*/

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

DMD display(1,1);    //Un panel horizontal 
//DMD display(2,1);  //Descomente si va utilizar dos paneles horizontales 
//DMD display(3,1);  //Descomente si va utilizar tres paneles horizontales

void ScanDMD()

  display.scanDisplayBySPI();
}

void setup() {
   Timer1.initialize( 3000 );           
   Timer1.attachInterrupt(ScanDMD);    
}

 void loop(){

    display.clearScreen(true);                        //borra pantalla  
    display.drawBox(14,7,17,9, GRAPHICS_NORMAL);      //dibuja un rectangulo en el centro
    delay(1000);

    for(int r=0;r<8;r++){
      display.clearScreen(true);                      //borra pantalla  
      display.drawCircle(15,8,r, GRAPHICS_NORMAL);    //dibuja un circulo en el centro y va creciendo su radio
      delay(1000);
      }
      
    display.clearScreen(true);                        //borra pantalla 
    display.drawLine(0,0,31,15, GRAPHICS_NORMAL);     //dibuja linea diagonal      
    display.drawLine(0,15,31,0, GRAPHICS_NORMAL);     //dibuja otra linea diagonal  
    delay(1000);
    }

Ejemplo 2. Escritura de Texto

/* Este codigo hace una demostracion de como escribir caracteres y cadenas de texto
//CONEXIONES:
//ARDUINO________________DMD
//PIN9___________________OE
//PIN6___________________A
//PIN7___________________B
//PIN13__________________SLK
//PIN8___________________SCLK
//PIN11__________________SPI
*/

#include <DMD.h>
#include <TimerOne.h>
#include "SystemFont5x7.h"
#include "Arial_black_16.h"
DMD display(1,1);    //Un panel horizontal 
//DMD display(2,1);  //Descomente si va utilizar dos paneles horizontales 
//DMD display(3,1);  //Descomente si va utilizar tres paneles horizontales

void ScanDMD()

  display.scanDisplayBySPI();
}

void setup() {
   Timer1.initialize( 3000 );           
   Timer1.attachInterrupt(ScanDMD);    
}

 void loop(){
   display.clearScreen(true);                          //borra pantalla  
   display.clearScreen( true );
   display.selectFont(Arial_Black_16);
   display.drawChar(  0,  1, '2', GRAPHICS_NORMAL );
   display.drawChar(  7,  1, '3', GRAPHICS_NORMAL );
   display.drawChar( 17,  1, '4', GRAPHICS_NORMAL );
   display.drawChar( 25,  1, '5', GRAPHICS_NORMAL );
   display.drawChar( 15,  1, ':', GRAPHICS_OR     );   // enciende puntos
   delay( 1000 );
   display.drawChar( 15,  1, ':', GRAPHICS_NOR    );   // apaga puntos
   delay( 1000 );
   display.drawChar( 15,  1, ':', GRAPHICS_OR     );   // enciende puntos 
   delay( 1000 );
   display.drawChar( 15,  1, ':', GRAPHICS_NOR    );   // apaga puntos
   delay( 1000 );
   display.drawChar( 15,  1, ':', GRAPHICS_OR     );   // enciende ppuntos
   delay( 1000 );
   display.clearScreen( true );
   display.selectFont(System5x7);                      // selecciona letra pequeña
   display.drawString(5,0,"hola",4,  GRAPHICS_NORMAL); // escribe una cadena de 4 letras
   display.drawString(1,9,"Mundo",5, GRAPHICS_NORMAL); // escribe una cadena de 5 letras
   delay( 2000 );
    }

Ejemplo 3. Desplazamiento del Display

/* Este codigo hace una demostracion de como escribir texto y rotar en pantalla
//CONEXIONES:
//ARDUINO________________DMD
//PIN9___________________OE
//PIN6___________________A
//PIN7___________________B
//PIN13__________________SLK
//PIN8___________________SCLK
//PIN11__________________SPI
*/
#include <SPI.h>        
#include <DMD.h>        
#include <TimerOne.h>   
#include "SystemFont5x7.h"
#include "Arial_black_16.h"
#define DISPLAYS_ACROSS 1 /// si desea que funcione con dos paneles tiene que cambiar a #define DISPLAYS_ACROSS 2
#define DISPLAYS_DOWN 1
char *MSG = "AZOGUES";
DMD dmd(DISPLAYS_ACROSS, DISPLAYS_DOWN);

void ScanDMD()

  dmd.scanDisplayBySPI();
}

void setup(void)
{
  Timer1.initialize(300);
  Timer1.attachInterrupt(ScanDMD); 
  Serial.begin(115200);
  //dmd.selectFont(SystemFont5x7); //letra pequeña
  dmd.selectFont(Arial_Black_16);  //letra grande
}

void loop(void)
{
  MSG = "Probando matrices P10 16x32Pixels, dinoelectro.blogspot.com...  1234567890...  ABCDEFGHIJKLMNOPQRSTUVWXYZ...     ";
  dmd.clearScreen(true);
  dmd.drawMarquee(MSG,strlen(MSG),(32*DISPLAYS_ACROSS)-1,0);
  long start=millis();
  long timer=start;
  
  while(1){
  if ((timer+20)< millis()){
  dmd.stepMarquee(-1,0);
  timer=millis();
  }
  
  }
}

domingo, 4 de junio de 2017

CONTROL DMX512

DMX Es una tecnología estándar creada para el control de artefactos electrónicos utilizados en el mundo del espectáculo; es ampliamente requerida por los arquitectos, ingenieros, DJs, individuos inmersos en el mundo de las artes escénicas, diseñadores, dueños de bares, discotecas, salones de recepciones, balnearios, hoteles… etc. Todas las personas interesadas en decorar ambientes con luz y sonido deberían considerar esta tecnología


Un sistema DMX consiste básicamente en un dispositivo TRANSMISOR de comandos y varios dispositivos RECEPTORES que interpretan dichos comandos para realizar una determinada acción.

¿Qué puede hacer con DMX?  

Puede comandar a distancia de forma manual o programada, luces de discoteca, cámaras de espuma y humo, paneles RGB, luces laser, cabezales roboticos, etc.

El Universo DMX

Un universo DMX se compone de 512 canales


Existen en el mercado Transmisores desde 127 canales; incluso hay aquellos que pueden controlar hasta varios universos a la vez.

Existe también paquetes de software (algunos de pago y otros gratuitos) que permiten que el computador haga las veces de controlador DMX; Para ello es necesario de un adaptador que permita la transmisión de comandos hasta los receptores DMX


Receptores DMX

Una amplia gama de receptores con tecnología DMX se encuentra disponibles en el mundo de de la iluminacion , a continuación se lista algunas posibles aplicaciones que se les puede dar:
  • Control de lámparas de corriente continua y alterna 
  • Apertura y cierre de puertas, ventanas, telones 
  • Sistemas de ventilación y aire acondicionado
  • Gobierno de servomotores, motores de paso, motores de corriente alterna y continua  
  • Control de paneles RGB 
Los receptores; dependiendo del modelo, pueden hacer uso de 1, 2 , 3,.... n canales de la trama DMX. En la mayoria de los casos un receptor no ocupa mas de seis canales, haciendo posible que un solo transmisor pueda comandar muchísimos receptores independientemente

Conexión entre equipos DMX

Como ya se mencionó anteriormente un sistema DMX consiste de una consola que transmite comandos llamada TRANSMISOR y varios RECEPTORES que interpretan dichos comandos, El primer RECEPTOR se conecta al TRANSMISOR y los demás se van conectando uno tras de otro. La distancia entre dispositivo y dispositivo no debe superar los 1000m (si se desea alcanzar mayores distancias deberá hacer uso de equipos repetidores de señal). Una resistencia de 120 OHM se recomienda conectar entre el pin 3 y pin 1 del último dispositivo evitar que corrientes parasitas y/o ruido electromagnético provoquen interferencia.


Cada dispositivo receptor tiene un conector XLR-3 macho para recibir la trama llamado DMX-In y un conector XLR-3 hembra para retransmitir la trama llamado DMX-Out. En raras ocaciones tambien se puede encontrar equipos que utilizan conectores del tipo XLR-5 que tienen el mismo pin-out de los XLR-3 mas dos señales adicionales es decir 1.Tierra, 2.señal-, 3.señal+ 4.señal-, 5.señal+


Los cables que conectan un dispositivo con otro se construyen conectando los pines punto a punto, tanto si la conexión es con conectores XLR-3 como si es con contectores XLR-5


Debido al éxito y aceptación que ha tenido esta tecnología han empezado a fabricarse equipos para comunicacion inalámbrica ya sea por transmisión bluetooth, radiofrecuencias, WI-FI,  etc.   Incluso se desarrollan equipos con tecnologia para gobierno a través de Internet.

Transmisor y un Reeceptor DMX con ARDUINO.
......pendiente....
Gracias!

sábado, 3 de junio de 2017

CONTROLADOR RGB CON ARDUINO




Este proyecto es sencillo de realizar, se trata de un controlador de luz RGB que  permite obtener distintas tonalidades de luz que resultan de la mezcla de los colores primarios ROJO, VERDE Y AZUL.

Hay muchas aplicaciones que podemos dar a este circuito; Quizás una de las mas interesantes que he encontrado es el que propone Rajarshi Roy en su blog; que consiste en encender al LED RGB con el mismo color que proyecta la pantalla del computador; Así por ejemplo, cuando vemos una película, podemos hacer que nuestro cuarto se ilumine con los mismos colores que están en escena. A continuación dejo un video de como funciona:


A continuación explico como construirlo...

Materiales

  • TRES RESISTENCIAS 220 OHM
  • UN LED RGB
  • PLACA ARDUINO UNO R3

Circuito:


Para explicar como funciona este proyecto lo he dividido en dos etapas;

La primera Etapa corresponde a una aplicación desarrollada en processing que se encarga de hacer un análisis del color RGB que esta proyectando el monitor; seguidamente envía la información al puerto serie del computador; Los datos enviados tienen el siguiente formato:

0xFF 0xRR 0xGG 0xBB

donde el primer byte siempre es 0xFF y sirve para indicar el inicio de la trama; los siguientes bytes son hexadecimales que indican la intensidad de los colores rojo, verde y azul respectivamente; a continuación pongo el código del programa desarrollado en processing
//Developed by Rajarshi Roy
import java.awt.Robot; //java library that lets us take screenshots
import java.awt.AWTException;
import java.awt.event.InputEvent;
import java.awt.image.BufferedImage;
import java.awt.Rectangle;
import java.awt.Dimension;
import processing.serial.*; //library for serial communication
Serial port; //creates object "port" of serial class
Robot robby; //creates object "robby" of robot class
void setup()
{
  port = new Serial(this, Serial.list()[0],9600); //set baud rate
  size(100, 100); //window size (doesn't matter)
  try //standard Robot class error check
  {
    robby = new Robot();
  }
  catch (AWTException e)
  {
    println("Robot class not supported by your system!");
    exit();
  }
}
void draw()
{
  int pixel; //ARGB variable with 32 int bytes where
  //sets of 8 bytes are: Alpha, Red, Green, Blue
  float r=0;
  float g=0;
  float b=0;
  //get screenshot into object "screenshot" of class BufferedImage
  BufferedImage screenshot = robby.createScreenCapture(new Rectangle(new Dimension(1368,928)));
  //1368*928 is the screen resolution
  int i=0;
  int j=0;
  //1368*928
  //I skip every alternate pixel making my program 4 times faster
  for(i =0;i<1368; i=i+2){
    for(j=0; j<928;j=j+2){
      pixel = screenshot.getRGB(i,j); //the ARGB integer has the colors of pixel (i,j)
      r = r+(int)(255&(pixel>>16)); //add up reds
      g = g+(int)(255&(pixel>>8)); //add up greens
      b = b+(int)(255&(pixel)); //add up blues
    }
  }
  r=r/(684*464); //average red (remember that I skipped ever alternate pixel)
  g=g/(684*464); //average green
  b=b/(684*464); //average blue
  port.write(0xff); //write marker (0xff) for synchronization
  port.write((byte)(r)); //write red value
  port.write((byte)(g)); //write green value
  port.write((byte)(b)); //write blue value
  delay(10); //delay for safety
  background(r,g,b); //make window background average color
}

En la segunda etapa tenemos al firmware que debe grabar en ARDUINO,  el mismo que se encarga de recibir los datos que llegan desde el puerto serie y de acorde con ellos genera las correspondientes señales PWM que controlan al LED RGB. A continuación el código:
//Developed by Rajarshi Roy int red, green, blue; //red, green and blue values int RedPin = 3; //Red pin 9 has a PWM int GreenPin = 5; //Green pin 10 has a PWM int BluePin = 6; //Blue pin 11 has a PWM int power = 4; void setup() { Serial.begin(9600);   //initial values (no significance)   int red = 255;   int blue = 255;   int green = 255; pinMode(4,OUTPUT); digitalWrite(4,LOW); } void loop() { //protocol expects data in format of 4 bytes   //(xff) as a marker to ensure proper synchronization always   //followed by red, green, blue bytes   if (Serial.available()>=4) {     if(Serial.read() == 0xff){       red = Serial.read();       green= Serial.read();       blue = Serial.read();     }   }   //finally control led brightness through pulse-width modulation   analogWrite (RedPin, red);   analogWrite (GreenPin, green);   analogWrite (BluePin, blue);   delay(10); //just to be safe }

Dejo un vídeo que muestra el funcionamiento:


Gracias!

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