jueves, 18 de octubre de 2012

Chip de sonido ISD1964

Con el fin de aplicarlo en proyectos con Arduino posteriormente vamos a estudiar el chip ISD1964.
El Sintetizador de sonido ISD1964 permite ser direccionado para grabar audio y luego reproducirlo en cada dirección de la memoria EEPROM interna donde fué grabado el mensaje.Como viene en encapsulado SOIC de montaje superficial, se elaboró,  mediante una tarjeta de circuito impreso,una adaptación a DIP para poder trabajarlo en la protoboard colocándole todos los elementos requeridos para su óptimo funcionamiento.Requiere de un micrófono ELECTRE polarizado, y Speaker de 16 ohmios, sirviendo los parlantes utilizados para Multimedia. La siguiente presentación en Power Point, describe resumidamente su arquitectura y forma de utilizarlo. ISD es la sigla de INFORMATION  STORE DEVICE  (Dispositivo para almacenar Información). Se pueden grabar y reproducir 16 mensajes de 4 segundos cada uno, para un total de 64 segundos, de ahí deriva el 64 en su rótulo. 













Los pines S0 (Start Input) y E0 (End Input) no se encuentran puenteadas en la plaqueta,por consiguiente hay que cablear externamente en el protoboard, y así mismo S1 con E1, S2 con E2, y S3 con E3. Quedan entonces sólo 4 pines de entradas de dirección que las podemos denominar A3,A2,A1 y A0, con los cuales podemos establecer las 16 direcciones: desde 0000 hasta 1111, donde en cada dirección podemos grabar y reproducir un mensaje de 4 segundos de duración, siempre y cuando se coloque una  resistencia de 80 KiloOhmios, como Rosc, y se pueda establecer la frecuencia de muestreo apropiada. En la plaqueta se dispone de una resistencia ya incorporada de 100 kilo-ohmios, con lo cual aumenta un poco el tiempo del mensaje a grabar pero disminuye así mismo la calidad del audio grabado. No se pudo obtener la resistencia de 80 K para montaje superficial. Para grabar se activa el pulsador REC habiendo seleccionado previamente la dirección y se habla a través de un micrófono ELECTRE sin pasarse de los 4 o 5 segundos . El Led con ánodo a Vcc, se debe encender mientras se está grabando.   Para escuchar lo grabado, en la misma dirección, se oprime el pulsador PLAYE (play Edge) o PLAYL (play Level). Un pulsador permite la reproducción por el flanco (se oprime y se suelta) y el otro pulsador lo hace por el nivel (debe permanecer el pulsador todo el tiempo oprimido en nivel bajo).

LABORATORIO:  Se trata mediante un Dip-Switch de 4 interruptores direccionar y grabar 16 mensajes.
 Al direccionar 0000 se debe grabar la palabra CERO en español e inglés, con 0001 la palabra UNO, y así sucesivamente hasta en 1111 grabar y reproducir la palabra QUINCE.




NOTA IMPORTANTE:  NO OLVIDE HACER EL PUENTE ENTRE A3 CON  A3, A2 CON A2, A1 CON A1 Y A0 CON A0. INDISPENSABLE PARA GRABAR EN TODAS LAS DIRECCIONES.

Veamos una fotografía del montaje realizado en el protoboard:

 .................................................................................................................................................................
Nota: El creador de este blog agradece públicamente a JOSE MIGUEL CEBALLOS FORERO y a su empresa KANANCE INGENIERIA de Mosquera,Cundinamarca, con su  excelente grupo de trabajo( Yamit, Michel, Edwin, Diego, Pedro, Yaneth),  por la colaboración en la importación del Chip, diseño, elaboración y pruebas de la tarjeta que nos permite trabajar con este interesante sintetizador de sonido. 
...................................................................................................................................................................

lunes, 17 de septiembre de 2012

Display de 7 segmentos con Arduino



Vamos a manejar un display de 7 segmentos cátodo común miniatura de referencia SM420561K para ser implementado en el protoboard.

El display dispone de 7 leds para los segmentos a, b, c, d, e, f, g tal como se muestra en la figura anterior.Además se dispone de un octavo led para el punto. La configuración de pines se indica también en la figura. Existen dos pines para el cátodo común que debe conectarse a GND (tierra).

