Webcervices. Con la tecnología de Blogger.
RSS

Unete a nuestro grupo de facebook

Unete a nuestro grupo de facebook
Hola que tal lectores de esta pagina tan maravillosa que es arduino Tec ...Los invito a que amplíen mas sus conocimientos en Arduino y Raspberry Pi Uniéndose a mi grupo Arduino Tec

Tutorial - Cruce de semáforos LED

Identificación y despiece del c

En nuestro primer tutorial vamos a proceder a la identificación de los componentes delStarter Kit que hemos adquirido aquí en El cajón de Ardu.




Los componentes que contenía el kit son los siguientes:

1.        1pcs x for Arduino UNO board
2.        1pcs x Development expansion board
3.        1 pcsx Breadboard
4.        1pcs x LED emitter kit (red / blue / yellow; each 5pcs)
5.        1 pcsx 74hc595
6.        2 pcsx Buzzers
7.        1pcs x Seven-segment display (1-digit)
8.        1pcs x Seven-segment display (4-digit)
9.        10pcsx Push button switches
10.      3pcs x Light dependent resistors
11.      5pcs x 10K resistors
12.      5pcs x 1K resistors
13.      8pcs x 220R resistors
14.      1pcs x Adjustable resistor
15.      1pcs x LM35 temperature sensor
16.      1pcs x 1602 LCD display
17.      1pcs x PS2 joystick
18.     1pcs x Stepping motor
19.     1pcs x Stepping motor driver board
20.     1pcs x Steering engine
21.     1pcs x RGB module
22.     30pcs x Breadboard cables
23.     10pcs x Dupont lines
24.     1pcs x 2.54mm pin header
25.     2pcs x Mercury switches
26.     1pcs x Flame sensor
27.     1pcs x Infrared receiver
28.     1pcs x USB cable (80cm)
29.     1pcs x Remote control 
30.     1pcs x Battery case
En el siguiente video explicamos de una manera general para qué sirve cada componente, espero que sea de utilidad y que cualquier pregunta o corrección que tengáis no dudéis en comentarla más abajo.


  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS

Diodo LED. Introducción y ejemplo

Multi proyectos 0145

Diodo LED. Introducción y ejemplo


Diodo LED, ¿qué es?
Un diodo LED es un componente electrónico capaz de transmitir luz. Emite dicha luz cuando la corriente eléctrica lo atraviesa,  y lo hace, además, de forma proporcional. A más intensidad de corriente atravesándolo, más luz.

Puede ser conectado ya sea polarización directa como inversa, aunque sólo funcionará si se encuentra conectado de forma directa.

La manera de distinguir el ánodo ( terminal positivo) del cátodo (terminal negativo) es fijándonos en la longitud de las patillas del diodo. El ánodo es más largo que el cátodo.


Se dibujan las flechas para indicar que se trata de un diodo LED.


LED rojo
Hay que tener en cuenta que, cuando vayamos a conectarlo para diseñar un circuito con nuestro Arduino UNO, es necesario conectar una resistencia en serie al diodo, así limitamos la intensidad que circula y evitamos que pueda ser dañado.
¿Qué valor mínimo de resistencia es recomendable?
Según la ley de Ohm, cuanto mayor sea el valor de la resistencia, menos intensidad circulará por el diodo, y menos luz emitirá. La intensidad con la que funciona correctamente un diodo LED es de unos 15mA, por lo que lo podemos resolver conectando una resistencia de 220 ohminos en serie.

Primero de todo, vamos a ver cómo funciona la placa breadboard. 
Vemos que arriba y abajo posee dos líneas (azul y roja, respectivamente). Estas líneas con agujeritos, se llaman buses. La línea roja indica el bus sometido al voltaje de entrada, y la línea azul será la conectada a tierra. Todos los puntos marcados con la línea roja serán equivalentes porque están conectados entre sí, y lo mismo ocurre con los puntos marcados con la línea azul. Además, buses están aislados eléctricamente uno del otro.

