Práctica 10 – Motor paso a paso

El motor paso a paso (o stepper en inglés) permite un control muy exacto de posición y velocidad. Es muy usado para aplicaciones de precisión: robots, impresión 3D, CNC, etc. Su principal diferencia con el servo es esa, además del hecho de ser más lento.

Motor paso a paso 28BYJ-48

El funcionamiento de los motores paso a paso podéis encontrarlo con detalle en algunos de los enlaces que ponemos al final de la práctica. Muy brevemente (y sacado de Wikipedia), convierte impulsos eléctricos en desplazamientos angulares discretos, y puede ser gobernado por impulsos procedentes de sistemas lógicos.

El 28BYJ-48 es un motor paso a paso unipolar, barato, sencillo de programar por la cantidad de ejemplos que hay en internet. Funciona a 5 voltios, con relación de reducción 64:1 (aproximadamente) y un máximo de  15 revoluciones por minuto. Necesita un controlador ULN2003 compatible con Arduino, que se puede apreciar en la placa verde en la foto debajo de estas líneas. Tiene 6 pines: 5V y GND (juntos) y otros cuatro para las señales de control (IN1, IN2, IN3, IN4).

stepperEn internet hay muchas librerías, nosotros usaremos la AccelStepper, que permite controlar varios parámetros con más facilidad que las demás *(puedes descargar la versión 1.48 haciendo click aquí) Tiene varias funciones (que puedes consultar aquí) para determinar la velocidad, aceleración, mandar un giro a un ángulo, medir cuánto queda para llegar a ese ángulo, determinar la posición actual, etc.

* en la Práctica 4 ya viste como añadir una librería

La mayor diferencia con la librería “oficial” de Arduino es que los pines se organizan en orden 1,3,2,4 (en vez de 1,2,3,4) y requiere que se declare la secuencia de control como HALFSTEP 8. En “void setup” se debe definir velocidad máxima (o la velocidad) y aceleración. En “void loop” se podrán definir las acciones a realizar, que sólo darán comienzo tras llamar a la función “run()”. En cada bucle el motor tiene bien determinada su posición, siendo una vuelta completa dividida en 4076 pasos.

Componentes necesarios para esta práctica

Al igual que en la práctica anterior, serán necesarios cables macho-hembra para la conexión entre Arduino y el controlador del motor.

El ejercicio a realizar en esta práctica es:

  1. El ejercicio a comienza conectando el motor y cargando la librería. Mediante un potenciómetro controlaremos la velocidad de rotación del motor (que estará rotando de inicio) a una aceleración dada.
  2. En el ejercicio b, también con potenciómetro para la señal de control, controlaremos la posición, para una aceleración y velocidad fijas.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

Para terminar, intentad unir ambos códigos y determinar con un potenciómetro la posición a la que el motor debe girar y con el otro la velocidad con la cual lo ha de hacer.

Como siempre, si tenéis dudas o queréis mostrarnos el resultado, escribidnos a:

practicas@thinkbit.org

Enlaces relacionados

Arduino Reference(ENG): Stepper library
Airspayce(ENG): Creador de la librería AccelStepper
42bots (ENG): 28BYJ-48 Stepper Motor with ULN2003 driver
Web-robotica: Motor de pasos 28BYJ-48 con driver ULN2003
DIYmakers: Mover motores paso a paso con Arduino
Prometec: Motores paso a paso: 28BYJ-48
Electroensaimada: Tutorial Arduino con motor paso a paso
El cajon de ardu: Tutorial: Motor paso a paso con módulo ULN2003
Instructables(ENG): Arduino Library for 28BYJ-48 and ULN2003

Práctica 9 – Sensor PIR

La práctica 9 se centra en programar el sensor pasivo de infrarrojos HC-SR501. Este sensor detecta variaciones en la radiación infrarroja que recibe (y que todos los cuerpos emiten en función de su temperatura interna). Si hay cambios  devuelve una señal digital=1 (“HIGH”), volviendo a cero (“LOW”) cuando deja de percibiar variaciones.  La “entrada de información” será el sensor PIR y como “salida de información” usaremos un simple LED.

Sensor HC-SR501

Este sensor es un tanto especial, pues tiene dos potenciómetros que al girarlos modifican la  sensibilidad (izquierda) y el tiempo entre mediciones (derecha). Es un sensor barato, y por lo tanto de funcionamiento irregular. Tiene tres pines: VCC (5V), GND (tierra) y un pin de salida digital (el del centro). No requiere de librería propia.

sensor_PIR_ThinkBit

Componentes necesarios para esta práctica

 

El ejercicio a realizar en esta práctica es:

  1. Cargad el código, conectad los cables según el esquema de Fritzing. Con un destornillador plano modificad la posición de los potenciómetros hasta conseguir la sensibilidad y latencia que queráis.

Código ejercicio

Archivos .ino

Descarga el ejercicio haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es no desesperarse con el comportamiento impredecible del sensor. Ánimo, ¡nosotros hemos sido capaces!

Enlaces relacionados

Página Arduino Playground(ENG): PIRSense
Makezine(ENG) : PIR Sensor Arduino Alarm
Prometec: Los sensores PIR
Luis Llamas: Detector de movimiento con Arduino y sensor PIR
Guillenxt: Sensor PIR + ARDUINO: Alarma de Movimiento
Instructables(ENG): Arduino-PIR-Motion-Sensor

