Entradas y salidas: digitales y analógicas

• Sensores tipo apagado-encendido – Interruptores (switches)

– Termostatos

– Interruptores magnéticos

– Interruptores de presión

– Interruptores de inclinación

– Sensor de infrarrojos, PIR, (Passive Infrared Sensor)

• Controlar la luz (u otros inputs) con pulsos modulados PWM (Pulse Width Modulation): reguladores de intensidad.

Salidas analógicas: regulación de intensidad con PWM

• La idea es jugar con los tiempos de encendido y apagado.

• Esto lo podemos hacer colocando retardos en el código, pero es incómodo y poco eficiente.

• Con Arduino podemos modular la intensidad usando los pines analógicos 3, 5, 6, 9, 10 y 11.

• Se controlan con la función analogWrite(pin, valor) – valor: un nº entre 0 y 255

Los sensores analógicos necesitan un tipo diferente de pin a los de los sensores de respuesta si-no.

• en la placa Arduino hay 6 pines marcados como

‘ANALOG IN’ (A0 a A5). • la función para leer la información de este tipo de

entradas es analogRead(pin).

• analogRead() devuelve un valor entre 0 y 1023 para voltajes entre 0 y 5 voltios. Vamos a practicar con nuestros sensores analógicos.

Entradas y sensores analógicos

Sketch para aumentar y disminuir la

intensidad del LED

• /* Disminuir y aumentar la intensidad del LED */

• const int LED = 9; // the pin for the LED • int i = 0; // usamos este contador para contar hacia arriba y

// hacia abajo

• void setup() { • pinMode(LED, OUTPUT); // tell Arduino LED is an output • } • void loop() { • for (i = 0; i < 255; i++) { // bucle de 0 a 254 (intensidad

//aumenta) • analogWrite(LED, i); // establecer el brillo del LED • delay(10); // esperar 10ms: analogWrite es instantáneo • // y podríamos no ver el cambio • } • for (i = 255; i > 0; i--) { // loop from 255 to 1 (fade out) • analogWrite(LED, i); // establecemos el brillo del LED • delay(10); // esperar 10ms • } • }

Salidas analógicas

// Mantener encendido el LED tras la pulsación y cambiar el brillo mientras el botón esté pulsado. const int LED = 9; // the pin for the LED const int BUTTON = 7; // input pin of the pushbutton int val = 0; // stores the state of the input pin int old_val = 0; // stores the previous value of "val" int state = 0; // 0 = LED off while 1 = LED on int brightness = 128; // almacena el valor de la intensidad unsigned long startTime = 0; // when did we begin pressing? void setup() { pinMode(LED, OUTPUT); // el LED es una salida pinMode(BUTTON, INPUT); // y el botón una entrada }

Montar el circuito correspondiente y ejecutar el siguiente sketch

Vamos a juntar ahora el circuito que acabamos de hacer con el del botón: la idea es que según el tiempo que apretemos el botón, la luz sea más o menos intensa.

void loop() { val = digitalRead(BUTTON); // lee el valor de entrada y lo guarda // comprobamos si ha habido una transición if ((val == HIGH) && (old_val == LOW)) { state = 1 - state; // cambiar el estado de apagado a // encendido o vice-versa startTime = millis(); // millis() es el reloj de Arduino //devuelve las milésimas de seg. transcurridas desde que //se restableció la placa delay(10); } // comprobamos si el botón se ha mantenido pulsado if ((val == HIGH) && (old_val == HIGH)) { // If the button is held for more than 500 ms. if (state == 1 && (millis() - startTime) > 500) { brightness++; // increment brightness by 1 delay(10); // retardo para evitar que el brillo pase demasiado deprisa if (brightness > 255) { // 255 is the max brightness brightness = 0; // if we go over 255 let’s go back to 0

continuación

} } } old_val = val; // val es ahora antiguo y lo almacenamos if (state == 1) { analogWrite(LED, brightness); // encender el LED al nivel actual de brillo } else { analogWrite(LED, 0); // turn LED OFF } }

