martes, 8 de febrero de 2011

Salida VGA con Arduino

Bueno ya tocaba escribir la primera entrada del 2011. Pese al parón con este blog no he parado de cacharrear con Arduino y os traigo una de las cosas mas vistosas con las que he tratado, una interfaz VGA para Arduino.

Investigando sobre el tema me tope con un modulo bastante baratillo que ofrecía soporte para Arduino, con eso quiero decir que el propio fabricante te ofrece documentación, librerías e incluso ejemplos. Voy a presentároslo:

MicroVGA



Modo texto
Resolución: 80x25
16 colores
Resolución física: 800x600 a 60Hz
Mas información en su página (ingles): http://www.microvga.com/
Precio: 23,90 €

Vamos a conectarlo a nuestra placa Arduino:
Información extraída de: http://www.microvga.com/arduino

Vamos a conectar antes de empezar únicamente la alimentación de 5V que corresponde GND al pin 1 y +5V al pin 2 empezando por la izquierda en la imagen. Ahora conectaremos un teclado PS/2 y un monitor al MicroVGA. Encendemos todo y cortocircuitamos los dos bornes de SETUP (a la derecha de la imagen). Nos aparecerá el menú de configuración de MicroVGA, tal y como muestra este vídeo:


Una vez seleccionado el modo de comunicación SPI. Ya podemos apagar y completar el conexionado según la siguiente tabla:


MicroVGASímboloArduino
1GNDArduino GND
2+5VArduino 5V
3+3V3No usado
4CS#Arduino Digital 8
5SCKArduino Digital 13
6RDY#Arduino Digital 9
7MISOArduino Digital 12
8MOSIArduino Digital 11


Vamos a cargar el programa de prueba:


El primer paso va a ser descargar las librerías que proporciona el fabricante de http://microvga.com/MicroVGA-arduino.zip.


Nota: Si vamos a trabajar con un Arduino uno/pro o mega/mega2560 habrá que sustituir el archivo arduino_uvga.c por este.
https://docs.google.com/leaf?id=0B2_QaX8F73zyOTgzY2MyMDUtMGI5My00YWQyLWEyMTktODJmNTY5ODRlN2I4&hl=en


Una vez tengamos la librería la descomprimimos en la carpeta libraries de nuestro IDE. Reseteamos el IDE.


Para cargar el ejemplo tendremos que hacer: File-Examples-MicroVGA-tetris. Nos aparecerá el código. Solo queda cargarlo en nuestra placa y jugar!


Pongo el vídeo que acabo de realizar como mi primera prueba :-D


martes, 28 de septiembre de 2010

Arrancando motores (II)

Saludos lectores,

Hace ya un tiempo, empecé hablando de motores en una anterior entrada. En esa ocasión vimos como manejar de una manera sencilla un servomotor. Aprovechando mi experiencia con el último proyecto voy a hablar de el manejo de motores de corriente continua (DC). Veamos primero que es un motor DC.



Sin entrar en mucha profundidad, que para eso esta el artículo en wikipedia, un motor DC consta de dos conexiones una positiva y otra negativa, dependiendo de la polaridad cambiará el sentido de giro. Y dependiendo también de la intensidad que le subministremos, variará su velocidad. Aparte de esto, en el sentido práctico tenemos que tener en cuenta otros aspectos.

  • La bobina tiene autoindución. Seguramente todos habremos visto al enchufar o desenchufar un equipo electrónico con transformador, un chispazo. Esto se debe a que las bobinas por sus características electromagnéticas ofrecen resistencia a la variación de intensidad de corriente. Si la variación de corriente es muy alta y el tiempo de transición es muy bajo se producirá un arco eléctrico que produce tensiones pico muy altas. Existen numerosos sistemas de protección ante esto, incluso Arduino incluye algunos, pero no es buena idea conectar un motor DC directamente a los pines de salida, y menos aún conectarlos a una salida PWM.
  • Las salidas solo otorgan voltajes positivos de 5V. Esto puede suponer dos problemas. En el caso de que queramos invertir el sentido de giro del motor no vamos a poder cambiar la polaridad a través de los pines y en el caso de que el motor necesite mas o menos alimentación que la otorgada de 5V.