El objetivo del presente proyecto es visualizar en el display los números del 0 al 9, y las letras A,B,C.D,E,F,
del sistema numérico  Hexadecimal.
El punto solo enciende con las letras.



En los almacenes especializados, como tienda de Robótica,  donde se suministran accesorios para trabajar con el Arduino venden  cables  de colores, muy útiles para llevar un orden y no confundirnos al  conectar el display a los pines del Arduino.
Conectores rápidos Macho - Macho 12" x 10
Nosotros conectamos cada segmento con un cable de color específico tal como se muestra en el siguiente esquema, disponiendo de una resistencia de 220 ohmios, 1/4 watio, en serie con cada diodo led, para limitar  la corriente en cada led y proteger los puertos del Arduino:


El programa en Arduino es el siguiente:


//Visualización en display de 7 segmentos de los caracteres del sistema hexadecimal

// Si el carácter es alfabético se enciende el punto decimal

// Los Leds  a,b,c,d,e,f,g y el punto decimal P se encienden al producirse un nivel lógico alto(HIGH) en el pin 

int i;
int j;
int a = 2;
int b = 3;
int c = 4;
int d = 5;
int e = 6;
int f = 7;
int g = 8;
int P=  9;
int retardo= 2000;

void setup( )
{
  pinMode ( a, OUTPUT);
  pinMode ( b, OUTPUT);
  pinMode ( c, OUTPUT);
  pinMode ( d, OUTPUT);
  pinMode ( e, OUTPUT);
  pinMode ( f, OUTPUT);
  pinMode ( g, OUTPUT);
  pinMode ( P, OUTPUT);

  }

 void loop ( )
 {
       
    for (i=0;i<=15;i++) 
   { 
     
     if (i == 0)   // 0
    {digitalWrite(a,HIGH);    //enciende el segmento a     
     digitalWrite(b,HIGH);    //enciende el segmento b          
     digitalWrite(c,HIGH);    //enciende el segmento c         
     digitalWrite(d,HIGH);    //enciende el segmento d          
     digitalWrite(e,HIGH);    //enciende el segmento e         
     digitalWrite(f,HIGH);    //enciende el segmento f         
     digitalWrite(g,LOW);    //apaga el segmento g     
     digitalWrite(P,LOW);   //apaga el punto P  
     delay(retardo);}
                  
    if (i == 1)    // 1
     {digitalWrite(a,LOW);    //apaga el segmento a  
     digitalWrite(b,HIGH);    //enciende el segmento b        
     digitalWrite(c,HIGH);    //enciende el segmento c         
     digitalWrite(d,LOW);    //apaga el segmento d          
     digitalWrite(e,LOW);    //apaga el segmento e         
     digitalWrite(f,LOW);     //apaga el segmento f       
     digitalWrite(g,LOW);    //apaga el segmento g     
     digitalWrite(P,LOW);   //apaga  el punto P
      delay(retardo);}
         
     if (i == 2)     //2
    {digitalWrite(a,HIGH);     //enciende el segmento a    
     digitalWrite(b,HIGH);     //enciende el segmento b         
     digitalWrite(c,LOW);     //apaga el segmento c         
     digitalWrite(d,HIGH);    //enciende el segmento d          
     digitalWrite(e,HIGH);    //enciende el segmento e        
     digitalWrite(f,LOW);     //apaga el segmento f        
     digitalWrite(g,HIGH);   //enciende el segmento g     
     digitalWrite(P,LOW);    //apaga el punto P
      delay(retardo);}
        
     if (i == 3)    //3
    {digitalWrite(a,HIGH);     //enciende el segmento a    
     digitalWrite(b,HIGH);     //enciende el segmento b         
     digitalWrite(c,HIGH);     //enciende el segmento c        
     digitalWrite(d,HIGH);     //enciende el segmento d          
     digitalWrite(e,LOW);     //apaga el segmento e       
     digitalWrite(f,LOW);      //apaga el segmento f       
     digitalWrite(g,HIGH);    //enciende el segmento g     
     digitalWrite(P,LOW);  //apaga el punto P
     delay(retardo);}
          
     if (i == 4)    //4
    {digitalWrite(a,LOW);      //apaga el segmento a    
     digitalWrite(b,HIGH);      //enciende el segmento b          
     digitalWrite(c,HIGH);      //enciende el segmento c         
     digitalWrite(d,LOW);      //apaga el segmento d         
     digitalWrite(e,LOW);      //apaga el segmento e         
     digitalWrite(f,HIGH);     //enciende el segmento f       
     digitalWrite(g,HIGH);    //enciende el segmento g     
     digitalWrite(P,LOW);    //apaga el punto P
     delay(retardo);}
      
     if (i == 5)    //5
    {digitalWrite(a,HIGH);     //enciende el segmento a  
     digitalWrite(b,LOW);      //apaga el segmento b          
     digitalWrite(c,HIGH);     //enciende el segmento c         
     digitalWrite(d,HIGH);    //enciende el segmento d          
     digitalWrite(e,LOW);     //apaga el segmento e       
     digitalWrite(f,HIGH);     //enciende el segmento f         
     digitalWrite(g,HIGH);    //enciende el segmento g     
     digitalWrite(P,LOW);    //apaga el punto P 
    delay(retardo);}    
       
     if (i == 6)    //6
    {digitalWrite(a,LOW);       //apaga el segmento a  
     digitalWrite(b,LOW);       //apaga el segmento b        
     digitalWrite(c,HIGH);      //enciende el segmento c         
     digitalWrite(d,HIGH);     //enciende el segmento d          
     digitalWrite(e,HIGH);     //enciende el segmento e         
     digitalWrite(f,HIGH);     //enciende el segmento f         
     digitalWrite(g,HIGH);    //enciende el segmento g    
     digitalWrite(P,LOW);    //apaga el punto P
     delay(retardo);}
         
     if (i == 7)     //7
     {digitalWrite(a,HIGH);     //enciende el segmento a
     digitalWrite(b, HIGH);     //enciende el segmento b          
     digitalWrite(c, HIGH);     //enciende el segmento c         
     digitalWrite(d,LOW);      //apaga el segmento d         
     digitalWrite(e, LOW);     //apaga el segmento e         
     digitalWrite(f, LOW);     //apaga el segmento f       
     digitalWrite(g, LOW);    //apaga el segmento g     
     digitalWrite(P,LOW);    //apaga el punto  P
     delay(retardo);}
   
     if (i == 8)      //8
    {digitalWrite(a,HIGH);      //enciende el segmento a  
     digitalWrite(b, HIGH);     //enciende el segmento b   
     digitalWrite(c, HIGH);      //enciende el segmento c    
     digitalWrite(d, HIGH);     //enciende el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, HIGH);     //enciende el segmento
     digitalWrite(g, HIGH);    //enciende el segmento g  
     digitalWrite(P,LOW);    //apaga el punto P 
      delay(retardo);}
    
    if (i == 9)      //9
    {digitalWrite(a,HIGH);     //enciende el segmento a  
     digitalWrite(b,HIGH);     //enciende el segmento b   
     digitalWrite(c,HIGH);     //enciende el segmento c     
     digitalWrite(d,LOW);     //apaga el segmento d         
     digitalWrite(e,LOW);     //apaga el segmento e       
     digitalWrite(f,HIGH);    //enciende el segmento f         
     digitalWrite(g,HIGH);   //enciende el segmento g    
     digitalWrite(P,LOW);   //apaga el punto P
    delay(retardo);}
      
     if (i == 10)      // A 
    {digitalWrite(a,HIGH);      //enciende el segmento a  
     digitalWrite(b, HIGH);     //enciende el segmento b   
     digitalWrite(c, HIGH);      //enciende el segmento c    
     digitalWrite(d, LOW);      //apaga el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, HIGH);     //enciende el segmento
     digitalWrite(g, HIGH);    //enciende el segmento g  
     digitalWrite(P,HIGH);   //enciende el punto P
      delay(retardo);}

     if (i == 11)       // B
    {digitalWrite(a, LOW);      //apaga el segmento a  
     digitalWrite(b, LOW);      //apaga el segmento b   
     digitalWrite(c, HIGH);      //enciende el segmento c    
     digitalWrite(d, HIGH);     //enciende el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, HIGH);     //enciende el segmento
     digitalWrite(g, HIGH);    //enciende el segmento g  
     digitalWrite(P,HIGH);     //enciende el punto P
      delay(retardo);}


     if (i == 12)       // C
    {digitalWrite(a, HIGH);      //enciende el segmento a  
     digitalWrite(b, LOW);       //apaga el segmento b   
     digitalWrite(c, LOW);       //apaga  el segmento c    
     digitalWrite(d, HIGH);      //enciende el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, HIGH);      //enciende el segmento
     digitalWrite(g, LOW);      //enciende el segmento g  
     digitalWrite(P,HIGH);     //enciende el punto P
     delay(retardo);}
     
   
     if (i == 13)       // D
    {digitalWrite(a, LOW);       //apaga el segmento a  
     digitalWrite(b, HIGH);      //enciende el segmento b   
     digitalWrite(c, HIGH);      //enciende el segmento c    
     digitalWrite(d, HIGH);     //enciende el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, LOW);      //apaga el segmento f
     digitalWrite(g, HIGH);    //enciende el segmento g  
     digitalWrite(P,HIGH);   //enciende el punto P
     delay(retardo);}

    
     if (i == 14)      //E
    {digitalWrite(a,HIGH);       //enciende el segmento a  
     digitalWrite(b, LOW);       //apaga el segmento b   
     digitalWrite(c, LOW);       //apaga el segmento c    
     digitalWrite(d, HIGH);     //enciende el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, HIGH);     //enciende el segmento
     digitalWrite(g, HIGH);    //enciende el segmento g  
     digitalWrite(P,HIGH);    //enciende  el punto P 
      delay(retardo);}

     
    if (i == 15)      //F
    {digitalWrite(a,HIGH);       //enciende el segmento a  
     digitalWrite(b, LOW);       //apaga el segmento b   
     digitalWrite(c, LOW);       //apaga el segmento c    
     digitalWrite(d, LOW);      //apaga el segmento d   
     digitalWrite(e, HIGH);     //enciende el segmento e       
     digitalWrite(f, HIGH);     //enciende el segmento
     digitalWrite(g, HIGH);    //enciende el segmento g  
     digitalWrite(P,HIGH);    //enciende  el punto P
     delay(retardo);}
               
     }
     }

