jueves, 24 de mayo de 2012

Ciclo For con LEDs en Arduino


Ciclo For


Algunas veces se requiere iterar una serie de pines y hacer algo con cada uno. Por ejemplo, en este ejemplo parpadean 6 LEDs conectados al Arduino, usando un ciclo for() para el ciclo de ida y vuelta a través de los pines digitales 2 a 7. Los LEDs prenden y apagan en secuencia, usando las funciones digitalWrite() y delay().

¿Qué se necesita?

Arduino
6 Resistencias de 220 ohms
6 LEDs
Cables de interconexión
Protoboard

Conectar los seis LEDs cada uno con una resistencia de 220 en serie, a los pines 2 a 7 del Arduino. Aquí se encuentra el esquema.



El código empieza utilizando un ciclo for para asignar los pines digitales 2 a 7 como salidas para los 6 LEDs utilizados.

En el ciclo principal del código, se utilizan dos ciclos for para recorrer de forma incremental, paso a paso a través de los LEDs, uno por uno, del pin 2 al pin 7. Cuando el pin 7 está encendido, el proceso se invierte, haciendo que los LEDs se prendan al contrario de como ya se había hecho.



int timer = 100; // The higher the number, the slower the timing.

void setup() {
// use a for loop to initialize each pin as an output:
for (int thisPin = 2; thisPin < 8; thisPin++) {
pinMode(thisPin, OUTPUT); 
}
}

void loop() {
// loop from the lowest pin to the highest:
for (int thisPin = 2; thisPin < 8; thisPin++) { 
// turn the pin on:
digitalWrite(thisPin, HIGH); 
delay(timer); 
// turn the pin off:
digitalWrite(thisPin, LOW); 
}

// loop from the highest pin to the lowest:
for (int thisPin = 7; thisPin >= 2; thisPin--) { 
// turn the pin on:
digitalWrite(thisPin, HIGH);
delay(timer);
// turn the pin off:
digitalWrite(thisPin, LOW);
}
}

Referencias:
Arduino

miércoles, 23 de mayo de 2012

Parpadear un LED sin retraso


Parpadeo sin retraso

Algunas veces tu necesitas dos cosas a la vez. Por ejemplo, tu necesitas hacer parpadear un LED mientras lees otra entrada. En este caso, tu no puedes usar delay(), si lo haces se detendrá todo lo demás del programa mientras el LED parpadea. En este programa se demuestra como hacer que el LED parpadee sin necesidad de un delay().

¿Qué se necesita?
Arduino Board
LED
Resistencia de 220 ohms


A continuación se muestra el esquema de como debe ir conectado el LED y la resistencia en el Arduino.






Para armar el circuido, toma el LED e insértalo en el Arduino, la patita positiva en el pin 3 y la patita negativa que es la más corta del LED a tierra. Ahora conecta tu Arduino a la computadora y corre el programa Arduino con el siguiente código.

Código

En este código se utiliza la función millis(), es un comando que regresa el número de milisegundos desde que el Arduino empieza a correr el programa para hacer parpadear el LED.


const int ledPin = 13; // el # de pin donde se encuentra el LED

int ledState = LOW; // estado del LED 
long previousMillis = 0; // guarda la ultima vez que el LED se actualiza

long interval = 1000; // intervalo de tiempo cuando el LED parpadea

void setup() {
pinMode(ledPin, OUTPUT); 
}

void loop()
{


unsigned long currentMillis = millis();

if(currentMillis - previousMillis > interval) {
// guarda la ultima vez que el LED parpadea
previousMillis = currentMillis; 

// si el LED está apagado, lo prende y viceversa
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;

// establecer el LED con el estado de la variable
digitalWrite(ledPin, ledState);
}
}

Processing

Processing es un entorno de programación que sirve para programar una multitud de cosas de forma fácil y rápida sin preocuparnos demasiado por las entrañas del hardware utilizado. Puede ser utilizado tanto para aplicaciones locales así como aplicaciones para la web (Applets). Se distribuye bajo la licencia GNU GPL.



Actualmente se pueden ejecutar sketchs dentro de móviles con Android como sistema operativo, admite la posibilidad de usar las características embebidas en los dispositivos móviles como el GPS, la brújula electrónica, enviar y recibir sms, etc y por supuesto bluetooth.