Estos problemas se solucionan mediante un circuito intermedio entre el dispositivo de control, en este caso Arduino, y el motor DC. Este circuito recibe el nombre de puente H. Existen varios tipos de circuitos integrados que incluyen este circuito, voy a hablar de uno en concreto, el l293d, que soluciona los problemas de alimentación, polaridad y protección electrónica.



Podemos ver su datasheet para mas información. Con este dispositivo conseguimos que mediante solo dos salidas con PWM podamos regular la velocidad, cambiando el valor de salida analógica de estas. Y el sentido, seleccionando una salida u otra. Veamos como es el esquema para dos motores, tal y como he usado para mi proyecto.

  
Hay que aclarar que la alimentación usada corresponde a los 5V que otorga la placa. También hay que prestar atención que muchos motores necesitan mucha intensidad para funcionar, es fácil, que el integrado se caliente en exceso. En ese caso sería recomendable acudir a un puente H mas potente, como el l298 que admite hasta 3A(aunque no incluye circuitos de protección de autoinductancia), e incluso, añadirle un sistema de disipación.


sábado, 11 de septiembre de 2010

En todo este tiempo...

Saludos lectores

Hacia tiempo que no me pasaba por el blog. Mis estudios y mi trabajo me han mantenido alejado de aquí pero eso no quiere decir que haya parado de investigar. Me gustaría presentaros mi proyecto mas importante con Arduino.

Se trata de un seguidor de lineas, os pongo una foto:


A simple vista se ve que he utilizado elementos bastante rudimentarios:
  • La base mecánica pertence a un kit de montaje llamado Rana Robot de la marca Velleman de la cual solo aprovechamos la base con los motores y las ruedas.
  • Para el montaje electrónico no lo he construido sobre un PCB sino que he montado una protoboard de tamaño reducido.
  • En ella se conectan las resistencias del circuito de los sensores de infrarrojos y el puente H, este último se trata de un integrado llamado l293 de Texas Intruments que toma las salidas PWM y dependiendo de ellas aplica la polaridad y voltaje a los motores.

  • Dos sensores de infrarrojos CNY70 que constan cada uno de un led emisor de infrarrojos y un fototransistor montados sobre una protoboard para soldadura de topos.

  • Cable, cinta aislante, una pila de 9V y un conector apropiado para Arduino.