placa de prototipado (breadboard o protoboard)


Por otro lado, en la parte central aparecen un gran cantidad de agujeros. Se usan para colocar y conectar los componentes. Las conexiones internas están dispuestas de forma vertical, de forma que los agujeros son completamente equivalentes si pertenecen a la misma vertical. Al conjunto de todos los agujeros equivalentes conectados entre sí se les denomina nodo.
Finalmente, detectamos una zona central, la que separa la parte superior de la inferior. Se suele utilizar para colocar los circuitos integrados, de forma que la mitad de un chip está aislada de la otra.


conexiones internas


EJEMPLO

Conectar un LED y ponerlo en funcionamiento de forma intermitente
Para hacer este sencillo circuito, necesitaremos:
-          Placa breadboard
-          1 resistencia 220
-          LED
-          Cables

Puede realizarse de varias formas. La más fácil sin duda es, teniendo en cuenta que el pin 13 ya lleva incorporado la resistencia del valor que necesitamos, conectar el el LED directamente en dicho pin y en la GND (tierra), quedando de la siguiente forma.

patilla más larga en el pin 13


Haciéndolo un poquito más complicado y así entender las conexiones, vamos a conectarlo al pin 12. Se puede observar en la imagen siguiente que hemos utilizado una resistencia que se encuentra en serie con el LED. Hay que tener en cuenta que el circuito debe cerrarse, sino no funcionará.



Tal y como hemos explicado antes en cuanto al funcionamiento del LED y de la placa breadboard, entendemos pues el hecho de que aparezca una resistencia conectada en serie al LED. Siguiendo el orden de: cable rojo (normalmente usado para la parte positiva), cable verde, resistencia, LED, cable blanco, cable negro (usado para la parte negativa), tenemos el circuito cerrado, garantizando que, al menos, circule intensidad por él.