En esta entrada explicare los pasos a seguir para hacer la comunicación entre processing y un dispositivo android.


Con processing se programa nuestra propia aplicación con su propia interfaz para cualquier dispositivo que tenga un controlador bluetooth.

Primeramente tenemos que tener instalado el programa:


1) Descargamos el Android SDK

Debes descomprimir el archivo zip en un directorio y abrir el directorio "tools" y ejecutar el archivo ejecutable "Android" que abrirá el AVD Manager tal y como se muestra aqui:


Aqui necesitaremos añadir el repositorio de Android e instalar todos sus componentes. Para eso, debemos hacer click sobre la izquierda en "Available Packages" y marcar la opción central que aparece en pantalla. El manager conectará con el repositorio de android y mostrará los componentes disponibles para descargar:


Aqui podemos seleccionar todos los elementos para tener el sistema de desarrollo completo. Una vez instalado, necesitamos instalar una versión especial para Android de Processing.


Ahora les mostraré como hacer un programa simple

void setup() {  
   size(480,800);  
  
   smooth();  
   noStroke();  
   fill(255);  
   rectMode(CENTER);     //Esto permite a los rectangulos aparecer  
};  
  
void draw() {  
   background(#FF9900);  
   rect(width/2, height/2, 150, 150);  
};
Si presionamos el boton "Run" (Ejecutar) Processing compilará nuestro programa en un archivo Applet temporal de Java que se ejecutará en una ventana individual. Para los que ya conocen Processing, es la forma habitual de trabajo. Para compilarlo para Android, debemos selecionar "Android Mode" en el menu y podremos ver la plicación en el emulador al pulsar como "Run":







NOTA: La primera ver que ejecutes el emulador, se mostrará un mensaje indicando que Android SDK no ha sido instalada. Pulsa "Yes" y selecciona el directorio de los archivos del SDK que previamente has copiado en un directorio. Una vez hecho, ejecuta tu programa otra vez.

Ten en cuenta que el emulador tarda su tiempo en inicializarse y ejecutar el programa por lo que ten paciencia :)

Tenemos ya todo el sistema funcionando y es por supuesto muy emocionante, pero aqui falta algo no? Vamos ejecutar nuestro programa en un dispositivo Android real!

Para ejecutar un programa en dispositivo android tenemos que seguir los siguientes pasos:

1) Para que funcione, es importante que tu dispositivo android tenga la opción "USB debugging" activada". Puedes activarla en Configuración -> Aplicaciones -> Desarrollo.

2) Ahora conecta tu dispositivo por USB y selecciona Sketch -> Present desde el menu:



Ahora vamos a probar la conexión de Bluetooth

Para esto vamos a crear una interfaz completa para que nos muestre los dispositivos bluetooth que hay alrededor, a continuación podamos elegir uno de ellos y finalmente conectarnos a este para enviar y recibir datos. 

Este es el código


import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import java.util.ArrayList;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
 
