miércoles, 28 de enero de 2015

¿ Qué es un Sistema Embebido ?

Es un sistema electrónico en el que confluyen hardware y software, específicamente diseñado para realizar tareas concretas. Normalmente en su hardware dispone de un microcontrolador como parte central.

 Además tiene unos periféricos para interconectarse con otros dispositivos.

 Puede ser que en el hardware en lugar de microcontrolador disponga de un DSP(Digital Signal Processor) o de FPGA (Field Programmable Gate Array).   

Los elementos del hardware ejecutan un programa llamado firmwareEl firmware es un bloque de instrucciones de máquina para propósitos específicos, grabado en una memoria, normalmente de lectura/escritura (EEPROM,Flash,etc), que establece la lógica de más bajo nivel que controla los circuitos electrónicos de un dispositivo de cualquier tipo. 
En resumen, un firmware es un software que maneja físicamente al hardware.
El programa BIOS de un computador es un firmware cuyo propósito es activar una máquina desde su encendido y preparar el entorno para cargar un sistema operativo en la memoria RAM.
El término  firmware   significa "software firma, fijo o sólido"

En el caso de una lavadora, esta se compone de un chasis, de motores eléctricos y bombas de agua, de un frontal con varias teclas para que el usuario pueda poner en marcha la lavadora, contiene temporizadores y válvulas eléctricas que controlan el flujo del agua, y más componentes. 
En este conjunto nos podemos fácilmene imaginar la necesidad un circuito electrónico que contenga los diferentes programas de lavado del que disponga el electrodoméstico. Y por razones obvias, esta electrónica no sería otra cosa que un microcomputador o microcontrolador, especialmente diseñado para dicho fin. Por lo tanto pdemos hablar de un sistema embebido o empotrado en el interior de la lavadora.

Desde 1996 la mayoría de los automóviles han empleado una computadora a bordo y varios sensores para detectar problemas mecánicos. Los vehículos modernos también emplean sistemas controlados por computador ABS y sistemas de control de transmisión operados por computadora. El conductor puede también recibir información "in-dash" mientras conduce de esta manera, como por ejemplo lecturas en tiempo real de la economía del combustible y de la presión del neumático. La mayoría del firmware del vehículo puede ser actualizado en un distribuidor local autorizado.


El sistema antibloqueo de ruedas o frenos antibloqueo,  Antiblockiersystem (ABS), es un dispositivo utilizado en vehículos  que hace variar la fuerza de frenado para evitar que los neumáticos pierdan la adherencia con el suelo.


El sistema fue desarrollado inicialmente para los aviones, los cuales acostumbran a tener que frenar fuertemente una vez han tomado tierra. En 1978 Bosch hizo historia cuando introdujo el primer sistema electrónico de frenos antibloqueo. Esta tecnología se ha convertido en la base para todos los sistemas electrónicos que utilizan de alguna forma el ABS, como por ejemplo los controles de tracción y de estabilidad.
El ABS funciona en conjunto con el sistema de frenado tradicional. 


Consiste en una bomba que se incorpora a los circuitos del líquido de freno y en unos detectores que controlan las revoluciones de las ruedas. Si en una frenada brusca una o varias ruedas reducen repentinamente sus revoluciones, el ABS lo detecta e interpreta que las ruedas están a punto de quedar bloqueadas sin que el vehículo se haya detenido. Esto quiere decir que el vehículo comenzará a deslizarse sobre el suelo sin control, sin reaccionar a los movimientos del volante. Para que esto no ocurra, los sensores envían una señal al Módulo de Control del sistema ABS, el cual reduce la presión realizada sobre los frenos, sin que intervenga en ello el conductor. Cuando la situación se ha normalizado y las ruedas giran de nuevo correctamente, el sistema permite que la presión sobre los frenos vuelva a actuar con toda la intensidad. El ABS controla nuevamente el giro de las ruedas y actúa otra vez si éstas están a punto de bloquearse por la fuerza del freno. En el caso de que este sistema intervenga, el procedimiento se repite de forma muy rápida, unas 50 a 100 veces por segundo, lo que se traduce en que el conductor percibe una vibración en el pedal del freno.
El ABS permite que el conductor siga teniendo el control sobre la trayectoria del vehículo, con la consiguiente posibilidad de poder esquivar posibles obstáculos mediante el giro del volante de dirección.

Arduino permite implementar sistemas embebidos de forma sencilla, debido al uso de las tarjetas de expansión o Shields  adicionadas a la tarjeta principal.


Así se permite que el desarrollador se concentre en la programación del firmware y en la funcionalidad del sistema sin preucuparse del hardware requerido.
El firmware es el código de los elementos programables ya sea el microcontrolador, DSP o FPGA.
Se escribe como texto en un determinado lenguaje, por ejemplo C, VHDL,etc. El código del firmware es compilado y convertido al código de máquina del elemento central del sistema embebido.


SISTEMAS INTEGRADOS CON ARDUINO -JOSE RAFAEL LAJARA VIZCAINO- LIBRO DE TEXTO

En este libro se intentan plasmar todas las facetas que integra el Arduino, desde la presentación del hardware en el que se basa la tarjeta hasta las herramientas de generación del código integradas en el entorno de desarrollo. Conjuntamente con la presentación de los contenidos de cada sección, el libro muestra multitud de ejemplos de diseño que exponen de forma clara toda la potencia y alcance de esta tecnología. Se presenta toda la información necesaria para desarrollar aplicaciones complejas a partir de los bloques de diseño básicos.


El lector puede descargar el entorno de desarrollo desde la página web del equipo Arduino (http://arduino.cc/) para compilar los ejemplos expuestos en el texto. Con todo ello el lector podrá construir sus propios sistemas basados en Arduino y convertir sus ideas en dispositivos funcionales, ya sea con un objetivo profesional, educacional o de entretenimiento.



martes, 16 de septiembre de 2014

Alarma con Reed Switch

Un reed switch  es un interruptor eléctrico activado por un campo magnético.
Cuando los contactos están normalmente abiertos se cierran en la presencia de un campo magnético; cuando están normalmente cerrados se abren en presencia de un campo magnético. Fue inventado por W. B. Elwood en 1936 cuando trabajaba para Laboratorios Bell.
El campo magnético puede estar generado por un imán permanente o por una bobina.

Se pueden encontrar en los sensores de las puertas y ventanas de las alarmas antirrobo, el imán va unido a la puerta y el reed switch al marco.
Vamos a implementar con Arduino una Alarma. Cuando el Reed Switch está en nivel alto debido a la presencia del imán la alarma está desactivada, pero al quitar el imán la alarma se activa haciendo sonar un Buzzer Piezo eléctrico y parpadear un Led.
Zumbadorbuzzer en inglés, es un transductor electroacústico que produce un sonido o zumbido continuo o intermitente de un mismo tono.  Es un tipo de altavoz basado en la propiedades de los cristales piezoeléctricos (poliéster o cerámica), que se deforman cuando se les aplica una tensión entre sus caras y que actuando como transductor electroacústico es utilizado para la reproducción de sonido.

Utilizamos el siguiente esquema el cual fue elaborado con el programa FRITZING el cual se puede descargar gratuitamente en http://fritzing.org/download/

El programa para el arduino es el siguiente:
El lector puede verificar que el programa responde al siguiente diagrama de flujo:

Nota: Para que se pueda leer un nivel alto (HIGH)  en el Reed Switch debe estar colocado el imán, de lo contrario se leerá en el un nivel bajo (LOW).

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/