Veamos una fotografía del montaje realizado:


La alimentación al Arduino UNO R3 se establece a través de una pila de 9 voltios recargable, con un plug de 2.1 mm, positivo al centro.
Se puede obtener un programa mucho más corto utilizando arreglos,tal como se muestra a continuación:


// Display de 7 segmentos,catodo común, en hexadecimal usando arreglos

void setup (){ 

  for (int X = 2; X <= 9; X++)
  pinMode(X,OUTPUT);
}

void loop (){

  int caracter = 0;
  while (caracter <= 15) {
  display7sg(caracter);
  caracter ++;
  delay (3000);
  }
  }

 void display7sg(int num){
 byte
 valores[]={B00111111,B00000110,B01011011,B01001111,B01100110,B01101101,B01111101,B00000111,B01111111,B01101111,B11110111,B11111100,B10111001,B11011110,B11111001,B11110001};
 for (int X = 0; X <= 7; X++) digitalWrite ( X + 2, bitRead(valores[num],X));
 }

















martes, 4 de septiembre de 2012

Documental presentado por los creadores del Arduino


La historia de Arduino y cómo ha nacido
La fotografía muestra al equipo creador del Arduino,entre ellos Massimo Banzi (Italiano) y David Cuartielles (Español), sus pioneros.
Presentamos un resumen de la historia de Arduino y cómo se creó este gran proyecto.  La información se ha extraído de la revista IEEE Spectrum:
Veamos algunas ideas principales del texto:
  • Arduino nació como un proyecto educativo en el año 2005 .
  • Su nombre viene del nombre del bar  Arduino donde Massimo Banzi pasaba algunas horas en Italia, el cual a su vez viene del nombre de un antiguo rey europeo allá por el año 1002.
  • Banzi dice que nunca surgió como una idea de negocio, es más nació por una necesidad de subsistir ante el eminente cierre del Instituto de diseño Interactivo IVREA en Italia.  Es decir, al crear un producto open hardware (de uso público) no tendría problemas legales por su uso. 
  • A la fecha se han vendido más de 250 mil placas en todo el mundo sin contar las versiones clones y compatibles.
  • Para su creación participaron estudiantes que desarrollaban sus tesis como Hernando Barragan (Colombiano) quien desarrolló la plataforma  Wiring con la cual se programa el microcontrolador.
  • Hoy en día con Arduino se pueden fabricar infinidad de prototipos y cada vez su uso se viene expandiendo más.  
  • Google ha apostado por el proyecto y ha colaborado en el Android ADK (Accesory Development Kit), una placa Arduino capaz de comunicarse directamente con spmartphones Android para obtener las funcionalidades del teléfono (GPS, acelerómetros, GSM, bases de datos) y viceversa para que el teléfono controle luces, motores y sensores conectados de Arduino.
  • El primer prototipo fue desarrollado en el instituto IVRAE pero aún no se llamaba Arduino, lo que se muestra en la siguiente fotografía.  
  • Para la producción en serie de la primera versión se tomaron en cuenta algunas consideraciones: De bajo precio, debía ser Plug and Play, utilizaron el color azul para marcar una diferencia con las placas convencionales, trabajar en todas las plataformas (Mac, Windows y Linux).
  • La primera producción fue de 300 unidades y se las dieron a los alumnos del Instituto IVRAE, (las ganancias fueron de sólo 1 Euro por placa), con el fin de que las probaran y empezaran a diseñar sus primeros prototipos.
  • Uno de los primeros proyectos fue un reloj alarma, el cual no se apagaría hasta que no te pararas de la cama.
  • Tom Igoe, profesor y padre de la computación física se unió al proyecto luego que se enterara del mismo a través de la web.  El ofreció su apoyo para desarrollar el proyecto a grandes escalas.
  • Hoy por hoy Arduino te permite crear cosas por ti mismo.
  • Varias universidades como Standford y Carnegie Mellon y el MIT usan Arduino en sus campus.