private static final int REQUEST_ENABLE_BT = 3;
ArrayList dispositivos;
BluetoothAdapter adaptador;
BluetoothDevice dispositivo;
BluetoothSocket socket;
InputStream ins;
OutputStream ons;
boolean registrado = false;
PFont f1;
PFont f2;
int estado;
String error;
byte valor;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BroadcastReceiver receptor = new BroadcastReceiver()
{
    public void onReceive(Context context, Intent intent)
    {
        println("onReceive");
        String accion = intent.getAction();
 
        if (BluetoothDevice.ACTION_FOUND.equals(accion))
        {
            BluetoothDevice dispositivo = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            println(dispositivo.getName() + " " + dispositivo.getAddress());
            dispositivos.add(dispositivo);
        }
        else if (BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(accion))
        {
          estado = 0;
          println("Empieza búsqueda");
        }
        else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(accion))
        {
          estado = 1;
          println("Termina búsqueda");
        }
 
    }
};
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  //size(320,480);
  frameRate(25);
  f1 = createFont("Arial",20,true);
  f2 = createFont("Arial",15,true);
  stroke(255);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void draw() {
  switch(estado)
  {
    case 0:
      listaDispositivos("BUSCANDO DISPOSITIVOS", color(255, 0, 0));
      break;
    case 1:
      listaDispositivos("ELIJA DISPOSITIVO", color(0, 255, 0));
      break;
    case 2:
      conectaDispositivo();
      break;
    case 3:
      muestraDatos();
      break;
    case 4:
      muestraError();
      break;
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onStart()
{
  super.onStart();
  println("onStart");
  adaptador = BluetoothAdapter.getDefaultAdapter();
  if (adaptador != null)
  {
    if (!adaptador.isEnabled())
    {
        Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
    }
    else
    {
      empieza();
    }
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onStop()
{
  println("onStop");
  /*
  if(registrado)
  {
    unregisterReceiver(receptor);
  }
  */
 
  if(socket != null)
  {
    try
    {
      socket.close();
    }
    catch(IOException ex)
    {
      println(ex);
    }
  }
  super.onStop();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void onActivityResult (int requestCode, int resultCode, Intent data)
{
  println("onActivityResult");
  if(resultCode == RESULT_OK)
  {
    println("RESULT_OK");
    empieza();
  }
  else
  {
    println("RESULT_CANCELED");
    estado = 4;
    error = "No se ha activado el bluetooth";
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mouseReleased()
{
  switch(estado)
  {
    case 0:
      /*
      if(registrado)
      {
        adaptador.cancelDiscovery();
      }
      */
      break;
    case 1:
      compruebaEleccion();
      break;
    case 3:
      compruebaBoton();
      break;
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void empieza()
{
    dispositivos = new ArrayList();
    /*
    registerReceiver(receptor, new IntentFilter(BluetoothDevice.ACTION_FOUND));
    registerReceiver(receptor, new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_STARTED));
    registerReceiver(receptor, new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED));
    registrado = true;
    adaptador.startDiscovery();
    */
    for (BluetoothDevice dispositivo : adaptador.getBondedDevices())
    {
        dispositivos.add(dispositivo);
    }
    estado = 1;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void listaDispositivos(String texto, color c)
{
  background(0);
  textFont(f1);
  fill(c);
  text(texto,0, 20);
  if(dispositivos != null)
  {
    for(int indice = 0; indice < dispositivos.size(); indice++)
    {
      BluetoothDevice dispositivo = (BluetoothDevice) dispositivos.get(indice);
      fill(255,255,0);
      int posicion = 50 + (indice * 55);
      if(dispositivo.getName() != null)
      {
        text(dispositivo.getName(),0, posicion);
      }
      fill(180,180,255);
      text(dispositivo.getAddress(),0, posicion + 20);
      fill(255);
      line(0, posicion + 30, 319, posicion + 30);
    }
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void compruebaEleccion()
{
  int elegido = (mouseY - 50) / 55;
  if(elegido < dispositivos.size())   
  {     
    dispositivo = (BluetoothDevice) dispositivos.get(elegido);     
    println(dispositivo.getName());     
    estado = 2;   
  } 
} 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
void conectaDispositivo() 
{   
  try   
  {     
    socket = dispositivo.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
    /*     
      Method m = dispositivo.getClass().getMethod("createRfcommSocket", new Class[] { int.class });     
      socket = (BluetoothSocket) m.invoke(dispositivo, 1);             
    */     
    socket.connect();     
    ins = socket.getInputStream();     
    ons = socket.getOutputStream();     
    estado = 3;   
  }   
  catch(Exception ex)   
  {     
    estado = 4;     
    error = ex.toString();     
    println(error);   
  } 
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
void muestraDatos() 
{   
  try
  {     
    while(ins.available() > 0)
    {
      valor = (byte)ins.read();
    }
  }
  catch(Exception ex)
  {
    estado = 4;
    error = ex.toString();
    println(error);
  }
  background(0);
  fill(255);
  text(valor, width / 2, height / 2);
  stroke(255, 255, 0);
  fill(255, 0, 0);
  rect(120, 400, 80, 40);
  fill(255, 255, 0);
  text("Botón", 135, 425);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void compruebaBoton()
{
  if(mouseX > 120 && mouseX < 200 && mouseY > 400 && mouseY < 440)
  {
    try
    {
        ons.write(0);
    }
    catch(Exception ex)
    {
      estado = 4;
      error = ex.toString();
      println(error);
    }
  }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void muestraError()
{
  background(255, 0, 0);
  fill(255, 255, 0);
  textFont(f2);
  textAlign(CENTER);
  translate(width / 2, height / 2);
  rotate(3 * PI / 2);
  text(error, 0, 0);
}
///////////////////////////////////////////////////////////////////////////////////

Bibliografía
Processing + Android + Bluetooth
Como programar un android con processing

martes, 22 de mayo de 2012

Proyecto Arduino

Nuestro proyecto Drive consiste en un carrito a escala que se mueve controlado por un dispositivo móvil. 

Herramientas y tecnología utilizada
Software:

  • Arduino Software
  • Amarino
  • Librería MeetAndroid para arduino


Hardware:

  • Teléfono LG Optimus E510F con Android 2.3
  • Carrito Magician chassis
  • Batería de 9 Volts (Las 4 baterías AA no fueron suficientes)
  • Arduino Uno








  • Modulo Bluetooth para arduino
  • Puente H (Chip SN754410NE)

  • Cables Interconectores (macho-macho) 












Pasos a Seguir


Primeramente armamos el carrito:



Después hicimos un circuito con el puente H para hacer que los motores se movieran. Para hacer esto debemos seguir los siguientes pasos:

Tenemos que colocar el puente H en nuestro protoboard de manera que se pueda ver la pequeña forma de U hacia arriba. Tenemos que identificar los pines de nuestro chip. El pin de lado izquierdo de la U sería el pin 1, debajo de ese sería el 2 y así sucesivamente. El de lado derecho de la Usería el pin 16.

Ahora tenemos que acomodar los cables de la manera en la que se muestra en el diagrama
Los pines 1, 9 y 15 van a la parte positiva del protoboard donde habrá 5V. 
El pin 8 va a el pin VIN donde habrá 12 V y con este correrán los dos motores dc.
Los pines 4, 5, 12 y 13 van a la parte negativa del protoboard.
El motor izquierdo va en los pines 3 y 6.
El motor derecho va en los pines 11 y 14.
El pin 2 del puente H va a el pin digital 2 del Arduino.
El pin 7 del puente H va a el pin digital 3 del Arduino.
El pin 10 del puente H va al pin digital 8 del Arduino.
El pin 15 del puente H va al pin digital 7 del Arduino.



Ahora tenemos que conectar el módulo bluetooth a nuestro arduino para que se pueda comunicar con el dispositivo móvil.

El bluetooth se conecto de la siguente manera:





Nota: Si ya estamos utilizando la entrada de 5V podemos usar la de 3 que viene en nuestro arduino.

El carrito armado quedó de la siguiente manera:



Ahora tenemos que descargar el software Amarino para probar si la conexión fue realizada exitosamente

Aqui estan los pasos a seguir para realizar las pruebas

Ahora que ya establecimos comunicación entre el celular y el arduino, tenemos que programar el arduino para que capte dicha señal y podamos manejar el carrito a nuestro antojo

El código que utilizamos en nuestro arduino fue el siguiente:


#include 

#define baudrate 115200

MeetAndroid phone;

// Motores
int motor_left[] = {2, 3}; //se definen los pines del motor izquierdo
int motor_right[] = {7, 8};//se definen los pines del motor derecho
int i;
int ledPin =  13;    // LED 

// ————————————————————————— Setup
void setup() {

// Configurar motores
int i;
for(i = 0; i < 2; i++){
pinMode(motor_left[i], OUTPUT);
pinMode(motor_right[i], OUTPUT);
pinMode(ledPin, OUTPUT);
}

Serial.begin(baudrate); // se define la tasa de baudios número de unidades de señal por segundo
}

void loop() {
phone.receive();

while (Serial.available() < 1) {} 
char value = Serial.read(); //lee el valor 


if (value == '1'){
turn_left();
Serial.println("1");
}

if (value == '2'){
turn_right();
Serial.println("2");
}

if (value == '3'){
drive_backward();
Serial.println("3");
}

if (value == '4'){
drive_forward();
Serial.println("4");
}

if (value == '0'){
motor_stop();
Serial.println("0");
}
}
}

// Funciones

void motor_stop(){ 
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], LOW);

digitalWrite(motor_right[0], LOW);
digitalWrite(motor_right[1], LOW);
}

void turn_left(){

digitalWrite(motor_left[0], HIGH);
digitalWrite(motor_left[1], LOW);

digitalWrite(motor_right[0], HIGH);
digitalWrite(motor_right[1], LOW);

}

void turn_right(){
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], HIGH);

digitalWrite(motor_right[0], LOW);
digitalWrite(motor_right[1], HIGH);
}

void drive_backward(){
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], HIGH);

digitalWrite(motor_right[0], HIGH);
digitalWrite(motor_right[1], LOW);
}

void drive_forward(){
digitalWrite(motor_left[0], HIGH);
digitalWrite(motor_left[1], LOW);

digitalWrite(motor_right[0], LOW);
digitalWrite(motor_right[1], HIGH);
}
Ahora nos conectamos a Amarino con el código ya programado y en Monitor podemos enviarle mensajes para que se mueva. En este caso, el carrito se moverá con los números 1, 2, 3 y 4.

Aquí está un ejemplo de nuestro carrito ya funcionando

video




viernes, 18 de mayo de 2012

Amarino

Conectar tu celular Android con Arduino

Primero que nada tienes que bajar la aplicación de Amarino en tu celular. Aquí les dejo el link para descargarlo Amarino

Ya que la descargaste, descargas la libreria Meet Android que es para el software de Arduino.

Cuando tengas todo eso descargado, vas a guardar la librería dentro de la carpeta libraries de el software de Arduino que se encuentra en Arduino -> Contents -> Resources -> Java -> libraries.  Ahí copias la carpeta que descargaste de Meet Android y después abres el Software de Android y ya te debe aparecer la librería. 




Para saber si ya está instalada la librería te vas al menú Sketch -> Import Library y ahí ya debe aparecerte la librería MeetAndroid.




Encontrar el Arduino Bluetooth en tu celular Android.




Primero entras a la aplicación de Amarino en tu celular, primero que nada tienes que buscar el dispositivo Arduino Bluetooth al que quieres hablar. Para realizar esto pulsa el botón de "Add BT Device" (Añadir un dispositivo Bluetooth) y espera a que tu módulo de Bluetooth Arduino aparezca. 








Pueden aparecer más de un dispositivo ya que detecta a todos los dispositivos Bluetooth que estén cerca. Encuentra el que sea tu módulo Bluetooth de Arduino, selecciónalo y agrégalo a Amarino.





Al agregar el dispositivo Bluetooth a Amarino aparecerá el dispositivo con un botón de conexión en la pantalla principal de la aplicación Amarino. 




















Ahora es momento de presionar el botón conectar, no te preocupes si sale un mensaje de  error de conexión o un mensaje diciendo que introduzca un PIN. Escriba en la solicitud de apareamiento el PIN de su módulo bluetooth que normalmente es "1234", en la placa ArduinoBT es "12345" y en algunos otros "0000". Presione el botón OK, si el PIN es correcto ya finalizó el apareamiento.






Presiona el botón conectar otra vez, esta vez debería de conectarse correctamente indicando una luz verde en el módulo Bluetooth cuando normalmente es naranja, en la aplicación también debe aparecer un cuadrado verde en la parte de arriba del botón de conexión.



Activar Eventos

Presione el ícono rojo de la izquierda del gabinete para gestionar los eventos que pueden ser enviados a la placa Arduino. Seleccione "Add Event" (agregar evento) y busque "Test Event" en la lista y selecciónelo. Se abrirá una página de descripción donde explica que hace este evento. Presione "Save" y esto agregara el Test Event, el cual manda información aleatoria al Arduino cuando se establece la conexión.





Ahora abre el Software de Arduino y selecciona del menú File -> Examples -> MeetAndroid -> Test.

Cambia el "baud rate" del módulo Bluetooth a 57600 o 115200. Las placas nuevas de Arduino solo funcionan con 115200 baud, las más viejitas solo con 57600 baud. 



Carga el sketch al Arduino. Coloca un LED en el pin 13 del Arduino. Con esto el celular ya está configurado, la placa Arduino tendrá un programa de prueba. 


Conecta tu Arduino con el Bluetooth módem, toma tu celular Android y ve a la pantalla principal de Amarino y presione conectar. Se debe iniciar la conexión, si se estableció correctamente el indicador cambia a verde. Ahora tu celular se comunica con el Arduino.

Si todo salió bien, el LED que esta en el pin 13 del Arduino debe parpadear cada 5 segundos durante 1 segundo.

Para monitorear que la comunicación en tu celular, presiona el botón de monitoreo en la aplicación de Amarino y ahí observarás el proceso de comunicación entre el Arduino y el celular.

>

Puente H


Un Puente H o Puente en H es un circuito electrónico que hace posible que un motor eléctrico DC gire en ambos sentidos, avance y retroceda. Se utilizan mucho en robótica y como convertidores de potencia. Estos puentes están disponibles como circuitos integrados aunque también se pueden construir mediante componentes discretos.
El término de "Puente H" viene de la representación gráfica del circuito. Dicho puente se crea con 4 interruptores mecánicos o mediante transistores. Cuando los interruptores S1 y S4 están cerrados y S2 y S3 abiertos se aplica una tensión positiva en el motor, haciendo que gire en un sentid. Abriendo los interruptores S1 y S4 y los interruptores S2 y S3 cerrados el motor gira en sentido contrario.

El puente H como ya mencioné se utiliza para invertir el giro de un motor, así como también puede utilizarse para frenarlo haciendo un corto entre las bornas del motor. Otra forma de utilizarlo es para permitir que el motor frene bajo su propia inercia, cuando desconectamos el motor de la fuente que lo alimenta.



Lo más común en estos circuitos es utilizar interruptores de estado sólido como los transistores ya que sus tiempos de vida y frecuencias de conmutación son mucho más altas. En convertidores de potencia es indispensable utilizar interruptores mecánicos por su bajo número de conmutaciones de vida útil y las altas frecuencias que suelen utilizar.

Los interruptores son acompañados de diodos (conectados a ellos en paralelo) que permitan a las corrientes circular en sentido contrario al previsto cada vez que se conmute la tensión ya que el motor está formado por bobinados que durante cortos períodos de tiempo se opondrán a que la corriente varíe.

Controlar motores usando el SN75441 (Puente H)
A continuación mostraré como usar el SN75441 para controlar dos motores DC de 12V. Realicé un esquema en Fritzing para que puedan saber con mayor facilidad como va conectado el puente H al Arduino. 





En este esquema se puede observar donde a donde va dirigido cada pin del puente H. Ahora les mostraré un diagrama de pines del puente H.
Como se muestra en el diagrama:
  • Los pines 1, 9 y 15 van a la parte positiva del protoboard donde habrá 5V. 
  • El pin 8 va a el pin VIN donde habrá 12 V y con este correrán los dos motores dc. 
  • Los pines 4, 5, 12 y 13 van a la parte negativa del protoboard.
  • El motor izquierdo va en los pines 3 y 6.
  • El motor derecho va en los pines 11 y 14.
  • El pin 2 del puente H va a el pin digital 2 del Arduino. 
  • El pin 7 del puente H va a el pin digital 3 del Arduino.
  • El pin 10 del puente H va al pin digital 8 del Arduino.
  • El pin 15 del puente H va al pin digital 7 del Arduino.
Después de estas conexiones ya puedes programar el Arduino para mover los motores usando el programa de Arduino. 


Video

video


jueves, 17 de mayo de 2012

Dispositivos periféricos



Los dispositivos periféricos son dispositivos auxiliares que son externos a la computadora. Algunas veces son llamados dispositivos de entrada o de salida. 


Estos permiten el acceso y la transferencia de información a la computadora. Existen dispositivos que se utilizan frecuentemente, y otros que pueden ser un poco menos comunes. Los comunes podrían ser el teclado, monitor, impresora y el mouse. 


También podrían ser los micrófonos, bocinas, la webcam, scanners, memorias USB, discos duros externos, entre otros dispositivos más específicos.







El papel que juegan los dispositivos periféricos de la computadora es esencial, ya que sin tales dispositivos la computadora no sería útil a los usuarios.




Existen diferentes tipos de dispositivos periféricos:


  • Periféricos de entrada: 

Captan y digitalizan los datos de ser necesario, introducidos por el usuario o por otro dispositivo y los envían al ordenador para ser procesados. El dispositivo de entrada más común es el teclado. 

También podría ser el mouse, micrófono, escaner , cámaras, entre otros.
  • Periféricos de salida: 
Muestran o proyectan información hacia el exterior del ordenador. La mayoría son para informar, alertar, comunicar, proyectar o dar al usuario cierta información, de la misma forma se encargan de convertir los impulsos eléctricos en información legible para el usuario. Sin embargo, no todos de este tipo de periféricos es información para el usuario. Ejemplo: Monitor, impresora, bocinas, altavoces, etc. 
  • Periféricos de comunicación: 
Su función es permitir o facilitar la interacción entre dos o más computadoras, o entre una computadora y otro periférico externo a la computadora. 

Entre ellos se encuentran los siguientes: Fax-Módem, tarjeta de red, concentrador, conmutador, enrutador, tarjeta inalámbrica, tarjeta bluetooth.
  • Periféricos de almacenamiento: 
Se encargan de guardar los datos de los que hace uso la CPU, para que ésta pueda hacer uso de ellos una vez que han sido eliminados de la memoria principal, ya que ésta se borra cada vez que se apaga la computadora. 

Pueden ser internos, como un disco duro, o extraíbles, como un CD.

Como se ha podido observar existen muchos tipos de dispositivos que utiliza la computadora y que son indispensables para poder comunicarnos con la máquina. Un ejemplo muy claro lo es el Teclado y el Mouse.


Los subsistemas de entrada/salida y memoria pueden ser combinados con un subsistema de CPU para formar una computadora o sistema integrado completo.
Estos subsistemas se interconectan mediante los buses de sistema (formados a su vez por el bus de control, el bus de direcciones y el bus de datos).

El subsistema de entrada acepta datos del exterior para ser procesados mientras que el subsistema de salida transfiere los resultados hacia el exterior. Lo más habitual es que haya varios subsistemas de entrada y varios de salida.
A estos subsistemas se les reconoce habitualmente como periféricos de E/S.

En general, un sistema integrado simple contará con un microprocesador, memoria, unos pocos periféricos de E/S y un programa dedicado a una aplicación concreta almacenado permanentemente en la memoria. 

Las microcomputadoras en estos sistemas controlan electrodomésticos tales como: televisores, videos, lavadoras, alarmas, teléfonos inalámbricos, etc. Incluso una PC tiene sistemas embebidos en el monitor, impresora, y periféricos en general, adicionales a la CPU de la propia PC. 

A lo largo del tiempo, se ha demostrado que la tecnología avanza cada día más en busca de mejores cosas y mayor comodidad para el usuario. 


Por ello debemos tener en cuenta como utilizar los dispositivos periférico del ordenador para obtener un mayor aprovechamiento de cada uno de estos y hacer nuestro trabajo más rápido y con la mayor comodidad posible, para lograr facilitar nuestras labores cotidianas en las ayuda de estas maquinas.



Bibliografía



Sistemas operativos integrados

Un sistema operativo integrado lo podemos encontrar en los circuitos de los dispositivos electrónicos. Normalmente los sistemas operativos residen en un disco magnético, sin embargo éstos pueden servir para implementarse en diferentes dispositivos tales como teléfonos celulares, asistentes digitales personales, automóviles, aparatos domésticos, entre otros. 


Estos sistemas suelen tener algunas características de los sistemas de tiempo real, pero también cuentan con limitaciones de tamaño, memoria, y consumo de energía. 

Embedded Linux

En estos últimos años, Linux se ha vuelto un sistema operativo integrado muy común, especialmente en dispositivos, routers y switches. 


Debido a la naturaleza modular de linux, es muy fácil reducir el sistema operativo removiendo ciertas características como herramientas, utility programs, entre otros servicios que no son necesarios en un sistema integrado. 

Una de las mayores ventajas de linux es que es un sistema operativo que funciona muy bien, es un sistema flexible, disponible, portátil, estable y abierto. Linux además es un sistema operativo gratuito.

En esta tabla se muestran los dispositivos móviles que cuentan con este sistema operativo


Los siguientes sistemas operativos se basan en Embedded Linux para funcionar:

  • Access Linux Platform
  • Android
  • bada
  • Openmoko Linux
  • OPhone
  • MeeGo
  • Mobilinux
  • MotoMagx
  • Qt Extended
  • LiMo Platform
  • webOS


Windows CE

Este sistema operativo integrado cuenta con los servicios más básicos de funcionalidad, las aplicaciones de éste incluyen dispositivos tales como móviles, de automóviles, videojuegos y cámaras digitales. 

Aunque Windows CE constituye la base para muchos tipos de dispositivos, no es raro tener la impresión de que se divide en dos campos: dispositivos equipados con Windows Mobile® y dispositivos incrustados personalizados (es decir, todos los demás).
Otros sistemas operativos integrados:

  • Symbian
  • Windows Mobile
  • Linux
  • Android
  • iOS
  • Palm OS

Interrupciones

Una interrupción es el rompimiento en la secuencia de un programa para ejecutar un programa especial llamando una rutina de servicio cuya característica principal es que al finalizar regresa al punto donde se interrumpió el programa.


Las interrupciones son un metodo del que disponen los dispositivos e incluso los procesos para hacer notar a la CPU la aparición de alguna circunstancia que requiera su intervención. De este modo, los dispositivos pueden provocar que la CPU deje por el momento la tarea que estaba realizando y atienda la interrupción. 


Una vez atendida, seguira con su labor anterior. Cuando no existían interrupciones, era el procesador el que tenía que estar continuamente comprobando el estado del dispositivo cuando lo necesitaba.


Existen dos tipos de interrupciones

  • Interrupciones por software:

Este tipo de interrupciones se programan por el usuario, éste decide el tiempo en el que se van a ejecutar.


Las interrupciones de software son eventos síncronos que son provocadas por el programa en ejecución usando una función especial del lenguaje, esto puede ocurrir al llamar a la instrucción INT, al realizar una división por 0 o realizar una petición de una interrupción externa.

Tienen como objetivo el que la CPU ejecute algún tipo de función. Al terminar de ejecutarse esta función, se seguirá ejecutando el programa que provocó la interrupción.

Este tipo de interrupciones es la forma más importante que tendrán los programas de ejecutar funciones especiales del DOS (Disk Operating System) o del BIOS (Basic Input Output System). Estas funciones tienen un número de interrupción software asociada.

Cuando un programa lanza una interrupción de este tipo, la CPU ejecuta su función de tratamiento asociada. Se guarda la máscara de interrupciones, se modifica la máscara a fin de habilitar selectivamente las interrupciones que permitiremos durante la ejecución de la rutina, se habilitan globalmente las interrupciones seteando el flag IF en 1 y se ejecuta la rutina de atención de la interrupción solicitada. 

  • Interrupciones por hardware:



Son las que se provocan por medio de los dispositivos externos al procesador. No son programadas. Entre las interrupciones de hardware existen dos tipos de interrupciones:

Interrupciones por hardware enmascarables: Son las que el usuario decide si quiere o no ser interrumpido.

Interrupciones por hardware no enmascarables (NMI): Son las que siempre interrumpen al programa. Estas interrupciones llegan a través de una línea directamente al procesador y cuando ésta se activa, el CPU provoca una interrupción por software.

Las interrupciones tienen distintas prioridades predefinidas que indican que interrupción tiene mayor prioridad y no puede se interrupida por una de menor prioridad, así el Registro de Interrupciones Activas (ISR) indica el número de la interrupción en concreto que se está realizando.

Si llega otra interrupción de hardware con menor o igual prioridad no se ejecutará, pues se asume que aún está en ejecución la anterior, mientras el ISR esté con su número. 
Los IRQ se encuentran numerados, y cada dispositivo hardware se encuentra asociado a un número IRQ. Por ejemplo, el reloj (en IRQ 0) tiene una prioridad más alta que el teclado (IRQ 1).


Bibliografía