Este es un ejemplo de dominio público que se encuentra en la página oficial de arduino (http://www.arduino.cc/).

El sketch para este ejemplo (con el pin12) será el siguiente:

// Le damos un nombre al pin 12, concretamente led
int led = 12;
void setup() {               
  // determinamos que nuestra variable led será de salida
  pinMode(led, OUTPUT);    
}

// escribimos el sketch
void loop() {
  digitalWrite(led, HIGH);   // enciende el LED (HIGH)
  delay(1000);               // espera durante un segundo (las unidades son milisegundos)
  digitalWrite(led, LOW);    // apaga el LED haciendo nula la tensión
  delay(1000);               // espera de nuevo un segundo
}



No dudéis en comentar y en preguntar cualquier duda.
Gracias por la atención.

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS

Pulsador. Introducción y ejemplos

Pulsador. Introducción y ejemplos

Partiendo de la definición de interruptor como un dispositivo que cuando se encuentra “cerrado” deja pasar la corriente y cuando está “abierto” impide el paso de la misma, un pulsador no es más que un tipo de interruptor, el cual se mantendrá en posición de “cerrado” tanto tiempo como pulsado lo mantengamos, gracias a la lámina conductora que produce el contacto.



El circuito estará abierto cuando el pulsador no esté presionado, de forma que al apretarlo, se cerrará el circuito, haciendo que pase la corriente a través de él.


De acuerdo con las imágenes, puede parecer que el pulsador tiene 4 terminales, pero lo cierto es que las dos patillas que se encuentran enfrentadas de cada lado están unidas internamente entre sí, lo que supone que en realidad tengamos solamente dos.


EJEMPLOS

Para controlar un LED mediante un pulsador, no es necesario programar nada, ya que conectamos 5V de entrada con masa (GND), como si estuviera conectado a una pila.


Los cables rojo y negro indican el ánodo y el cátodo, respectivamente, haciendo el comportamiento como el de un circuito eléctrico corriente. 

Caso 1
Unimos el terminal de entrada y el de salida de la parte de la izquierda (o de la derecha), de forma que se queda unido mediante la lámina conductora.
Con esto conseguimos que el circuito esté siempre cerrado (encendiéndose el LED), comportándose el pulsador como un cable, es decir, sin poder actuar de ninguna forma.

Caso 2
Cuando unimos el terminal de la izquierda con el de la derecha (o al revés), independientemente de si sea el de "arriba" o "abajo" (se verá más claramente en el vídeo), entonces el pulsador sí que actúa como un interruptor. Mientras no esté pulsado, el circuito estará abierto y por tanto el LED permanecerá apagado. El momento en el que pulsemos, entonces se cerrará el circuito encendiéndose finalmente el LED.



Puede observarse en el vídeo que dependiendo de cómo conectemos los cables blancos, estaremos en el Caso 1 o en el Caso 2.


Control del encendido y apagado de un LED con dos pulsadores
Para poder realizar este circuito, es necesario que dispongamos de 2 resistencias de 1 kΩ cada una, para utilizar en el pulsador.

Vamos a ver cómo sería el montaje:
Primero conectaríamos los dos pulsadores, cada uno de ellos unido a un pin (2 y 10 en nuestro caso). En la misma patilla donde hemos puesto los cables (rojos) colocamos las resistencias unidas a masa (horizontal de arriba de color azul), para evitar que se nos quemen los pulsadores. Y, con el cable negro, conectamos dicha horizontal con la masa de nuestro Arduino (GND).



Unimos ahora el cable de alimentación, que distribuirá la tensión en ambos pulsadores, a la otra patilla que queda libre.
Del Pin de 5V se puede observar en la imagen siguiente cómo une ambos pulsadores (cables naranja)



Finalmente, faltará colocar el LED como hemos explicado en una entrada anterior (Diodo LED. Introducción y ejemplo ). Lo haremos mediante el pin 13, quedando finalmente el montaje que se muestra a continuación:


Una vez tenemos el montaje, bastará con introducir un sencillo sketch para hacer que funcione correctamente:

int LED = 13; //LED
int pulsador1 = 2; // primer pulsador
int pulsador2 = 10; // segundo pulsador

void setup () { 
  pinMode (LED, OUTPUT); //configurado como salida
  pinMode (pulsador1,INPUT); //configurado de entrada
  pinMode (pulsador2, INPUT);
}

void loop () {
  if (digitalRead(pulsador1) == HIGH){ //si el pulsador1 está en alto
    digitalWrite (LED, HIGH); //encender el LED
  }
  else if (digitalRead(pulsador2) == HIGH){ //si el pulsador2 está en alto
    digitalWrite (LED, LOW); // apagar el LED
  }
}



Como se aprecia en el vídeo, si apretamos el pulsador que no toca, no funciona. Uno es para encender y el otro para apagar, no hay reversibilidad. 


Y esto es todo. No dudéis en comentar y en preguntar cualquier duda.
Gracias por la atención.

  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS

Tutorial - Led RGB con pulsadores


Tutorial - Led RGB con pulsadores












El objetivo de este tutorial consiste en combinar la utilización de pulsadores para controlar el color de un led RGB.

El modelo RGB se basa en la posibilidad de representar un color mediante la mezcla por adición de los tres colores de luz primarios: rojo, verde y azul.




Antes de adentrarnos en el montaje, enumeraremos los componentes necesarios para realizar el experimento:



1 led RGB
3 resistencias de 270 ohmios (Con 220 ohmios será suficiente, la única diferencia que encontraremos es que a menor resistencia, el led brillará con mayor intensidad, soportando con garantías este incremento)
3 pulsadores táctiles
1 placa breadboard
1 microprocesador Arduino UNO
Cables
1 placa breadboard pequeña adicional (opcional)














A continuación, vemos el diagrama del cableado:




























Deberemos comprobar que la patilla más larga del led RGB sea la que esté conectada a tierra. En nuestro diagrama se trata de la segunda patilla, pero esto puede variar según el tipo de led RGB que tengamos.


























Por ejemplo, en el montaje del vídeo que podéis ver al final del tutorial, se ha empleado un led RGB en el que las patillas "Red", "Green" y "Blue" se disponen de forma sucesiva, y la última patilla comenzando desde la izquierda es la que se conecta a tierra.









En el de la imagen que veis a la derecha, la disposición es diferente. Por tanto, se deberá tener en cuenta en cada caso para una correcta conexión de los pines.












Cabe destacar que se está asumiendo que se dispone de un led "Cátodo común". Si, en cambio, nuestro led es "Ánodo común", deberemos conectar el pin más largo de éste a +5V en vez de a tierra. En este caso, el ciclo de color será inverso, es decir, cuando accionemos el pulsador dispuesto a encender la luz roja, se encenderá la azul y viceversa.






Tal y como vemos en el diagrama, se está empleando la mitad de la placa breadboard, ya que la parte media de los buses de nuestra placa está separada, por lo que la corriente no tiene continuidad.







Finalmente, vamos a explicar con detalle el programa a introducir en el software de Arduino. Iremos analizando cada parte del código para entender qué se consigue con cada una de ellas.




En primer lugar, el código que vamos a introducir presupone que el led está apagado. Si mantenemos presionado alguno de los botones, el led se encenderá aumentando gradualmente su intensidad. El botón de la izquierda encenderá el color rojo, el del centro, el verde y el de la derecha, el azul.




Podremos realizar cualquier combinación con estos tres colores, teniendo en cuenta que a mayor tiempo de pulsación, obtendremos una mayor intensidad de luz. Si queremos volver a empezar con el led apagado, basta con darle al botón de reiniciar (botón rojo de la placa Arduino).







Vamos por tanto a analizar el programa a emplear:




Primero, la definición de los pines:

Tenemos tres pines de salida para controlar el led. Mediante éstos podemos controlar cuánta potencia va a cada color del led.

Necesitamos tres pines más para los pulsadores, los cuales configuraremos como pines de entrada.


  1. int redLEDPin = 11;
  2. int greenLEDPin = 10;
  3. int blueLEDPin = 9;
  4.  
  5. int redSwitchPin = 7;
  6. int greenSwitchPin = 6;
  7. int blueSwitchPin = 5;

Tras la asignación de los pines, declaramos las siguientes variables:

  1. int red = 0;
  2. int blue = 0;
  3. int green = 0;


Las utilizaremos para mantener los valores actuales de la intensidad de cada canal del led y pueden variar de 0 a 255. Por tanto, si tenemos 'blue' = 0, la parte azul del led estará apagada, mientras que si tenemos 'blue'=255, brillará con la máxima intensidad.



  1. void setup()
  2. {
  3. pinMode(redLEDPin, OUTPUT);
  4. pinMode(greenLEDPin, OUTPUT);
  5. pinMode(blueLEDPin, OUTPUT);
  6. pinMode(redSwitchPin, INPUT_PULLUP);
  7. pinMode(greenSwitchPin, INPUT_PULLUP);
  8. pinMode(blueSwitchPin, INPUT_PULLUP);
  9. }
  10.  
  11. void loop()
  12. {
  13. if (digitalRead(redSwitchPin) == LOW)
  14. {
  15. red ++;
  16. if (red > 255) red = 0;
  17. }
  18. if (digitalRead(greenSwitchPin) == LOW)
  19. {
  20. green ++;
  21. if (green > 255) green = 0;
  22. }
  23. if (digitalRead(blueSwitchPin) == LOW)
  24. {
  25. blue ++;
  26. if (blue > 255) blue = 0;
  27. }


Tras definir el modo de los pines ( 'input' para las entradas y 'output' para las salidas), pasamos a la parte de los bucles. Cada uno de ellos funciona de la misma manera. 
Por ejemplo, el primero controla el led rojo. Si 'digitalRead', mediante 'redSwitchPin' detecta que está en 'LOW', lo que quiere decir que el botón está pulsado, se le suma 1 a 'red' (mediante el comando ++). Y seguirá sumando hasta que 'red' llegue a 255. A partir de este momento, el 'if' siguiente volverá a poner 'red' a 0 y se iniciará de nuevo el bucle.

  1. analogWrite(redLEDPin, red);
  2. analogWrite(greenLEDPin, green);
  3. analogWrite(blueLEDPin, blue);
  4. delay(10);
  5. }

Con el 'delay' final conseguimos reducir la velocidad de cambio de color del led para que nos sea más fácil manipularlo.

Y con esto ha sido todo por hoy. Os dejo un vídeo con el correcto funcionamiento del proyecto.







  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS

Tutorial - Cruce de semáforos LED

Tutorial - Cruce de semáforos LED





Objetivo: Montar un cruce de semáforos con un tiempo
 de espera de 6 segundos antes del cambio. La secuencia
 hará una espera de 4 segundos en verde, 2 segundos
parpadeando, luego Amarillo y luego Rojo (6 segundos de nuevo).
 El botón lo programaremos para que reinicie el contador cambiando
de semáforo (similar a cuando pulsamos el botón para cruzar en uno de estos).










Componentes a usar en este tutorial:

2 x Diodo LED Red

2 x Diodo LED Yellow

2 x Diodo LED Green

6 x Resistencia 220 ohmios

1 x Resistencia 10 Kohmios

1 x Arduino UNO

Cables

1 x Pulsador









En la imagen superior tenemos el diagrama del montaje.
Podemos identificar los LEDs, las resistencias y el botón pulsador.





Vamos a pasar a comentar las conexiones:





Para conectar nuestro Arduino UNO a la protoboard o
 BreadBoard sacaremos un cable (cable rojo) del PIN 5V
 hasta nuestra fila positiva de la protoboard (+) y un cable
 (cable azul) desde el PIN GND hasta nuestra fila (-) de la protoboard.





Para evitarnos problemas de conexión haremos ya el puente
a mitad de la protoboard. El cable azul de la imagen conecta
 la fila negativa para que todos los pines estén unidos. Nota:
 esto no es obligado hacerlo pero suele ser útil para evitarnos
problemas de montaje.





Ahora que ya tenemos la protoboard preparada para seguir,
 procederemos a conectar nuestro botón pulsador.
 Este componente está dotado de 4 terminales o "patas".
 Podemos conectarlo como en la imagen haciendo de
puente entre las bandas verticales de la protoboard.
A la pata de la izquierda le conectaremos la resistencia
 de 10 Kohmios y la resistencia irá conectada a la fila
negativa (GND) de la protoboard mediante un cable.

De la pata de la derecha del pulsador saldrá un cable que
conectara éste a la fila positiva de la protoboard (5V).





Seguidamente procederemos a colocar los LEDs
en la protoboard. Usando el polo negativo del LED
en la zona vertical de la protoboard y el positivo en
 la fila negativa de la protoboard (GND) como indica
la imagen. Del polo negativo del LED deberá ir conectado
 la resistencia de 220 ohmios como muestra la imagen.
 Es recomendable que su disposición también haga de
 puente entre las columnas verticales de la protoboard.





Una vez tenemos montados y conectados los componentes,
tan sólo nos faltará conectar los LEDs y el botón a nuestro
Arduino UNO. Estas conexiones las haremos de la siguiente manera:





Los LEDs los conectaremos desde la salida de la resistencia
 hacia el controlador. (ver imagen)





- LED Verde (derecha): PIN 2 del Arduino.

- LED Amarillo: PIN 3 (PWM)

- LED Rojo: PIN 4

- LED Verde: PIN 5

- LED Amarillo: PIN 6

- LED Rojo: PIN 7





Por último nos faltará conectar el botón a nuestro controlador. La pata superior izquierda la conectaremos al PIN 8 del Arduino UNO. Cable negro de la imagen.







Ahora vayamos al programa:
/*
 Programa para un par de semaforos que cambian de uno
 a otro, y la implementacion de un boton para terminar
 el tiempo de la luz verde y pasar al otro.
*/
// Declaramos la variable para el pin del boton
const int button = 8;

void setup() {
 // Con un ciclo activamos los pines del 2 al 7 como salidas
 for (int pin = 2; pin <= 7; pin++) {
   pinMode(pin, OUTPUT);
 }
 // El pin del boton lo ponemos como entrada
 pinMode(button, INPUT);
}

// Funcion para el primer semaforo y sus cambios de estado
void semaphoreOne() {
 digitalWrite(2, HIGH);
 int count = 0;
 while (count < 30) {
   // El ciclo esta en espera mientras el boton no es presionado
   if (digitalRead(button) == true) {
     break;
   }
   count++;
   delay(200);
 }
 // Programamos el cambio entre semaforos. Cuando el LED tiene la posicion LOW estara apagado, mientras que si esta en posicion HIGH estada encendido.
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 delay(500);
 digitalWrite(2, HIGH);
 delay(500);
 digitalWrite(2, LOW);
 digitalWrite(3, HIGH);
 delay(2500);
 digitalWrite(3, LOW);
 digitalWrite(4, HIGH);
 digitalWrite(7, LOW);
 // Mandamos a llamar al otro semaforo
 semaphoreTwo();
}

// Funcion para el segundo semaforo y sus cambios de estado
void semaphoreTwo() {
 digitalWrite(5, HIGH);
 int count = 0;
 while (count < 30) {
   if (digitalRead(button) == true) {
     break;
   }
   count++;
   delay(200);
 }
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 delay(500);
 digitalWrite(5, HIGH);
 delay(500);
 digitalWrite(5, LOW);
 digitalWrite(6, HIGH);
 delay(2500);
 digitalWrite(6, LOW);
 digitalWrite(7, HIGH);
 digitalWrite(4, LOW);
 // Mandamos a llamar al otro semaforo
 semaphoreOne();
}

// Iniciamos nuestro semaforo
void loop() {
 // Cambiamos el estado de todos los leds para
 // que esten apagados todos al inicio
 for (int pin = 2; pin <= 7; pin++) {
   digitalWrite(pin, LOW);
 }
 // Prendemos el verde de un semaforo y el
 // rojo del otro semaforo
 digitalWrite(2, HIGH);
 digitalWrite(7, HIGH);
 // Iniciamos el primer semaforo
 semaphoreOne();
}



  • Digg
  • Del.icio.us
  • StumbleUpon
  • Reddit
  • RSS

Objetivo Y Reclamaciones

Este blog es un portal en el cual se publican contenidos de diferentes blogs.En los cuales se les anexa al pie de pagina un enlace a su pagina original aquí encontraran toda clase de proyectos de arduino y linux
Espero tengan una gran experiencia en este blog un Gran Saludo
de parte de la organización WebCervices..
objetivo
O del grupo ArduinoTec De arduino
Cualquier reclamación o petición comunicar al Administrador principal o hacer un comentario en la publicación que se sientan inconformes en los correos
electriarias@gmail.com
y para temas de suma importancia mi correo personal
pabioarias@hotmail.com

Siguenos en Twitter

Like

Unete a nuestro grupo de facebook

Hola que tal lectores de esta pagina tan maravillosa que es arduino Tec ...Los invito a que amplíen mas sus conocimientos en Arduino y Raspberry Pi Uniéndose a La mi grupo Arduino Tec

Unete Al Grupo De facebook

Unete Al Grupo De facebook
Amplia tus conocimientos debatiendo temas de Arduino y Raspberry pi