Prática 1

Nesta prática 1 vamos começar usar o Arduino IDE, no entorno de programação da placa. O exemplo será acender diodos LED, e faze-los piscar. A diferença com a prática anterior, é que agora controlamos o LED mediante ao código e não mediante a um pulsado.

ESTRUTURA DE UM CÓDIGO DE ARDUINO

Se voltarmos ao código de blink no led 13, da prática 0, (o em Arquivo->Exemplos->Básicos->Blink):

6E agora, apagamos todos os “comentários”, é dizer, toda a parte escrita de cor cinza ( o mais concretamente, a que começa por “//” ou está dentro de um “/*   */”. Tereis tudo mais “limpo”:

18

VOIDS

Para começar, observamos se existem duas peças de códigos:

  • Void setup(): Esta parte do código só se executa 1 vez, é dizer, conectar a placa.
  • Void loop(): Esta parte do código se executa internamente  (até que se desconecte o Arduino).

A chave “{“determinam o princípio y “}” o final de cada Void.

Mas espera! Estão nos enganando, existe uma linha de princípio de tudo que não está em nenhum das peças de antes! É verdade, esta linha está inicializando uma variável: É dizer, alguma coisa vale a pena. Aqui precisamos saber que:

  • Variável: Algo que podes atribuir um valor qualquer.
  • Int: Simplesmente está dizendo que a variável é número inteiro (…,-3,-2,-1,0,1,2,3,4…)

Por exemplo, se uma maçã vale 1 real, poderia criar a variável “maçã” e dizer que é igual a 1 real:

Ou por exemplo, se faz 20° fora, poderia criar a variável “temperatura” e dizer:

Podemos chamar a variável como queremos (exceto alguns símbolos estranhos). No código então, o que estamos fazendo é dizer que o número de pin está conectado o diodo LED. Seguimos lendo o código e vemos o que aparece.

Em void setup (só se exercita 1 vez):

  • pinMode(led, OUTPUT)-> nós colocamos o pin que está conectado ao led em modo saída (Dar Voltagem)

Em void loop (se executar continuamente):

  • digitalWrite(led, HIGH) -> enviamos corrente por o pin o que está conectado ao LED (5 volts)
  • delay(1000) -> dizemos ao Arduino que espere, que não faça nada, durante 1000 milisegundos, é dizer, 1 segundo.
  • digitalWrite(led, LOW) -> irá parar de enviar corrente através do pin de LED, por isso vai desligar.
  • delay(1000) -> volta a esperar 1 segundo.

Na seguinte imagem podemos observar de forma resumida:

24

IMPORTANTE: Ao final de cada linha se coloca um símbolo ponto e vírgula ->;

Se não colocar o código não funcionará

IMPORTANTE++: Uma vez que tenhas todo o código pronto, para carrega-lo na placa Arduino tem que pressionar o botão

compilar y cargar

Componentes necessários para está prática

 

Os exercícios a ser realizado nesta prática são:

  1. O exercício a consiste em fazer piscar um LED (de qualquer cor), com uma frequência determinada, partindo do exemplo “Blink”.
  2. O exercício b consiste em fazer piscar dois LEDs (de duas cores que você escolher), de forma sucessiva, novamente com a frequência determinada.

 

Código exercício a

Código exercício b

Archivos .ino

Comentários finais e desafio semanal

Como você percebeu, no exercício (“b”) usamos uma variável que contém o tempo que queremos para durar o pisca do led, e o outro (exercício “a”) simplesmente colocamos esse tempo no delay (aqui) em número. Qualquer uma das formas é correta, mas usar variáveis é muito mais cômodo em códigos mais complexo. Parabéns! Agora você sabe piscar LEDs com Arduino!

Agora, eu desafio você a fazer piscar 5 leds um após o outro, com a velocidade que quiser (e torná-lo atraente).

Você pode enviar o código (e se você quiser, fotos ou vídeos) para o seguinte endereço:

practicas@thinkbit.org

Links relacionados

 

Práctica 8

Esta práctica trata sobre dos sensores, el termistor 103 (que aumenta el valor de su resistencia con la temperatura) y el DHT11, que mide la humedad y temperatura del ambiente.  Las mediciones de ambos sensores se representarán con un servo.

Termistor NTC 103

thermistor

 

Para leerlo habrá que realizar un divisor de tensión. Para medir el valor de la resistencia se usa AnalogRead. Para variar este valor hay que calentarlo (o enfriarlo). Bastará con tocarlo con los dedos unos segundos.

Tener en cuenta que devolverá un valor analógico (de 0 a 1023) que permite ver VARIACIONES de temperatura, en ningún caso valores de ºC reales. Para ello tendríamos que calibrar el sistema (con ayuda de un termómetro medianamente fiable establecer el valor que devuelve el termistor a los 0ºC, el que devuelve a los 10ºC por ejemplo, y extrapolar para los demás valores suponiendo comportamiento lineal del termistor, que al ser un componente barato sólo será así en cierto rango de temperatura).

Sensor de humedad DHT11

Sensor de humedad DTH 11 (humidity sensor)

Sensor de humedad DTH 11 (humidity sensor)

Puede realizar medidas de temperatura y de humedad. Contiene un chip que transforma medidas analógicas a digitales. Requiere de una librería propia para funcionar.

  #include <dht11.h>

La librería la puedes descargar aquí. La hemos sacado del github de Adafruit. Una vez descargada, descomprimela y ponla en la carpeta “libraries” de la carpeta “Arduino”. Reinicia el IDE.

librariedht

En el código deberás poner un nombre a tu sensor DHT11, en este caso se ha usado el mismo nombre:

  dht11 DHT11;

En el void setup habrá que definir a qué pin esta conectado el sensor:

  DHT11.attach(2);

Mediante un variable entera “chk” se hará una comprobación del correcto funcionamiento del sensor.

  int chk = DHT11.read();

Según el valor de este número, tendremos funcionamiento normal, un “0″, o bien otros tipos de errores “-1″, “-2″ o desconocido. Mediante un switch case verificamos:

switch (chk) {
  case 0: Serial.println("OK"); break;
  case -1: Serial.println("Checksum error"); break;
  case -2: Serial.println("Time out error"); break;
  default: Serial.println("Unknown error"); break;
}

Finalmente, mediante dos variables reales (“temperatura” y “humedad”) realizaremos las medidas:

temperatura = DHT11.temperature;
humedad = DHT11.humidity;

Componentes necesarios para esta práctica

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en construir un divisor de tensión para sacar la señal analógica del termistor 103. Su variación la sacaremos visualmente mediante un servo
  2. El ejercicio b consiste en sacar el valor de la humedad ambiente mediante el DHT11, representando su valor también con un servo.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es usar el DHT11 para obtener medidas de temperatura, en vez de humedad. También representar con el servo.

Según lo vayáis completando, mandad el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página Arduino Playground (ENG): Thermistor
Página Arduino Playground(ENG): DHT11
Arduteka: Sensor de temperatura NTC
Adafruit: DHT sensors
Panamahitek: DHT11 sensor de humedad y temperatura
Taller de arduino: Sensor DHT11 con arduino
Opiron: Todo sobre los sensores DHT11 y DHT22
Three House Projects: Internet Based Temperature Sensing System
Instructables(ENG): The super simple Arduino weather web server
Instructables (ENG): DHT11 LCD Weather Station DIY
Instructables(ENG): Arduino portable weather monitor

Práctica 7

En la práctica 7, aprenderemos a usar un led display de 4 dígitos, 7 segmentos, con el fin de representar números. También veremos como descargar librerías y meterlas en nuestro IDE de Arduino.

LED DISPLAY DE 4 DIGITOS, 7 SEGMENTOS

A primera vista, podemos notar que la cantidad de “leds” que se tienen que encender en el display es mucho mayor que el número de pins que tenemos (12). Lo que pasa es que estos pines se dividen en: 1 para cada digito, es decir, 4. Y 12 para los “segmentos”: 7 segmentos forman un dígito + el punto. (NOTA: En el que tenemos, solo funcionan los dos puntos centrales, no los de las comas). Se hace un HIGH al pin de dígito que queramos usar, y LOW a los segmentos que queramos que se enciendan. Se va barriendo muy rápidamente de un dígito a otro, por lo que parece que los 4 están encendidos a la vez, pero en realidad solo hay un dígito encendido en cada momento.

 

Led Display 4 Dígitos, 7 segmentos

 

Como quizás estás empezando a imaginarte, representar números en esto parece ser complicado, hay demasiadas cosas a tener en cuenta. Esto es cierto, por lo que para simplificarnos la vida, vamos a usar una librería que alguien se ha molestado en escribir, y que aparte de colgarla de forma gratuita en internet (Un día lo haréis vosotros también! =D ), nos va a facilitar muchísimo el trabajo. La dirección es la siguiente:

http://playground.arduino.cc/Main/SevenSegmentLibrary

En el video de la práctica se puede ver paso por paso el proceso de instalarla en nuestra IDE.

Hay que tener muchísimo cuidado al poner los cables, es muy fácil equivocarse:

3b

 

3c

Componentes necesarios para esta práctica

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en instalar la librería para controlar el display, y ejecutar el código que trae como ejemplo:  Un contador de tiempo.
  2. El ejercicio b consiste en sacar en el display el número de veces que se ha apretado un botón.

Código ejercicio a


 

Código ejercicio b


Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es mostrar la distancia que obtenemos con el sensor de ultrasonidos en el led display.

Según lo vayáis completando, mandad el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Librería que usamos (Hay más información) : Link (ENG)

Práctica 6

La práctica 6 trata sobre el uso del sensor de ultrasonidos HC-SR04. Este sensor emite un eco y al recibirlo de vuelta produce una señal analógica acorde con el tiempo que ha tardado en recibirlo.  Esto es, obtendremos valores enteros desde “0″ a “1023″ según la distancia al obstáculo.  Mediante el monitor se podrán representar los valores obtenidos. La “entrada de información” será pues el sensor de ultrasonidos y como “salida de información” usaremos LEDs y un servo.

Sensor HC-SR04

Es importante conectarlo bien a los pines indicados. Para usarlo se definirá los valores constantes de los pines (así como llamar a la librería del servo):

#include Servo.h;
#define echoPin 6 
#define trigPin 7

Después se emite un eco de 8 milisengundos de duración por el trigPin:

Y mediante la función “pulseIn” se lee en el echoPin lo que tarda en ser recibido:

 duration = pulseIn(echoPin, HIGH);
 distance = duration/58.2;

El “58.2″ está relacionado con la velocidad del sonido. Son los microsegundos que tarda el sonido en recorrer 1 cm dos veces (una que va y la otra que vuelve).  Modificando este valor obtendremos medidas de distancia erróneas.

Sensor_ObjDec_Ultra_HC_SR04_7Componentes necesarios para esta práctica

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en usar 4 LEDs para representar distancias entre 0 y 20cm, esto es, si el obstáculo (una taza en este caso) está entre los 0 y los 5cm, se enciende un LED, si está entre los 5 y los 10cm se encienden dos, y así hasta 20cm. Si pasa de 20cm, entonces los cuatro LEDs parpadearán.
  2. El ejercicio consiste en hacer uso de un servo para representar la distancia en vez de los LEDs.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es representar la misma distancia (20cm) con 10 LEDs en vez de 4.

Según lo vayáis completando, mandad el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página Arduino Playground(ENG): SR04
Opiron: Todo sobre sensores de ultrasonidos
My Robot Lab(ENG): Use HC SR04 sensors
Three House Projects: HC-SR04 Ultrasonic Tutorial
Instructables(ENG): Simple Arduino and HC-SR04 example
Instructables (ENG): Ultrasonic distance sensor
Instructables(ENG): GoPro + HC-SR04

Práctica 5

En la práctica 5 aprenderemos a usar Leds RGB, los cuales son simplemente 3 leds de 3 colores distintos (Rojo, Verde y Azul) empaquetados en el mismo led. Veremos como controlarlos, aprenderemos el concepto e importancia de las funciones, y profundizaremos en la estructura de bucle condicional for.

Leds RGB

Como ya hemos dicho, (Y nos podemos imaginar), los leds RGB son leds formados por 3 leds de 3 colores distintos. RGB viene de los colores en inglés, Red/Green/Blue. Variando la intensidad de corriente por cada led, podremos obtener cualquier posiblidad en toda la gama de colores.

Al ver un led RGB por primera vez, nos llamará la atención el hecho de que tenga 4 patas (¡Una más larga que las demás y todo!). Imaginemos que tenemos 3 leds y los queremos unir. Vamos a necesitar 3 patitas para controlar cada uno de ellos, pero solo una conectada a tierra, por lo que las “tres patitas que se conectan a tierrra” se unen en una.

Llegado a este punto, hay que hacer una aclaración: Hay dos tipos de leds RGB, de ánodo y cátodo común. Básicamente esto determina como está colocado el diodo y como hay que alimentarlo para hacer que se encienda. Los leds RGB en nuestros kits son de ánodo común, es decir, se encienden alimentando la pata más larga a 5V y brillará más cuanto mayor sea la diferencia de voltaje entre esta pata y la(s) otra(s). (Es decir, si conectásemos una pata a GND, la diferencia sería de 5V y tendríamos mucha luz). En la imagen inferior podemos observar de que patita es cada color:

¿Como lo controlamos? Con los pines PWM, de salida analógica. Con nuestros leds de ánodo común, si sacamos 0 por la salida analógica conectada a una pata (Lo equivalente a tierra), obtendremos mucha luz, y si vamos subiendo nuestra salida, la luz irá disminuyendo de forma gradual, hasta apagarse cuando lleguemos a un valor de 255.

¡Hay que tener en cuenta que si queremos usar leds RGB de cátodo común, todo esto sería al reves!

Funciones

Las funciones nos ayudan a reducir y simplificar el código, sobre todo cuando necesitamos repetir una misma acción una y otra vez. Si nos fijamos en el código del primer ejercicio, abajo del todo podemos ver:

Lo primero que nos puede llamar la atención es el hecho de que escribamos void al principio. Esto es porque void setup y void loop son funciones. Fijaos en el hecho de que se declare nuestra función fuera de estos dos voids. (En un plano más técnico, void es una declaración de una función que no nos devuelve nada, es decir, realiza una acción pero no nos devuelve un dato.)

Tras declararlo como un void, se declara el nombre de la función, y justo después, sus argumentos (O datos que necesita coger). Dentro de las llaves se meten las acciones que queramos que realice nuestra función. Para llamarlo, simplemente escribimos el nombre de la función, y definimos los argumentos necesarios (Ver ejercicios):

setColor(0, 255, 255);

Componentes necesarios para esta práctica

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en un bucle que va a ir poniendo diferentes colores al Led, para poder observar algunas combinaciones. Habrá que fijarse bien en la función setColor.
  2. El ejercicio b consiste en un bucle que irá iluminando gradualmente cada color en orden: Rojo, Verde y Azul. El delay lo controlará un potenciómetro. Es importante notar la estructura for que se ha usado para poder barrer por todas las posibilidades de cada led. Así mismo, la estructura de contador con if’s condicionales se ha hecho para que antes de cada delay se lea el potenciómetro de nuevo y la “respuesta sea más rápida”, sin repetir el mismo bloque de código demasiado.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí 
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es controlar un LED RGB con dos potenciómetros y un LDR (El sensor de luz). Un potenciómetro controlará el led rojo, el otro el verde, y el LDR el azul. 

Según lo vayáis completando, mandad el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página oficial Arduino: Funciones
Tdrobótica: Control de un led RGB
Adafruit (ENG): Arduino tutorial 3 - RGB Leds

Práctica 4

La práctica 4 es la primera donde usaremos algo distinto a los leds como “salidas de información”: servomotores. Un servomotor, normalmente llamado servo (lo llamaremos así a partir de ahora), es simplemente un motor con unos topes que le permiten girar en un rango de 180º (media vuelta), y que puede ubicarse y mantenerse estable en cualquier posición de este rango. Aprenderemos lo que son las librerías, su importancia, y a hacer un bucle condicional for.

Librerías

Podemos imaginarnos las librerías tal como suenan: una gran estantería llena de libros, al que acudimos cuando necesitamos saber o usar algo. En programación, son códigos ya escritos que podemos incluir en nuestro código, para añadirle muchas funcionalidades, como controlar hardware, etc…  Por ejemplo:  queremos usar un servo ahora, pero hacer la programación desde cero para usar un servo no estaría a nuestro alcance, por lo que acudimos a la librería del servo para simplificarnos la vida.

Vienen algo más de una decena de ellos instalados de serie con el IDE de Arduino, pero podemos instalar (¡o hacer nosotros mismos!) todas las que queramos.

La manera de incluir una librería en nuestro código es con:

#include <nombredelalibrería.h>

Servos

Ya hemos explicado lo que son los servos, asi que vamos a aprender a usarlos.

Servo

Servo

 

Podemos observar que de los servos salen tres cables: El más oscuro (Marrón o negro normalmente) es siempre el de tierra, es decir, GND. El rojo será el que hay que conectar a 5V, y el sobrante es el llamado de señal, el que le dice en que posición tiene que estar.

Vamos a ver ahora como usar uno en Arduino.

Primero, incluimos la librería del servo:

#include <Servo.h>

Después, llamaremos a nuestro servo algo, para poder tener varios a la vez y poder distinguirlos:

Servo nombredelservo;

En void setup, tendremos que inciar el servo, diciendo en que pin está conectado el cable de señal:

nombredelservo.attach(pinseñal);

Ahora, solo quedaría girarlo, metiendole un valor entre 0 y 179:

nombredelservo.write(valor)

Bucle Condicional : For

Un bucle es un proceso que se repite una y otra vez (¡Como el void loop!). Son importantísimos en la programación, porque simplifican mucho la vida y nos hacen los códigos más cortos.

Lo que vamos a aprender es a hacer un bucle condicional: Un bucle que se repite solo cuando se cumple una condición. Usaremos la estructura for para ello:

for (Inicialización; Condición; Incremento){
 Código a realizar
}

Vamos a ver esto de una forma más gráfica:

En este bucle: Empezariamos con una variable x=0. La condición para que se vaya repitiendo el bucle es que x sea menor que 100. Mientras se cumpla esta condición, vamos a irle añadiendo 1 a x en cada vuelta. (NOTA: x++ es igual a x=x+1). Cada vez que se repite el bucle, estamos imprimiendo por el serial el valor x, por lo que contaremos de 0 a 99.

Map

Al leer el potenciómetro, nos llega un valor en el rango de 0 a 1023. El servo solo puede girar de 0 a 180 grados, ¿Que hacemos?. Podríamos simplemente dividir 180/1023 y multiplicar esto por el valor del potenciómetro, y obtener un valor “escalado”, pero vamos a ver que hay un método más cómodo: La función map. Tiene la siguiente estructura:

map(nombrevariable, desdevalorbajo, desdevaloralto, hastavalorbajo, hastavaloralto)

Vamos a ver un ejemplo con números. Si tenemos que x=10, y hacemos lo siguiente:

x = map(x, 0, 20, 0, 100)

Obtendríamos x = 50 

Componentes necesarios para esta práctica

 

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en simplemente abrir un ejemplo  preinstalado en arduino (Sweep), y cargarlo. El servo empezará a girar de un lado a otro.
  2. El ejercicio b usa un ejemplo preinstalado también (Knob). Ahora se controlará el giro del servo con un potenciómetro.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí 
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es modificar el ejercicio b para que el potenciómetro, a la vez que se determine la posición del servo, determine cuántos LEDs se encienden (usar 5 LEDs). Esto es, construir un indicador de posición del servo mediante LEDs. Ningún LED encendido si estamos en 0 grados, todos encendidos si estamos en 180 grados (habrá que usar una estructura if para dividir en cinco segmentos la lectura analógica 0-1023 y aplicar una estructura for para encender los LEDs).

Según lo vayáis completando, mandad el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página oficial Arduino(ENG): Servo with knob
Página oficial Arduino(ENG): Include
Tronixstuff(ENG): entre otras cosas...servos
Arduteka: El servomotor
BricoGeek: Control de servomotores
Adafruit(ENG): Lesson 14: servomotors
Instructables(ENG): Using servos
Instructables(ENG): Arduino+Servo+potentiometer
Instructables(ENG): How to #Arduino servo
ArduinoArts(ENG): Servo on IKEA lamp
Página oficial Arduino : Función map

 

Práctica 3

La práctica 3 es una introducción a señales analógicas, esto es, obtendremos valores enteros desde “0″ a “1023″ en vez de “0″ y “1″ como en la práctica anterior. Se introducirá el monitor, que representa los valores obtenidos. La “entrada de información” se hará con un potenciómetro y un LDR (o “light dependent resistor”, resistencia variable con la luz) y volveremos a hacer uso de diodos LED como “salida de información”. Recordad que, simplificando mucho, la labor del microcontrolador es esa, recibir entradas (digitales y analógicas), procesarlas y producir salidas (digitales y analógicas).

Monitor (puerto serie)

Se usa para visualizar los valores obtenidos por Arduino. Mediante el puerto serie (a través del USB) el ordenador recibe información del microprocesador, en concreto el valor de una variable en un instante determinado. Para ello debemos primero inicializar el puerto serie mediante Serial.begin(9600), donde el número entre paréntesis, 9600, corresponde a los baudios (pulsos por segundo). Después en el “void loop” se usa la expresión “Serial.print(nombredelavariable)”, para ver en el monitor el valor de la variable, aunque es más útil “Serial.println(nombredelavariable)” pues así en el monitor vemos un valor por línea (en el caso anterior los coloca seguidos). Para activar el monitor basta con hacer CTRL+Shift+M después de compilar y descargar al Arduino el código.

monitor

Divisor de tensión

Un divisor de tensión es un circuito usado para dividir la tensión (ohh si, premio para mí) entre varias resistencias. Nosotros lo usaremos para obtener la señal analógica del LDR. Tendrá este aspecto:

divisordevoltaje

 

Componentes necesarios para esta práctica

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en controlar la frecuencia de encendido de un LED mediante un potenciómetro. Girando el potenciómetro variamos el valor de su resistencia. Sacamos ese valor mediante un pin “ANALOG IN”, en este caso el A0, lo leemos con un “analogRead” y así conseguimos un valor desde “0″ a “1023″. Asignamos esa lectura al delay.
  2. El ejercicio b usa prácticamente el mismo código que el ejercicio a. La diferencia importante es que sustituye el potenciómetro por un LDR, que varía su resistencia no mediante un giro mecánico sino mediante la luz que recibe.  Para ello, debemos realizar un circuito denominado “divisor de tensión”. Para añadir interés a la práctica, hemos realizado un escalado del valor de la lectura abriendo la posibilidad de dar un valor máximo de delay deseado al declarar una variable tipo “float“, un número real en el cual almacenaremos el resultado de la operación de reescalado.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

El reto de este semana es encender secuencialmente 5 LEDs controlando la velocidad (o sea el delay) con un potenciómetro. Intentad que sea lo más sensible posible a los cambios que realizáis (que no tenga que esperar al siguiente loop para cambiar de velocidad. Con esto nos referimos a simplemente volver a leer el potenciómetro antes de cada delay).

Según lo vayáis  completando, mandad el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página oficial Arduino: AnalogInput
Página oficial Arduino(ENG): Analog Read Serial
Página oficial Arduino(ENG): Calibration
Opiron: Todo sobre el LDR
Arduteka: Sensor LDR
Arduteka: Entrada analógica y salida PWM
Adafruit(ENG): Digital inputs
Ladyada(ENG): Lesson 4: serial communications
Sparkfun(ENG): Analog Signals
Sparkfun(ENG): Analog to digital conversion
Instructables(ENG): Serial communications + bluetooth
Bildr(ENG): Simple light reading with LDR

Práctica 2

En esta práctica 2 vamos a empezar a trabajar con señales digitales, “1″ y “0″ lógicos, y mediante condicionales (“if”) decirle al microcontrolador qué hacer en cada uno de los dos casos. La “entrada de información” se hará con pulsadores (o “pushers”) y volveremos a hacer uso de diodos LED como “salida de información”. Recordad que, simplificando mucho, la labor del microcontrolador es esa, recibir entradas (digitales y analógicas), procesarlas y producir salidas (digitales y analógicas). La práctica 2 va sólo de las digitales.

ESTRUCTURA CONDICIONAL “IF”

Se usa para determinar si se ha producido la situación que queremos. En el ejemplo de abajo:

Quiere decir esto: si la señal que viene del pulsador es “HIGH” (o sea un “1″ lógico, o sea que está pulsado), entonces poner el pin 4 en “HIGH” ( en “1″, enceder el LED que está en ese pin); si no, ponerlo en “LOW” (“0″ lógico, apagarlo).

 IMPORTANTE: entre el GND y el pulsador hay una resistencia llamada “pull down” que nos garantizará que de inicio tenemos un “0″ lógico. En realidad es redundante, pues Arduino ya tiene internamente esta resistencia, pero el concepto es importante.

IMPORTANTE+: Al final de cada línea se pone el símbolo punto y coma–>;

Si no lo ponemos el código no funcionará

IMPORTANTE++: una vez tengáis listo el código, para cargarlo en la placa Arduino tenéis que darle a este botón

compilar y cargar

Componentes necesarios para esta práctica

 

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en encender un LED a partir de un pulsador, pero no como lo hacíamos en la práctica 0 (donde el pulsador era un mero interruptor). En este caso lo haremos mediante una señal digital que controlaremos con el pulsador.
  2. El ejercicio b consiste en dos pulsadores y tres LEDs: si pulsamos el pulsador derecho, se enciende el LED derecho, si pulsamos el LED izquierdo, se enciende el izquierdo. Si pulsamos los dos a la vez, se encienden y parpadean los tres LEDs. Esta última condición se expresa mediante el símbolo “&&”, que indica que en un condicional deben ocurrir dos cosas a la vez.

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

En el ejercicio b usamos la misma resistencia para los tres LEDs, de esa manera ahorramos espacio.

El reto de este semana es incluir un tercer pulsador al ejercicio b, con las siguientes condiciones:

  1. si pulsamos los dos pulsadores de la izquierda a la vez, se encienden los dos LEDs de la izquierda.
  2. si pulsamos los dos pulsadores de la derecha a la vez, se encienden los dos LEDs de la derecha.
  3. si pulsamos los tres pulsadores a la vez, sólo se enciende el LED del centro.

Podéis mandar el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página oficial Arduino: flowcontrol condicional if
Página oficial Arduino(ENG): DigitalReadSerial(CTRL+Mayúscula+M para Serial Monitor)
Página oficial Arduino(ENG): Button+LED(CTRL+Mayúscula+M para Serial Monitor)
Arduteka: E/S digitales
Adafruit(ENG): Digital inputs
Ladyada(ENG): Lesson 5: digital inputs,if/if-else statements 
Sparkfun(ENG): Digital Signals 
Sparkfun(ENG): Pull-up resistors

 

Práctica 1

En esta práctica 1 vamos a empezar a usar el Arduino IDE, el entorno de programación de la placa. El ejemplo será encender diodos LED, y hacerlos parpadear. La diferencia con la práctica anterior, es que ahora controlaremos el LED mediante código y no mediante un pulsador.

ESTRUCTURA DE UN CÓDIGO DE ARDUINO

Si volvemos al código del blink en el led 13, de la práctica 0, (o en Archivo->Ejemplos->Basics->Blink):

6Y ahora, borramos todos los “comentarios”, es decir, toda la parte escrita de color gris (o más concretamente, la que empieza por “//” o está dentro de un “/*       */”. Tendremos todo más “limpio”:

18

VOIDS

Para empezar, vemos que hay dos grandes trozos del código:

  • Void setup(): Esta parte del código solo se ejecuta 1 vez, es decir, al conectar la placa.
  • Void loop(): Esta parte del código se ejecuta eternamente (hasta que desconectemos el Arduino).

La llave “{” determinan el principio y “}” el final de cada void.

¡Pero espera! Nos estás engañando, ¡hay una linea al principio del todo que no está en ninguno de los dos trozos de antes!. Es verdad, esta linea está inicializando una variable: Es decir, está diciendole a algo lo que vale. Aqui tenemos que saber que:

  • Variable: Algo a lo que le puedes asignar un valor cualquiera.
  • int : Simplemente está diciendo que la variable es un numero entero (…,-3,-2,-1,0,1,2,3,4…)

Por ejemplo, si una manzana vale 1 euro, podria crear la variable “manzana” y decir que es igual a 1 euro:

int manzana = 1

O por ejemplo, si hace 20º fuera, podría crear la variable “temperatura” y decir:

int temperatura = 20

Podemos llamar a la variable como queramos (excepto algunos símbolos extraños). En el código entonces, lo que estamos haciendo es decir en qué número de pin está conectado el diodo LED. Seguimos leyendo el código y vemos qué es lo que aparece.

En void setup (sólo se ejecuta 1 vez):

  • pinMode(led, OUTPUT) -> nos pone el pin al que esta conectado el led en modo salida (Dar voltaje)

En void loop (se ejecuta continuamente):

  • digitalWrite(led, HIGH) -> enviamos corriente por el pin al que está conectado el led (5 voltios)
  • delay(1000) -> le decimos al Arduino que espere, que no haga nada, durante 1000 milisegundos, es decir, 1 segundo.
  • digitalWrite(led, LOW) -> le dejamos de enviar corriente por el pin al led, por lo que se apagará.
  • delay(1000) -> volvemos a esperar 1 segundo.

En la siguiente imagen podemos verlo de forma resumida:

24IMPORTANTE: Al final de cada línea se pone el símbolo punto y coma–>; 

Si no lo ponemos el código no funcionará

IMPORTANTE++: una vez tengáis listo el código, para cargarlo en la placa Arduino tenéis que darle a este botón

compilar y cargar

Componentes necesarios para esta práctica

 

Los ejercicios a realizar en esta práctica son:

  1. El ejercicio a consiste en hacer parpadear un LED (del color que queráis), con una frecuencia determinada, partiendo del ejemplo “Blink”.
  2. El ejercicio b consiste en hacer parpadear dos LEDs (de los colores que elijáis también), de forma sucesiva, de nuevo con una frecuencia determinada.

 

Código ejercicio a

Código ejercicio b

Archivos .ino

Descarga el ejercicio a haciendo click aquí
Descarga el ejercicio b haciendo click aquí

Comentario final y RETO SEMANAL

Como habrás notado, en un ejercicio (en el “b”) usamos una variable que contiene el tiempo que queremos que dure el parpadeo del led, y en el otro (ejercicio “a”) simplemente hemos metido ese tiempo en el delay(aquí) en número. Cualquiera de las dos formas es correcta, pero usar variables es mucho más cómodo en códigos más complejos. ¡Enhorabuena! ¡Ya sabes hacer parpadear Leds con Arduino!

Ahora, te retamos a hacer parpadear 5 leds en línea, uno tras otro, con la velocidad que queráis (y que sea vistoso).

Podéis mandar el código (y si queréis, fotos o vídeos) a la siguiente dirección: practicas@thinkbit.org

Enlaces relacionados

Página oficial Arduino(ENG): Blink
Página oficial Arduino(ENG): Blink without delay
Arduteka: HOLA MUNDO
Opiron: Semáforo
Tronixstuff(ENG): LEDs
Bricogeek: Primeros pasos
Adafruit(ENG): All about LEDs
Instructables(ENG): Blinking LED
Instructables(ENG): Multiple blinking LEDs

 

Práctica 0

Antes de ponernos a hacer cosas, unas palabras de agradecimiento para los cracks que idearon Arduino con la intención de crear una plataforma educativa. Un espíritu al cual millones de aficionados debemos el poder aprender a programar un microcontrolador, ¡ahí es nada!. Después mira el video y lee el texto.team-arduino1

Esta práctica “0″ pretende exponer los conocimientos básicos para empezar a montar proyectos con Arduino.

COMPONENTES DE LA PLACA ARDUINO

El elemento principal es la placa Arduino, la cual está compuesta por estos elementos:

ArduinoUNO_Front_indicacionesNo es necesario que entiendas qué es cada cosa, simplemente dónde están situadas para en el futuro próximo usarlas.

DESCARGA DE SOFTWARE

Para poder programar el Arduino necesitarás descargar el IDE (entorno de desarrollo). Es un programa que no requiere instalación y que encontrarás en la página web de Arduino. ¡Ojo!, entra en la página en su versión inglesa, pues contiene las versiones más actualizadas (a Diciembre 2013 la última versión es la 1.0.5).  Según que OS tengas (Windows, Linux, iOs) deberás elegir un archivo u otro:

http://arduino.cc/en/Main/Software

IMPORTANTE: para que el PC reconozca la placa cuando esta se conecte por USB, hay que instalar los drivers del Arduino. Sigue los pasos indicados en el vídeo.

IMPORTANTE+: una vez dentro del IDE, deberás seleccionar en Tools/Board la opción Arduino Uno para que el PC sepa qué versión de Arduino estás usando. Sigue los pasos indicados en el vídeo.

IMPORTANTE++: es probable que también necesites actualizar el entorno de desarollo de Java (Java Development Kit). Entra en el link inferior y descarga la versión “Java SE Development Kit 7u45″. Lo más probable es que tengas Windows de 32 bits. En tal caso descarga la versión “x86″.

http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html

COMPONENTES NECESARIOS PARA ESTA PRÁCTICA

Los ejercicios ha realizar en esta práctica, una vez instalados los elementos necesarios para trabajar, son:

  1. Primero se probará que el software y los drivers funcionen correctamente. Para ello se usará un LED que Arduino lleva incorporado en el pin 13.
  2. El ejercicio a consiste en conectar un LED entre los pines de 5V y GND. Importante colocar una resistencia, para evitar que el LED se queme. Cambiar las resistencias servirá para comprobar cómo al aumentar el valor de la misma, disminuye el brillo.
  3. El ejercicio b consiste en el mismo circuito más un pulsador.

ANEXO 1: LECTURA DE LAS RESISTENCIAS

Las resistencias se identifican por bandas de colores. Las dos primeras indican un número del 00 al 99. La tercera indica por cuánto se multiplica (10, 100, 1000,…). Dependiendo del color tendrá un valor u otro (click en la imagen para ampliar):

Codigo de Colores

Ejemplo: 330 ohmios

  1. Primera banda: naranja—> 3
  2. Segunda banda: naranja—> 3
  3. Tercera banda: marrón—>x10

33 x 10 = 330

ANEXO 2: CONFIGURACIÓN DE LA BREADBOARD

La placa de prototipado está configurada de manera especial para facilitar el cableado.

  • En la figura se aprecian cuatro líneas, dos arriba y dos abajo, dos con símbolo “+” y otras dos con “-” al lado derecho. Se usarán para conectar a los pines 5V y GND del Arduino. Los pines dentro de los recuadros horizontales (verde, verde claro, azul o morado) están conectados entre ellos pero NO con los de un recuadro de otro color.
  • De la misma manera, los pines dentro de los recuadros verticales (rojo, naranja, amarillo) están conectados a pines del mismo recuadro pero NO con pines de recuadros de un color diferente.

Haz click en la imagen para ampliar. Con el uso entenderéis su utilidad.

BreadBoard de 830 puntos (los recuadros de colores marcan conjuntos de pines que son el mismo punto eléctrico)