Esto funciona! Si pulsamos y soltamos, el LED se enciende y apaga. Si lo mantenemos pulsado, el brillo cambia hasta que lo soltemos.

fin

• Montamos una nueva versión del circuito del botón y el LED.

• Cambiamos el botón por una fotorresistencia o LDR (resistencia dependiente de la luz).

Si tapamos la LDR con las manos, el LED se apaga y si las quitamos, el LED se enciende de nuevo.

Este tipo de sensores nos pueden decir no sólo si hay o

no luz, sino, además y muy importante, la cantidad de luz que hay.

Entradas analógicas: un sensor electrónico en lugar del botón

montamos el circuito de la figura (o uno mejorado), y ejecutamos el siguiente código:

En la placa de montajes colocamos el fotorresistor y una resistencia de 10 k Ω

// LED que parpadea a la velocidad especificada por el valor de la entrada analógica const int LED = 13; // el pin del LED int val = 0; // variable usada para almacenar el valor //que proviene del sensor void setup() { pinMode(LED, OUTPUT); // LED es una salida } void loop() { val = analogRead(0); // leer el valor del sensor

digitalWrite(LED, HIGH); // encender el LED

delay(val); // detener el programa durante un tiempo digitalWrite(LED, LOW); // apagar el LED delay(val); }

// Establecer el brillo del LED según el valor de una entrada analógica const int LED = 9; // the pin for the LED int val = 0; // variable used to store the value coming from the sensor void setup() { pinMode(LED, OUTPUT); // LED is as an OUTPUT } void loop() { val = analogRead(0); // read the value from the sensor analogWrite(LED, val/4); // encender el LED con el brillo obtenido del sensor delay(10); // stop the program for some time }

Ahora, vamos a juntar el sensor (LDR) y el actuador (LED) en un mismo circuito.

• Modificamos el circuito. • Cargamos y ejecutamos el siguiente sketch.

MEDIDOR DE TEMPERATURA

• MATERIAL NECESARIO - 3 LED’s rojos - 1 sensor de temperatura TMP36 - 3 resistencias de 220 Ω - Cables, placa de montajes -1 placa Arduino

• A destacar - entrada analógica - uso del monitor serie

• Descripción del proyecto Vamos a usar un sensor de temperatura (datos analógicos) para medir nuestra temperatura. El voltaje de salida es directamente proporcional a la temperatura en grados centígrados.

(amorímetro)

MEDIDOR DE TEMPERATURA

la pata corta del LED, cátodo, a tierra a través de la resistencia

patilla izquierda a la corriente y derecha a tierra; la central a A0

corriente y toma de tierra

La conexión USB se puede utilizar para mandar datos al equipo o recibirlos desde el ordenador. Después de cargar el sketch, hacer clic en el icono del monitor serie (arriba, derecha). Hay que especificar la velocidad de la comunicación: 9600 bps.

// medidor de temperatura // nombramos al pin donde está conectado el sensor const int sensorPin = A0; // room temperature in Celcius (la medimos o estimamos) const float baselineTemp = 20.0; void setup() { // abrimos el puerto serie para ver los datos en pantalla Serial.begin(9600); // declaramos los LED’s como salidas y los apagamos for (int pinNumber = 2; pinNumber < 5; pinNumber++) { pinMode(pinNumber, OUTPUT); digitalWrite(pinNumber, LOW); } }

MEDIDOR DE TEMPERATURA

void loop() { // leer el valor en el pin A0 y almacenarlo en una variable local // el valor está entre 0 y 1023 int sensorVal = analogRead(sensorPin); Serial.print(“lectura del sensor: "); Serial.print(sensorVal); // convert the ADC reading to voltage float voltaje = (sensorVal / 1024.0) * 5.0; // Send the voltage level out the Serial port Serial.print(", Volts: "); Serial.print(voltaje); // convert the voltage to temperature in degrees C // tenemos en cuenta las especificaciones // del sensor (10mV equivale a 1 ºC) Serial.print(", grados (C): "); float temperature = (voltaje - .5) * 100; Serial.println(temperature);

MEDIDOR DE TEMPERATURA

// if the current temperature is lower than the baseline // turn off all LEDs if (temperature < baselineTemp) { digitalWrite(2, LOW); digitalWrite(3, LOW); digitalWrite(4, LOW); } // if the temperature rises 2-4 degrees, turn an LED on else if (temperature >= baselineTemp + 2 && temperature < baselineTemp + 4) { digitalWrite(2, HIGH); digitalWrite(3, LOW); digitalWrite(4, LOW); } // if the temperature rises 4-6 degrees, turn a second LED on else if (temperature >= baselineTemp + 4 && temperature < baselineTemp + 6) { digitalWrite(2, HIGH); digitalWrite(3, HIGH); digitalWrite(4, LOW); } // if the temperature rises more than 6 degrees, turn all LEDs on else if (temperature >= baselineTemp + 6) { digitalWrite(2, HIGH); digitalWrite(3, HIGH); digitalWrite(4, HIGH); } delay(50); }

MEDIDOR DE TEMPERATURA

LÁMPARA DE VARIOS COLORES

• MATERIAL NECESARIO - 1 LED rgb - 3 fotocélulas o fotorresistores - 3 resistencias de 10 kΩ - 3 resistencias de 220 Ω - Cables, placa de montajes -1 placa Arduino

• A destacar - Salidas analógicas - Mapear (cambiar de escala) valores

• Descripción del proyecto Vamos a hacer una lámpara que cambia de color en función de las condiciones externas

LÁMPARA DE VARIOS COLORES

La terminal más larga es el cátodo

Rojo A0 Verde A1 Azul A2

LÁMPARA DE VARIOS COLORES

// Lámpara multicolor const int greenLEDPin = 9; // LED connected to digital pin 9 const int redLEDPin = 10; // LED connected to digital pin 10 const int blueLEDPin = 11; // LED connected to digital pin 11 const int redSensorPin = A0; // pin with the photoresistor with the red gel const int greenSensorPin = A1; // pin with the photoresistor with the green gel const int blueSensorPin = A2; // pin with the photoresistor with the blue gel int redValue = 0; // valores iniciales int greenValue = 0; int blueValue = 0; int redSensorValue = 0; int greenSensorValue = 0; int blueSensorValue = 0;

void setup() { // inicializamos la comunicación serie Serial.begin(9600); // set the digital pins as outputs pinMode(greenLEDPin, OUTPUT); pinMode(redLEDPin, OUTPUT); pinMode(blueLEDPin, OUTPUT); }

void loop() { // leer los valores de los sensores y almacenarlos en las variables correspondientes redSensorValue = analogRead(redSensorPin); delay(25); // esperar a que el ADC termine greenSensorValue = analogRead(greenSensorPin); delay(25); blueSensorValue = analogRead(blueSensorPin); // escribir los valores en el monitor serie tabulados Serial.print("raw sensor Values \t red: "); Serial.print(redSensorValue); Serial.print("\t green: "); Serial.print(greenSensorValue); Serial.print("\t blue: "); Serial.println(blueSensorValue);

LÁMPARA DE VARIOS COLORES

/* El ADC proporciona un valor entre 0 y 1023 (10 bits) pero analogWrite() usa 8 bits, valores entre 0 y 255. Por lo tanto, dividimos la lectura del sensor entre 4. */ redValue = redSensorValue / 4; greenValue = greenSensorValue / 4; blueValue = blueSensorValue / 4; // print out the mapped values Serial.print(“valores sensores corregidos \t red: "); Serial.print(redValue); Serial.print("\t green: "); Serial.print(greenValue); Serial.print("\t Blue: "); Serial.println(blueValue); // ajustamos los niveles de luz del LED analogWrite(redLEDPin, redValue); analogWrite(greenLEDPin, greenValue); analogWrite(blueLEDPin, blueValue); }

LÁMPARA DE VARIOS COLORES