Aquí un video en funcionamiento:



    Esta entrada es a nivel introductorio de lo que espero que sean una serie de entradas en las cuales explique los aspectos mas específicos de este proyecto.

      miércoles, 17 de febrero de 2010

      Arrancando motores (I)

      Bueno, después de un parón vuelvo a estar aquí con nuevos chismes, me he centrado ahora con el tema de motores, tanto DC como servos. Hoy toca hablar de servos.

      En el tema de servos no he investigado demasiado, me compre por internet este servo, que es de los mas pequeñitos, pero aun así hace su fuerza y no me maté mucho la cabeza con el tema del código, utilicé el que viene de ejemplo con el compilador, el llamado Sweep, que lo que hace principalmente es hacer girar el servo 180º de un lado a otro.

      Montaje:


      ¿No es muy complicado no? :-)

      Partes del código a destacar:
      • Definimos el objeto "motor":
        Servo myservo;
      • Asignamos el pin de control del servo :
        myservo.attach(9);
      • El ángulo lo controlamos asi:
        myservo.write(posición);

      Bueno, la verdad es que no es una entrada muy extensa, pero me estoy reservando para la siguiente que sera bastante mas divertida. Os pongo un vídeo para ir abriendo boca.

      viernes, 29 de enero de 2010

      Theremin con sensor de luz (1)

      Saludos! Aquí estoy otra vez y vengo con mi nuevo invento, se trata de intentar imitar un theremin con un sensor de luminosidad. No esperéis ninguna maravilla. Para que os hagáis una idea aquí hay un personaje que incluso esta peor que yo y lo ha hecho con un sensor de ultrasonidos.



      Bueno al lío con el montaje. Los ingredientes son:

      • Un altavoz o piezo (Yo he llegado a conectarlo a la entrada de audio del PC, así que lo primero que tengáis).
      • Un potenciómetro para controlar el volumen, con una resistencia mas bien baja.
      • Una resistencia sensible a la luminosidad.
      • Una resistencia de 10 kOhm para conectar a masa el luminómetro.
      Y se conectan tal que así:


      Chulo eeeee.

      Bueno vamos con el código:

      const int speaker=7;
      const int lum=0;

      int valor=0;

      void setup(){
      pinMode(speaker,OUTPUT);
      }
      void loop(){

      valor = analogRead(lum)*4;
      //Podemos cambiar el valor por el que multiplica para cambiar el tono

      for(int i=0;i<50;i++){

      digitalWrite(speaker,HIGH);
      delayMicroseconds(valor);
      digitalWrite(speaker,LOW);
      delayMicroseconds(valor);
      }
      }

      Como podéis ver, el código es muy sencillo, consiste en un bucle que lee la entrada del luminómetro, ese valor luego lo utiliza para establecer el retardo entre pulsos. Así varía el sonido de grave a agudo. Con mas luminosidad suena mas grave y con menos suena mas agudo.

      Os adelanto que estoy haciendo experimentos con un Serial EEPROM

      martes, 19 de enero de 2010

      Primer proyecto

      Saludos a todos, esta es mi primera entrada en este blog y me gustaria presentaros mi primer trabajo con arduino. Este consiste en un contador ascendente de 0 a 9 representado en un display de 7 segmentos. Sin utilizar un 7447 para decodificar de BCD a 7-segmentos.

      Si utilizasemos un 7447 solo necesitariamos usar 4 salidas digitales, en cambio si realizamos la decodificación en el arduino necesitaremos ocupar 7 u 8 salidas (dependiendo si queremos usar el led de la coma). Claro esta, que si queremos diseñar un contador con un solo display ambas opciones nos sirven, pero mas adelante en una aplicación mas compleja nos interesaria tener mas salidas libres, ya que sino ocupamos 8 salidas de las 11 disponibles. Empezemos con la receta.

      INGREDIENTES:

      Arduino .
      8 resistencias de 1kOhm.
      display de 7 segmentos (Cátodo común).

      MANOS A LA OBRA:

      El montaje no es demasiado complicado, pero es importante no liarse con el patillaje del display, mi recomendación es que probeis pata a pata que led se ilumina. Y establezcais vuestro propio esquema.

      Primero es conectar el cátodo a la GND de la placa. Después hay que conectar los ánodos a las salidas digitales de la placa intercalando en serie las resistencias de 1kOhm.

      Ahora toca programarlo, os adjunto el código bajo mi parámetros de montaje, raro seria que coincidiese como lo habeis montado vosotros. Tendriaís que modificar los valores de las constantes al principio del código.

      /*
      Contador de 7-segmentos
      POR Loperz Hates
      */

      const int a = 4;
      const int b = 3;
      const int c = 2;
      const int d = 8;
      const int e = 10;
      const int f = 6;
      const int g = 9;
      const int h = 5;


      // The setup() method runs once, when the sketch starts

      void setup() {
      // initialize the digital pin as an output:
      pinMode(a, OUTPUT);
      pinMode(b, OUTPUT);
      pinMode(c, OUTPUT);
      pinMode(d, OUTPUT);
      pinMode(e, OUTPUT);
      pinMode(f, OUTPUT);
      pinMode(g, OUTPUT);
      pinMode(h, OUTPUT);
      }
      void Representar(int valor){
      switch(valor){
      case 0:

      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

      case 1:
      digitalWrite(c, HIGH);
      digitalWrite(f, HIGH);
      break;

      case 2:
      digitalWrite(a, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(g, HIGH);
      break;

      case 3:
      digitalWrite(a, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

      case 4:
      digitalWrite(b, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(f, HIGH);
      break;

      case 5:
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

      case 6:
      digitalWrite(b, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

      case 7:
      digitalWrite(a, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(f, HIGH);
      break;

      case 8:
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

      case 9:
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(f, HIGH);
      break;

      default:
      digitalWrite(h, HIGH);
      break;
      }
      }
      void LimpiarDisplay(){
      digitalWrite(a, LOW);
      digitalWrite(b, LOW);
      digitalWrite(c, LOW);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      }

      void loop(){
      for(int i=0;i<=9;i++){ LimpiarDisplay(); Representar(i); delay(500); } }
      Consta de los procedimientos:
      • setup() Inicializa los pines que vamos a utilizar como de salida.
      • Representar(int valor) Recibe un entero y lo representa en el display.
      • Limpiardisplay() Apaga todos los leds para representar el siguiente dato.
      • loop() Contiene el contador de 0 a 9.
      Bueno os dejo una foto de la pinta que tiene el montaje. Hasta otra :-D