Primeros pasos con Arduino, práctica 1: el coche fantástico By salva el 19 Mayo 2010 » 6 Comentarios »»»
Arduino, Arduino, Electrónica,, Electrónica Proyectos Darle 5/5
arle 1/5 arle 2/5 arle 3/5 arle 4/5 arle 5/5 Su voto: Nada Average: 4.7 (6 votos)
Arduino es un sistema microcontrolado de hardware libre y código abierto, multiplataforma, barato, con un entorno de programación sencillo y simple, basado en el microcontrolador ATMEGA en sus diferentes versiones de Atmel. Existen diferentes versiones de las placas arduino, yo he usado la llamada Arduino Duemilanove es la sucesión de la Arduino Diecimila, que monta el nuevo procesador ATMega328. Dispone de 14 pines de entada y salida digitales, de los cuales 6 se pueden usar como salidas PWM (Pulse Width Modulation), 6 entradas analógicas, se conecta al puerto USB, (con un cable como el de las impresoras), también dispone de un conector de corriente. Todo lo que necesitamos saber sobre este estupendo sistema está en la web oficial::http://www.arduino.cc/ oficial En Tecnología es un sistema ideal para controlar los proyectos que solemos realizar con nuestros alumnos, control de puertas, barreras, semáforos, ascensores,… En esta y sucesivas entregas iremos realizando prácticas básicas basadas en este hardware: Para comenzar necesitamos: Descargar e instalar el instalar el entorno de programación Arduino. No hace falta instalación simplemente descomprimimos el paquete en una carpeta y lanzamos el ejecutable “arduino”. Conectar nuestra placa al PC. Si no detecta automáticamente los drivers éstos los podremos encontrar en la carpeta arduino-xx/drivers/FTDI USB Drivers/ Arrancamos el entorno, y en el menú m enú Tools configuramos la conexión (serial Port) y nuestra placa (en este caso Arduino Duemilanove). La sintaxis del lenguaje es muy parecida al lenguaje C, la estructura básica de cualquier programa es la siguiente: void setup() { //declaro }
variables,
asigno
PinMode
o
inicializo
las
comunicaciones
serie.
void loop() { //se ejecuta a continuación, incluye el código que lee entradas, activa salidas...es el núcleo del código. } Os aconsejo leer el manual adjunto para ampliar un poco más en el entorno Arduino, en él encontrareis un apartado donde se describen la base de la programación de este sistema, muy fácil si tenemos conocimientos de programación. A partir de aquí podremos em pezar con nuestras prácticas:
Práctica
1:
El
coche
fantástico.
Necesitaremos 8 diodos LED, ocho resistencias de 220 Ohmios y una placa de prototipos y conectamos el esquema como el de la figura. Los diodos leds se encenderán y apagaran siguiendo un patrón establecido en el código, se muestran tres posibles opciones, podremos variar el tiempo de encendido y apagado, modificando la variable timer. Aquí el código: /* Co c h e f an tátic o 1* / int pinArray[] = {2, 3, 4, int count = int timer = 70; void for (count=0;count<8;count++) pinMode(pinArray[count], } } void loop() for (count=0;count<8;count++) digitalWrite(pinArray[count], delay(timer); digitalWrite(pinArray[count], delay(timer); } for (count=7;count>=0;count--) digitalWrite(pinArray[count], delay(timer); digitalWrite(pinArray[count], delay(timer); } }
5,
6,
7,8,9}; 0; setup(){ { OUTPUT);
{ { HIGH); LOW);
{ HIGH); LOW);
/* El c o c h e f an t ás tic o 2*/ int pinArray[] = {2, 3, 4, 5, 6, 7,8,9}; int count = 0; int timer = 15; //timer marca como queremos que vaya de rápido la ráfaga de encendido-apagado de los LEDS void setup(){ for (count=0;count<8;count++) { pinMode(pinArray[count], OUTPUT); } }
void for digitalWrite(pinArray[count], delay(timer); digitalWrite(pinArray[count delay(timer); digitalWrite(pinArray[count], delay(timer*2); } for digitalWrite(pinArray[count], delay(timer); digitalWrite(pinArray[count delay(timer); digitalWrite(pinArray[count], delay(timer*2); } }
loop() (count=0;count<7;count++)
+
{ { HIGH); 1],
HIGH); LOW);
(count=7;count>0;count--)
-
{ HIGH); 1],
HIGH); LOW);
/* Es tr el la f u g az *--------------* Este programa es una variante del ejemplo del coche * fantástico. Muestra mediante un loop una estrella * fugaz que es dibujada en una linea de LED-s * directamente conectados a la placa Arduino * * Puedes controlar la velocidad a la que la estrella * se mueve gracias a una variable llamada "waitNextLed" * * También puedes controlar la longitud de la cola * de la estrella a través de la variable "tail length" * * @author: Cristina Hoffmann * @hardware: Cristina Hofmann * */ // Variable declaration int pinArray [] = { 2,3,4,5,6,7,8,9,10,11,12 }; // Declaración de los PIN-es mediante un array int controlLed = 13; // LED de control int waitNextLed = 100; // Tiempo antes de encender el siguiente LED int tailLength = 4; // Número de LED-s que permanecen encendidos antes de empezar a apagarlos para formar la cola int lineSize = 11; // Número de LED-s conectados (que es también el tamaño del array) void setup() // Configuración de los PIN-es como salida digital { int i; pinMode (controlLed, OUTPUT); for (i=0; i< lineSize; i++) { pinMode(pinArray[i], OUTPUT) ; } } void loop() { int i;
int tailCounter = tailLength; // Se establece la longitud de la cola en un contador digitalWrite(controlLed, HIGH); // Se enciende el LED de control para indicar el inicio del loop for (i=0; i 0) tailCounter--; } for (i=(lineSize-tailLength); i
Arduino: práctica nº 2: Control mediante pulsadores By salva el 21 Mayo 2010 » 1 Comentario »»»
Arduino, Electrónica Darle 4/5
arle 1/5 arle 2/5 arle 3/5 arle 4/5 arle 5/5 Su voto: Nada Average: 4 (1 vote)
Bien en esta segunda práctica usaremos unos pulsadores para controlar el encendido de un diodo LED; ¿cómo conectamos un pulsador? Usaremos un divisor de tensión, como se aprecia en la figura, con una resistencia en Pull-down, de forma que cuando pulsemos la entrada digital tome el valor alto. Declaramos el pin como entrada y usamos la función DigitalRead() para leer el valor de dicha entrada.
Se proponen tres ejercicios diferentes, 1. Este es el más sencillo, al accionar el pulsador enciendo un diodo LED, al soltar se apaga: int buttonPin = 2; int ledPin = 13; int estado = 0; void setup() { pinMode(ledPin, OUTPUT); pinMode(buttonPin, INPUT); } void loop(){ estado = digitalRead(buttonPin); if (estado == HIGH) { digitalWrite(ledPin, HIGH); } else {
digitalWrite(ledPin, LOW); } } 2. Ahora con dos pulsadores, al accionar el pulsador 1, enciende el Diodo, al accionar el pulsador 2, apaga el diodo. int ledPin = 13; int inputPin1 = 2; // pulsador 1 int inputPin2 = 3; // pulsador 2 int p1; int p2; void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin1, INPUT); pinMode(inputPin2, INPUT); } void loop(){ p1=digitalRead(inputPin1); p2=digitalRead(inputPin2); if (p1 == HIGH) { digitalWrite(ledPin, HIGH); } else if (p2 == HIGH) { digitalWrite(ledPin, LOW); } } 3. Ahora usamos los pulsadores para iluminar más o atenuar la luz del led, para ello debemos cambiar la conexión del Led al pin 9, que usa la salida PWM, modulación por ancho de pulso, como si de una salida analógica se tratara. int ledPin = 9; int inputPin1 = 2; // pulsador 1 int inputPin2 = 3; // pulsador 2 int p1; int p2; int value = 0; void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin1, INPUT); pinMode(inputPin2, INPUT); } void loop(){ p1=digitalRead(inputPin1); p2=digitalRead(inputPin2); if (p1 == HIGH) { value--; } else if (p2 == HIGH) { value++; } value = constrain(value, 0, 255); analogWrite(ledPin, value); delay(10); } - See more at: http://www.tecnosalva.com/arduino-pr%C3%A1ctica-n%C2%BA-2-control-mediantepulsadores#sthash.zh4NPEAA.dpuf
Prácticas 3 y 4 con arduino: control de un motor y un servomotor By salva el 24 Mayo 2010 » 10 Comentarios »»»
Arduino, Electrónica Darle 5/5
arle 1/5 arle 2/5 arle 3/5 arle 4/5 arle 5/5 Su voto: Nada Average: 4.5 (4 votos)
Vamos a controlar un motor, lo conectaremos según el esquema adjunto al pin 9 de Arduino, para poder modular el pulso, realizaremos varias prácticas: 1. Arrancamos el motor, esperamos un tiempo, después apagamos el motor. int motorPin = 9; void setup()
{ pinMode(motorPin, OUTPUT); } void loop() { int onTime = 2500; int offTime = 1000; digitalWrite(motorPin, HIGH); delay (onTime); digitalWrite(motorPin, LOW); delay (offTime); }
2. Al igual que antes cambiabamos la iluminación del led, ahora podemos controlar la velocidad del motor con la función analogWrite(pin, valor). int motorPin = 9; void setup() { pinMode(motorPin, OUTPUT); } void loop() { int onSpeed = 200; int onTime = 2500; int offSpeed = 50; // a number between 0 (stopped) and 255 (full speed) int offTime = 1000; //the number of milliseconds for the motor to turn off for analogWrite(motorPin, onSpeed); // turns the motor On delay(onTime); // waits for onTime milliseconds analogWrite(motorPin, offSpeed); // turns the motor Off delay(offTime); // waits for offTime milliseconds }
3. Aceleramos y desaceleramos el motor , ahora usamos un bucle para acelerar y frenar el motor, usando del mismo modo la función analogWrite(), que en el caso anterior. int motorPin = 9; void setup() { pinMode(motorPin, OUTPUT); } void loop() { int delayTime = 50; tor for(int i = 0; i < 256; i++){ //aceleramos analogWrite(motorPin, i); delay(delayTime); } for(int i = 255; i >= 0; i--){ //frenamos analogWrite(motorPin, i); delay(delayTime); } }
4. Usamos ahora un potenciómetro para variar la velocidad del motor. El potenciómetreo se conecta de la siguiente forma, extremos a v+ y gnd y el pin de control al pin 0 de las entradas análogicas de Arduino. Arduino dispone de 6 entradas analógicas, que tienen un voltaje de 0 a 5voltios que convertidas a señales digitales tendríamos de 0 a 1024, esto es 10 bits de resolución. ¿Por qué dividimos por 4 analogRead()?, pues porque esta función devuelve un valor comprendido entre 0 y 1024 (10 bits) y la función analogWrite () toma valores comprendidos entre 0 y 255 (8 bits). int motorPin = 9; int potPin=0; int potValue; void setup() { pinMode(motorPin, OUTPUT); } void loop() { potValue = analogRead(potPin) / 4; analogWrite(motorPin, potValue); }
5. Control de un servomotor #include Servo myservo; // creamos un objeto servo para controlar nuestro servo int pos = 0; // variable para almacenar la posición del servo void setup() { myservo.attach(9); // attaches the servo on pin 9 to the servo object } void loop() { for(pos = 0; pos < 180; pos += 1) // avanza de 0 a 180 grados { // en saltos de un grado myservo.write(pos); // mueve a la posición de la variable 'pos' delay(15); // espera 15ms } for(pos = 180; pos>=1; pos-=1) // va de 180 a 0 grados { myservo.write(pos); delay(15); } } - See more at: http://www.tecnosalva.com/pr%C3%A1cticas-3-y-4-arduino-control-motor-yservomotor#sthash.LVUgcSQu.dpuf
Cómo hacer un cubo de leds 4x4x4 con Arduino By salva el 22 Ene 2014 » 4 Comentarios »»»
Arduino,
Proyectos
arle 1/5 arle 2/5 arle 3/5 arle 4/5 arle 5/5 Sin votos aún
Este cubo LED utiliza un microcontrolador Arduino Uno para crear un espectáculo de luces en movimiento muy espectacular. Para realizar este proyecto con éxito la paciencia es una de las claves, si sigue el tutorial paso a paso no tendrá ningún problema en desarrollarlo. Por último, lo más importante en este proyecto es que te diviertas .
¿qué vamos a necesitar?
Arduino Uno (yo he usado Arduino Duemilanove) Cable rígido para unir los diodos en el cubo 64 diodos led (yo usé diodos leds azules) 16 resistencias de 220 Ohmios Pinzas de cocodrilo Un trozo de porexpan Cables de conexión y placas Board para montar el circuito. Alicates de corte y punta plana de precisión.
El diseño Antes de comenzar la construcción, es importante tener una visión completa de cómo va a funcionar, para que pueda improvisar e identificar los errores a medida que avanzas. Necesitamos controlar los 64 leds del cubo con tan solo 20 pin de la placa de arduno, vamos a estar utilizando una técnica denominada multiplexación. Rompemos el cubo en cuatro capas separadas por lo que sólo necesitamos pines de control para 16 LEDs - de modo para encender un LED específico, debemos activar tanto la capa , y el pin de control , que nos da una necesidad total de 16 +4 pines.
Cada capa tiene un cátodo común - la parte negativa del circuito - así que todas las patas negativas se unen entre sí , y se conecta a un solo pin para esa capa . En el lado (positivo ) de ánodo , cada LED se puede conectar a la correspondiente LED en la capa por encima y por debajo de ella . En esencia , tenemos 16 columnas de las patas positivas y 4 capas de la negativa. El siguiente diagrama en 3D muestra perfectamente la idea :
La construcción Lo primero es tomar el trozo de porexpan y pegar en él la plantilla para poder armar el cubo. A continuación ya podemos ir doblando los cátodos (piernas cortas) de los LED 90 grados y luego soldar a todos juntos para formar un cátodo común. Cada una de las cuatro capas contará con un cátodo común y 16 ánodos individuales (piernas largas).
Debes doblar todas los cátodos de los Leds de manera uniforme, yo me ha ayudado de unos alicates de precisión pequeños, como los de la imagen. Con un poco de paciencia voy soldando de cuatro en cuatro los catodos de los diodos. El siguiente paso es utilizar un cable para conectar las cuatro filas juntos en una capa, se podría utilizar cuatro tiras de alambre por capa, pero en realidad sólo se necesitan dos iguales - una tras la primera tira de LEDs y un segundo antes de la última tira de LEDs. Yo he usado tres tiras por capa para dar una mayor sensación de cubo unido, en la imagen de abajo podrás observar como quedaría cada capa con un cátodo común y 16 ánodos individuales. Asegúrese de recortar cualquier exceso de cable colgando sobre el borde de su cubo , también puedes recortar los cuatro cátodos que sobresalen del borde de la capa. Recuerda que en las soldaduras debes usar el menor contacto y tan poco de soldadura como sea posible. Recuerde, más estaño en cada soldadura no es sinónimo de mayor fuerza en la unión, al contrario podría dar problemas más adelante.
Soldando las cuatro capas. Ahora que tenemos las cuatro capas individuales, vamos a sol darlas entre si para formar el cubo. Vamos a hacer esto al unir los 16 ánodos de cada capa juntos para que nos quedamos con 16 ánodos comunes y 4 cátodos comunes. Lo primero que debe hacer es doblar el último mm de cada ánodo hacia el centro del LED, esto le ayudará a unir las capas entre sí. Sólo tiene que hacer esto con tres de sus capas superiores.
A partir de aquí tendremos que darnos m aña para completar la tarea, podeis usar: 1. 2.
Separdores de cartón entre capas para facilitar la tarea de soldar los 16 ánodos. Usar pinzas de cocodrilo para sujetar las capas mientras las sueldo. Mi consejo es que soldar los ánodos de las esquinas juntos primero. Repita esto para las dos capas restantes y su cubo estará completo.
Conexionado y Programa en Arduino Bueno vamos ahora al conexionado del cubo a la placa arduino y posterior programación, Usamoa las placas board para pinchar el cubo, y conectamos a cada uno de los 16 ánodos cómunes una resistencia de 220 Oh, que a su vez se conectarán a los puertos de Arduino, como se muestran en el gráfico siguiente. A su vez cada capa que forman los cátodos comunes se conectarán a los puertos A2. A3, A4 y A5.
Una vez realizadas las conexiones me puedo descargar cualquiera de los dos programas adjuntos, cada uno de ellos muestran animaciones diferentes.
Si usted desea hacer sus propias animaciones , sigue leyendo y voy a explicar cómo funciona. Así , cuando se abrió el código en el software de Arduino, te habrás dado cuenta de la gran bloque de código en el medio que parecía un poco a esto.
Este gran bloque de código en el medio es donde se desarrollan los patrones de encendio de los leds del cubo. La manera más fácil de pensar en ella es como una animación . Cada cambio en el cubo representa un fotograma de la animación, y cada línea de código representa un fotograma. En cada línea hay 64 bits de 1 y 0 , se dividió en 16 bloques de 4 bits cada uno, los cuatro primeros nibbles (cuartetos de bits) corresponden a la capa 1, los siguientes a la capa 2 y asi hasta la cuatro. Si hay un 1, entonces eso significa que un LED se encendió, si hay un 0, entonces no va a lucir.
Por ejemplo si tenemos esta línea: B1000,B1000,B1000,B1000, B0000,B0000,B0000,B0000, B0000,B0000,B0000,B0000,B0000,B000 0,B0000,B0000, 10, He separado por colores cada capa, de forma que el color negro corresponde a la capa 1(la inferior), la rojo a la dos, verde tres y azul la cuarta capa. Bien en las capas 2, 3 y 4 todo está a cero significa que todos los leds de esas capas están apagados, sin embargo si observamos la capa 1 (la inferior) vemos que está encendido el primer led de cada nibble (cuarteto), lo que quiere decir que lucirán los leds de la fila inferior del fondo. El último valor de la fila indica el tiempo que permanece la secuencia.
Trata de probar con sus propias animaciones, mi consejo es utilizar los comentarios para darse un recordatorio de lo que hace cada animación. Usted puede escribir un comentario en el programa escribiendo "/ /" y luego el comentario.
En esta web: http://www.robota.nl/en/blog/led-cube-4x4x4-pattern-designer/led-cube-si... puedes hacerte tus propios patrones de encendido de los leds, con un poco de paciencia e imaginación, pueden quedar unos resultados espectaculares, si quieres en los comentarios puedes enviar los tuyos para que los podamos probar. Fuentes:
[http://www.techmadeeasy.co.uk/2013/01/21/make-your-own-4x4x4-led-cube-wi...
[http://www.makeuseof.com/tag/how-to-make-a-pulsating-arduino-led-cube-th.
- See more at: http://www.tecnosalva.com/c%C3%B3mo-hacer-cubo-leds-4x4x4arduino#sthash.4sKpcJB8.dpuf
