Felix Maocho

Para quien le interese lo que a nosotros nos interesa

3º Ejercicio de uso de pines digitales de entrada INPUT– Temporizador luminoso

reloj-automatico-escalera-l-kgsxmvPor Félix Maocho
18/11/2016

,

Objetivo

Construir un aparato que regule la duracion de encendido de las luces de una escalera.

Conocimientos que se precisan

Para realizar este ejercicio tal como aquí se resuelve solo se necesitan los conocimientos que se han ido explicando hasta el capítulo dedicado al Uso de los pines digitales como entrada (IN PUT), que podemos resumir en los siguientes puntos:

  • Saber escribir, “subir” a la Tarjeta Arduino un sketch o programa
  • Conocer las funciones “int”, “pinMode”, “digitalWrite”, e “if”
  • Enunciado del problema

Enuciado 

Para un descansillo de una escalera se desea que cuando se pulse el botón la luz se mantenga encendida un minuto, apagándose a continuación.

Material necesario

  • Tarjeta Arduino y cable de conexiones
  • Tarjeta de prototipado o “protoboard”
  • 8 Cables de conexiones macho/macho (preferiblemente 3 rojos a 5V, 3 azules uno verde y otro amarillo)
  • 1 Resistencia1 de 220 Ω
  • 2 Led
  • 2 pulsadores o Push button

Objetivos

  1. Ejercitarse en el uso de los pines digitales de entrada o INPUT
  2. Ejecutarse en el uso las funciones “if”
  3. Aprender a detectar los problemas que puede dar el uso dela ·función “delay”
  4. Especificaciones

Se supone que hay una escalera que une dos plantas iluminada con leds en cada rellano que normalmente se mantienen apagados, cuando alguien pulsa uno de los botones que hay en cada planta, se encienden los led que iluminan la escalera por un tiempo, apagándose a continuación.

Tenemos que crear dos circuitos digitales. Uno alimentado desde un pin digital alimenta dos luces, que se suponen que están en pisos diferentes. Otro es el que detecta cuando un botón se ha oprimido. Caben dos soluciones poner los botones con montajes PULL DOWN o montaje PULL UP

1º Ejercicio Solución con un montaje PULL DOWN

Hardware

Utilizaremos los buses rojo y azul de uno de los lados. para alimentar las luces. por tanto el rojo se unirá a un pin digital en OUPUT, el bus azul a un pin de tierra (GRD) , y el otro par de buses los utilizaremos para llevar la la energía a una de las patas del de los pulsadores. mientras que de la otra pata es la que llegaremos a tierra.

Utilizaremos para los pulsadores un montaje PULL DOWN, (tirar abajo. o derribar), quiere decir que donde extraemos el cable que irá al pin a digital abierto como INPUT. el voltaje está habitualmente a 0 voltios, y al apretar el pulsador pasa a 5V. En un montaje de este tipo , el orden de los elementos que interviene en el circuito PULL DOWN es el siguiente:

  • Fuente de corriente eléctrica a 5V
  • Pulsador
  • Segmento de cable que acaba en el Pin que hará la lectura del voltaje
  • Resistencia del circuito
  • Tierra

El esquema de las conexiones sera así:

arduino-63-luces-de-la-escalera_bb

Descripción general

En la parte superior el pin 12 y el pin GRD están conectados con los buses superiores que alimentan a dos Led montados en batería, a los que como es costumbre se une en serie una resistencia de 220Ω. Estos Led solo lucirán cuando el sketch de salida electricidad por el pin 12.