Les recomendamos ver el video del documental Arduino Español (28 min), dando click a continuación:

Documental sobre Arduino

lunes, 3 de septiembre de 2012

Simulador para el Arduino: virtualbreadboard

Los invito a observar el interesante video tutorial de un simulador para el Arduino que encontré de un Instituto Tecnologico en Bolivia:  http://youtu.be/TfemwzKfKrc

Este tutorial está dirigido a principiantes sin conocimientos previos de la plataforma Arduino que desean aprender el lenguaje de programación con la ayuda de un simulador.

Para más tutoriales similares ingresar a http://www.TecBolivia.com

NOTA: Hasta mediados del año 2011 el software "VirtualBreadboard" estaba disponible como descarga gratuita, por decisión de su desarrollador actualmente la licencia tiene un costo mínimo. Para más detalles ingresar a su sitio web en www.virtualbreadboard.com/


viernes, 20 de abril de 2012

Libro en PDF Arduino Básico: Tienda de robótica

Tienda de Robótica publicó en PDF un excelente libro que establece los fundamentos básicos tanto en electricidad y electrónica como en programación para comenzar a trabajar con Arduino.
Se puede descargar enhttp://www.tiendaderobotica.com/tienda/download/libro_arduino.pdf

lunes, 12 de marzo de 2012

jueves, 23 de febrero de 2012

Manual de programación

¿ COMO PROGRAMAR EL ARDUINO ?

Estimado estudiante:  Es importante familiarizarnos con la sintaxis del código para elaborar los "Sketchs" para programar el arduino. Para ello es muy importante tener siempre a la mano el manual que puede consultar en la red como  Manual de programación de Arduino,  traducido y adaptado por José Manuel Ruiz Gutierrez.

LED PARPADEANTE: VIDEO 2

Este video presenta un  led parpadeante con arduino, y luego variando su intensidad por PWM, pero sin explicar su código, lo cual si se hace en nuestro taller en la UAN.