En la parte inferior, los pines 5V y GRD están conectados a los dos buses inferiores. El bus rojo alimenta a cada una de las patas del pulsador, (push button). mientras que otra pata se une a una resistencia que va a ser común para todos los pulsadores y que tendrá un valor más elevado de lo habitual, pues su objetivo no es solo evitar un cortocircuito. sino que deje pasar una mínima cantidad de energía, porque no tiene sentido el que pase más, si su objetivo es solo permitir que un segmento que va desde el pulsador a la resistencia, cambie cuando se oprime el pulsador, de estar a 0V, (por estar unido a tierra, a estar a 5V por quedar unido la carga. Pondremos por ello una resistencia de 1000Ω, suficientemente grande para evitar por si misma que se produzcan cortocircuitos al unir el pin 5V al pin GRD sin ningún componente que consuma la energía que sale por 5V

Observe que los componentes quedan en la configuración típica del PULL DOWN, entrada de 5v, pulsador, cable que va a el in en INPUT, resistencia, salida a 0v,

De acuerdo con la codificación que se utiliza para las resistencias, la resistencia de 1000Ω lucirá las siguientes bandas de color, marrón , negro, rojo. Para saber de cuantos homios, (Ω) tiene una resistencia, hay que conocer el código de colores con el que se marcan. Los códigos de colores son como siguen:

1000-honiosColocando la banda mas separada a la derecha, las lineas del del lado izquierdo que son tres o cuatro, indican los homios de acuerdo el código de colores y la última por la derecha de la serie es el número de ceros que siguen. En nuestro caso

  • Marrón =1 para el primer digito
  • Negro = 0 para el segundo digito
  • Rojo = 100 para el multiplicador

Por último un cable verde une el segmento que cambia de voltaje según se oprime el pulsador, con el pin 2, que abriremos de INPUT.

Software

El temporizador funcionará de la siguiente forma, si se aprieta cualquiera de los pulsadores, lo detectará el Pin2 y entonces durante un cierto tiempo se mandará salir energía por el pin 13, Pasado ese tiempo se vuelve a apagar los leds. Por tanto el sketch hará lo siguiente:

* Comprobar el voltaje de pin 2 y dejar el resultado en la variable “corriente”
* Si (corriente = 1) // (han oprimido un pulsador)
* Encender las luces durante un tiempo
* Repetir el ciclo

Y el sketch que manejaba el harreare será como sigue

/* Sketch E6.31 Temporizador luminoso (Montaje PULL DOWN)
* 1º Comprobar el voltaje de pin 2 y dejar en la variable “corriente”
* 2º Si (corriente = 1) // (han oprimido un pulsador)
* 2.1 Encender las luces durante un tiempo
* 2.2 apagar las luces
* 3º Repetir el ciclo
*/

// Área de definición de variables y parámetros
int pinout = 12; // pin que se abre en OUTPUT
int pininp = 2; // pin que se abre en INPUT
int corriente = 0; // Si hay 5V toma el valor 1 , si hay 0V, 0
int tiempo = 20000; // mantenemos encendidos los led 20 segundos

// Función setup
void setup() {
pinMode(pinout, OUTPUT); // Pin abierto como OUTPUT enciende led
pinMode(pininp, INPUT); // Pin abierto como INPUT, lee el voltaje
}

// Función loop
void loop() {
delay(100)  //  Tiempo de retardo para evitar los “rebotes” del pulsador
corriente = digitalRead(pininp); // 1º comprobar el voltaje
if (corriente == 1) { // 2º (han oprimido un pulsador)
digitalWrite(pinout, HIGH); // 2.1 Encender las luces durante un tiempo
delay (tiempo); // mantenerla encendida tiempo
digitalWrite(pinout, LOW); // 2.2 apagar las luces
} // Cierre del “if” encendida
} // cierre de la función loop 3º Repetir el ciclo

Este prototipo se pueden fácilmente escalar a tantos pisos como e queramos, tanto en lo referente a los los led, como al número de interruptores, sin mas limitación que las caídas de tensión que se produzcan por la longitud de los cables y teniendo en cuenta que el pin 12 sólo suministra 40 miliamperios, lo que no da a energía para encender muchos leds aun eliminando las resistencias. Primoroso repartir mas leds utilizando mas pines de salida puesto que cada uno proporciona la misma intensidad de corriente, hasta llegar al máximo de energía que puede suministrar una tarjeta Arduino. A partir de ahí habría que buscar medios indirectos como un relé para alimentar las luces.

Tiempo de retardo

Con el fin de evitar los problemas de la fluctuación del voltaje cuando se corta o da la corriente, introducimos preventivamente mediante un “delay” un tiempo de retardo de 100 milsegundos.

Indentar un sketch

Cuando se escribe un sketch, lo habitual es indentar o poner un poco mas a la derecha todas los mandatos que entran entre los caracteres “{” y “}” correspondientes a función, como la función “loop”, o algunos mandatos, (come en nuestro caso los mandatos “if” y “else”). La razón para ello es poder identificar de un vistazo, el comienzo y final de estos mandatos y saber cuales mandatos están condicionados por ellos.. Gráficamente se puede ver de un solo vistazo donde acaba y termina el párrafo controlado por los caracteres “{” y “}”.

Desgraciadamente, el editor de Word Press, que utilizo para redactar este post, llena de caracteres ocultos el indentado, o lo que afloraría en el momento que se lleve con copy/paste el software del ejercicio propuesto a su editor IDE. Por ello he renunciado a hacer este indentado en estos post. Pero animo a introducir los indentados en su editor de los sketch de Arduino, por la claridad que dan a los Sketch, que compensan largamente el trabajo de introducirlos.

Lo que si le puedo poner es una imagen de como que da el programa correctamente editado en el entorno IDE de Arduino:

sketch63-luces-de-escalera-2

Un pequeño problema de este programa

Observe lo que ocurre si no se ha apretado ningún botón, el “loop”, no hace nada mas que comprobar el voltaje. Por tanto pasará el “loop” muy rápidamente una y otra vez y obtendremos una serie de consultas seguidas del voltaje en el pin 2 que no tiene mucho sentido,

2ª Ejercicio Solución con un montaje PULL UP

Repetimos el ejercicio pero haciendo ahora un omtaje PULL UP de los botones

Hardware

Solo a modo de ejemplo, voy a resolver el ejemplo inicial, pero en este caso con un montaje PULL UP. Observarán que la tarjeta funciona en todo exactamente igual, la única diferencia, es que donde antes hacia repetidamente una lectura de un voltaje, que habitualmente esta bajo, (0V), ahora hace la lectura repetida de un voltaje que habitualmente está alto (5V), con todo lo que supone de mayor carga para la tarjeta. Esto no pone en peligro la tarjeta, pero naturalmente no la favorece. Por tanto, si es absolutamente igual hacerlo de una forma o de otra, porque no se tienen ventajas especiales hacerlo de cualquiera de las dos formas, deberemos en principio preferir la solución PULL DOWN.

Este es el caso, el montaje PULL DOWN no tiene ninguna ventaja, porque no tratamos de controlar las posibles caídas de tensión, (en este caso si se “va la luz” ni funcionarán los timbres ni se pueden encender las luces, porque todo se alimentan del mismo punto), por ello es menos adecuado aunque se puede realizar sin riesgo de estropear la tarjeta, aunque si la sometemos a mayor desgaste

Como dijimos en el post, Uso de los pines digitales como entrada (INPUT), el montaje PULL UP se caracteriza porque los elementos que participan en el montaje se colocan en el orden inverso al PULLDOWN

  • Fuente de corriente eléctrica a 5V
  • Resistencia del circuito
  • Segmento de cable que acaba en el Pin que hará la lectura del voltaje
  • Pulsador
  • Tierra

arduino-633-luces-de-la-escalera_bb

Si se lijan es exactamente igual que la solución anterior pero cambiando el enlace de los buses, poniendo el bus rojo a tierra y el azul a 5V, nosotros hemos preferido cambiar las conexiones de los pulsadores y la resistencia grande. Observen con detalle las diferencias en el diagrama de conexiones.

Como ven solamente hemos hecho tres cambio mínimos. El primero es que la resistencia esta conectada directamente al bus rojo que porta 5V.; los otros cambios es que los pulsadores se unen ahora por una pata al bus azul por lo que por esa parata están directamente unidos a tierra.

Como consecuencia, mientras no este cerrado el circuito, los cables conectados a la otra pata de la resistencia y al pulsador estarán habitualmente a 5V, pero tan pronto como se cierre el circuito, se pondrán a 0V, por quedar directamente unidos a tierra (GRD) y eso, es lo que detectará el cable verde, que va a parar al pin 2, que cada vez que se aprieta el botón el voltaje del cable pasa de 5V a OV

Software

El software sera exactamente lo mismo. solo que aquí lo que detecta que se ha apretado el pulsador es que la variable “corriente” toma el valor cero, al hacer la lectura del voltaje. ESTE ES EL UNICO CAMBIO, como resalto en el Sketch que queda así :

/* Sketch E6.32 Temporizador luminoso (Montaje Pull UP)
* 1º Comprobar el voltaje de pin 2 y dejar en la variable “corriente”
* 2º Si (corriente = 1) // (han oprimido un pulsador)
* 2.1 Encender las luces durante un tiempo
* 2.2 apagar las luces
* 3º Repetir el ciclo
*/

// Área de definición de variables y parámetros
int pinout = 12; // pin que se abre en OUTPUT
int pininp = 2; // pin que se abre en INPUT
int corriente = 1; // Si hay luz toma el valor 1 , si hay apagado 0
int tiempo = 10000; // las mantenemos encendidas 10 segundos

// Función setup
void setup() {
pinMode(pinout, OUTPUT); // Pin abierto como OUTPUT enciende led
pinMode(pininp, INPUT); // Pin abierto como INPUT, lee el voltaje
}

// Función loop
void loop() {
delay(100)  //  Tiempo de retardo para evitar los “rebotes” del pulsador
corriente = digitalRead(pininp); // 1º comprobar el voltaje
// ******* ESTE ES EL ÜNICO CAMBIO UN 0 POR UN ! *******
if (corriente == 0) { // 2º (han oprimido un pulsador)
// ********************************************************
digitalWrite(pinout, HIGH); // 2.1 Encender las luces durante un tiempo
delay (tiempo ); // mantenerla encendida tiempo
digitalWrite(pinout, LOW); // 2.2 apagar las luces
} // Cierre del “if” encendida
} // cierre de la función loop 3º Repetir el ciclo

sketch63-luces-de-escalera-22

Por supuesto este sketch padece de los mismos defectos que el anterior una repetida e innecesaria consulta del voltaje en el caso de que nadie apriete el botón aquí agravado puesto que lo va a leer continuamente es que está a 5V

El peligro del “delay”

Podíamos tomar alguna medida para evitar tal número de lecturas inútiles como puede ser frenar la velocidad de ejecución del “loop” poniendo por ejemplo al principio un “delay” que haga que por fuerza tarde más el tiempo necesario en hacer el “loop”. Sin embargo el “delay” es un arma de dos filos, porque mientras se ejecuta el “delay” la ejecución del programa no avanza, el programa aparece como “anestesiado”.

Por tanto, si cuando está ejecutando un “delay”· alguien aprietan y un botón y lo suelta antes de que finalice, la máquina no se enterará de que han apretado el botón, porque para cuando vaya a leer el voltaje, este se habrá puesto nuevamente a cero.

Cuando se utilice un “delay” hay que tener en cuenta que la “parada” del programa en ese punto no suponga problemas. Por ejemplo, en este programa, si el vecino del primero aprieta el botón 1 y enciende las luces de la escalara, mientras estén encendidas, no vale para nada apretar el botón 2 porque el sistema no se entera.

En este caso concreto esto no importa, porque el vecino del segundo piso, que salga cuando aun está encendida la luz, o da al botón y no vale para nada, o no da al botón y aprovecha la luz encendida por el anterior. Lo que pasará, es que en este caso, el tiempo que se encuentre encendida la luz el vecino del segundo es variable, del máximo, si sale inmediatamente que se encendió la luz, o solo unos segundos si ya casi han pasado el tiempo de encendido previsto. En este caso sólo tendrá que dar la luz cuando esta se apague, (si lo hace antes no valdrá para nada) y se volverá a encender la luz, Esto es exactamente lo que ocurre en la mayoría de las escaleras y la gente no protesta. .

Un ejemplo de error provocado por el “delay”

Supongamos que por esas normas que se van imponiendo de ahorro de luz, el sistema de luces de la escalera que tenemos enciende solo la luz del descansillo donde está el botón oprimido. Es decir que vemos independizado el sistema de modo que el botón 1 1no sólo enciende la luz 1 y el botón 2 solo enciende el la luz 2.

En este caso tendríamos que buscar otra solución, pues imaginemos que sale el vecino del primero y enciende el botón 1, la luz 1 se enciende por el tiempo marcado, pero no así la luz 2. Ahora sale el vecino del segundo, encuentra la luz apagada y aprieta el botón 2, pero la luz 2 no se enciende porque el programa esta “anestesiado” en un “delay” durante un ·tiempo.

Esto no es aceptable. Y hay que buscar una solución: Para que observen los riesgos del “delay” les dejo tanto el esquema de conexiones como un programa que funciona (mal) como indicamos, para que comprueben la veracidad de lo que digo y busquen una solución.

3º Ejercicio Leds independientes en cada piso

Solución errónea

Cambiamos las especificaciones por la de encender independiente mente los led en d función del botón que lo solicita.

Con las medidas de ahorro energético actuales, es corriente que al pulsar el botón de la luz de la escalera se enciendan únicamente las luces de ese descansillo y no la totalidad de las luces de la escalera. El sistema exige que identifiquemos cual ha sido el botón pulsado y en función de él encender las luces que corresponda.

Para ello podremos identificar qué botón se ha pulsado y encender sólo la luz correspondiente. Haciendo que cada pulsador se controle por diferente pin. De esa forma podríamos identificar individualmente los pulsadores y mandar encender l en cada caso las luces correspondientes.

Muestro a continuación, una posible solución a como hacerlo. Nuevamente hemos realizado un montaje tipo PULL DOWN por ser el más lógico en este caso, pero igualmente podríamos haber optado por un PULL UP.

Nuevamente recordamos que el montaje PULL DOWN se caracteriza porque el orden de los elementos que forman el circuito pulsador son :

  • Fuente de corriente eléctrica a 5V
  • Pulsador
  • Segmento de cable que acaba en el Pin que hará la lectura del voltaje
  • Resistencia del circuito
  • Tierra

Mientras que en el montaje PULL UP , los componentes están situados al contrario o sea:

  • Fuente de corriente eléctrica a 5V
  • Resistencia del circuito
  • Segmento de cable que acaba en el Pin que hará la lectura del voltaje
  • Pulsador
  • Tierra

Como pueden observar en el este caso hemos optado por el montaje PULL DOWN para cada uno de los dos pulsadores pero hubiéramos podido optar por el montaje contrario en uno o los dos pulsadores. Lo importante es que recordemos que si optamos por un montaje PULL DOWN lo que leerá la Tarjeta Arduino habitualmente es 0 voltios y sólo cuando este oprimir do el pulsador pasar a a 5 voltios, por tanto el que la variable que recoge la lectura del voltaje, (en nuestro caso “corriente” adquiera el valor “1” es señal que han pulsado el botón. Si el montaje fuese PULL UP sería al revés. Igualmente se han independizado los circuitos, tanto para alimentar a los led ahora cada uno depende de unpin digital en OUPUT.

arduino-632-luces-de-la-escalera_bb.
Descripción

Como se ve, en este caso se ha independizado la alimentación de los leds, hecha actualmente desde los pin 12 y 13 como los circuitos de cada “push button” con lo que damos la oportunidad de comprobar por separado el estado de cada botón y en función de ello encender las luces correspondientes. El botón de la izquierda encenderá el pin 13 y el de la derecha el 13

Software

Podríamos en principio pensar que basta ver el estado de cada pulsador y encender o no las luces correspondientes. Por tanto en principio valdría un sketch como el que indico:

/* Sketch E6.33 Temporizador luminoso con luces independientes
* 1º Comprobar el voltaje de pin 2 y dejar en la variable “corriente”
* 2º Si (corriente1 = 1) // (han oprimido un pulsador1)
* 2.1 Encender las luz1 durante un tiempo
* 2.2 apagar la luz1
* 3º Comprobar el voltaje de pin 2 y dejar en la variable “corriente”
* 4º Si (corriente2 = 1) // (han oprimido un pulsador1)
* 4.1 Encender las luz1 durante un tiempo
* 4.2 apagar la luz2
* 5º Repetir el ciclo
*/

// Área de definición de variables y parámetros
int pinout1 = 13; // pin en OUTPUT para luz1
int pinout2 = 12; // pin en OUTPUT para luz2
int pininp1 = 2; // pin en INPUT para pulsador1
int pininp2 = 3; // pin en INPUT para pulsador2
int corriente1 = 0; // luz valor 1 , apagado 0
int corriente2 = 0; // luz valor 1 , apagado 0
int tiempo = 20000; // l20 segundos

// Función setup
void setup() {
pinMode(pinout1, OUTPUT); // enciende led1
pinMode(pinout2, OUTPUT); // enciende led2
pinMode(pininp1, INPUT); // botón1
pinMode(pininp2, INPUT); // botón2
}

// Función loop
void loop() {
delay(100)  //  Tiempo de retardo para evitar los “rebotes” del pulsador
corriente1 = digitalRead(pininp1); // 1º comprobar boton1
if (corriente1 == 1) { // 2º oprimido un pulsador1
digitalWrite(pinout1, HIGH); // 2.1 luz1
delay (tiempo ); // mantenerla encendida
digitalWrite(pinout1, LOW); // 2.2 apagar luz1
} // Cierre del “if” encendida1
delay(100)  //  Tiempo de retardo para evitar los “rebotes” del pulsador
corriente2 = digitalRead(pininp2); // 3º comprobar boton2
if (corriente2 == 1) { // 4º oprimido un pulsador21
digitalWrite(pinout2, HIGH); // 4.1 luz2
dlay (tiempo ); // mantenerla encendida
digitalWrite(pinout2, LOW); // 2.2 apagar luz2
} // Cierre del “if” encendida2
} // cierre de la función loop 5º Repetir el ciclo

Aparentemente este programa tiene que funcionar bien, pues no es mas que duplicar sketch 6.31 de antes, que funcionaba perfectamente. Solo que hay una diferencia muy sutil que quizá no se han dado cuenta. Antes se encendían TODAS las luces y nadie va a dar a un botón mientras las luces estén encendidas, el mayor problema que podíamos tener, es que mientras están encendidas TODAS las luces alguien salga en otro piso y de pronto TODAS las luces se apagan y hasta que nuevamente se aprieta un botón. Ocurre que si se aprieta un SEGUNDO botón mientras están encendidas TODAS las luces, es sistema no se entera y las luces se apagan pasados los segundos determinados desde que se encendió la PRIMERA luz, pero esto pasa desapercibido.

Sin embargo ahora cuando se pulsa un botón se enciende UNA luz, la que corresponde a ese piso. Si en otro piso sale alguien, su luz estará apagada, pero cuando apriete el botón es sistema no se entera, porque esta “anestesiado” en un largo “delay”, y por tanto DEJA A OSCURAS al la segunda petición de encender la luz, lo cual es inadmisible.

Haga la prueba, compile este sketch monta los componentes y pruebe a encender el segundo led cuando está luciendo el primer led o viceversa. ¿Que podemos jacer?

Desde luego hay solución y la veremos en otros ejemplos pero este ejemplo se va haciendo muy largo así que la solución la daré en otro sitio, Sólo quiero que piensen en el problema y busquen soluciones al mismo.

Puntuación

Como de costumbre procedo a puntuar este software. No me cansaré de repetir que una misma forma de actuar de la tarjeta Arduino se puede conseguir de muchas formas y que de todas ellas la mejor y por tanto la que yo le concedo la más alta puntuación, es aquella que es mas sencilla, mas corta y precisa de menos medios.

A mi modo de ver el primer sketch es de buena calidad, pero tiene los dos defectos indicados, lecturas innecesarias y un delay que hace que el programa no tenga un funcionamiento perfecto que consistiría en detectar las pulsaciones y mantener las luces encendidas un rato desde la ÚLTIMA pulsación

Si hay alguien que pueda soslayar ambos defectos con pocas lineas mas de programa, habrá conseguido mejorarlo. Dando vueltas quizá se me ocurriera a mi alguna basada en conseguir llevar algún tipo de contador que se ponga a cero cada vez que se pulsa un botón o algo parecido

Reseco de las lecturas sucesivas, se fácil distanciarlas algo, pero al fin y al cabo la única forma de saber si han apretado el botón es leer el estado de el pin en INPUT, por tanto nos pongamos como nos pongamos tendremos que hacer muchas lecturas, con nuestros actuales conocimientos . (les anticipo que hay mejor solución como es el uso de interrupciones, pero aun no hemos llegado a esa clase)

Pruebas del aparato

Cargado cualquiera de los sketch en la tarjeta, si no funciona el prototipo es que tiene algún error en el montaje de los cables o componentes o ha conectado a algún pin erróneo, pues el software le he probado y funciona a la perfección.

Cuando todo funcione haga las siguientes pruebas:

En el primer ejercicio

Oprima uno de los botones, espere 10 seg. Y oprima el segundo, vera que las luces se apagan a los 10 segundos o sea pasados los 20 segundos del primero.

El segundo ejercicio es igual que el primero salvo que el montaje es PULL UP

En el tercer ejercicio puede observar los problemas del “delay” apite consecutivamente los dos botones, solamente se encenderá el led correspondiente al primer pulsador.

Prácticas

Buscar solución al caso planteado en el tercer ejercicio. La hay a la altura de sus conocimientos, solo es cuestión de cometer errores y seguir probando (la única forma de aprender es pegarse con los ejercicios)

Repaso

Como repaso final te diré lo que has aprendido hoy

  • Ejercitarte en el uso de los pin digitales
  • Leer si el voltaje está alto o bajo en un punto
  • Manta PULL DOWN y PULL UP
  • Problemas que puede producir el mandato “delay” y como solucionarlo
  • Manejo de pin digital como INPUT
  • Uso de la función “if”
  • Símbolo de igualdad y asignación

Félix Maocho

indice

 | , , , | Editar

18 noviembre 2016 - Posted by | Curso de Arduino, Robotica | , , ,

Aún no hay comentarios.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: