{"id":1078,"date":"2023-01-07T11:39:08","date_gmt":"2023-01-07T10:39:08","guid":{"rendered":"https:\/\/www.e-ika.com\/blog\/?p=1078"},"modified":"2023-06-26T18:55:50","modified_gmt":"2023-06-26T17:55:50","slug":"kit-arduino-uno-r3","status":"publish","type":"post","link":"https:\/\/www.turibot.es\/blog\/index.php\/2023\/01\/07\/kit-arduino-uno-r3\/","title":{"rendered":"Kit Arduino UNO R3"},"content":{"rendered":"\n
\"\"<\/figure>
\n

Para empezar a trabajar con la plataforma Arduino, debemos tener instalado el IDE de Arduino en nuestro ordenador. Este proceso podemos verlo con detalle en la p\u00e1gina 15 del Libro de Proyectos de Arduino<\/strong><\/a>.<\/p>\n\n\n\n

Si estamos usando una placa de Arduino compatible necesitamos instalar el driver del chip CH340. Podemos descargarlo aqu\u00ed<\/strong><\/a>.<\/p>\n<\/div><\/div>\n\n\n\n

Una vez tenemos instalado el IDE, podemos ponernos manos a la obra y empezar a conocer el fant\u00e1stico mundo Arduino.<\/p>\n\n\n\n

Contenido<\/p>

<\/polyline><\/svg><\/div>
  1. El UNO y la Protoboard<\/a>
    1. Arduino UNO<\/a>
        <\/ol><\/li>
      1. La Protoboard<\/a>
          <\/ol><\/li><\/ol><\/li>
        1. Encender un led<\/a>
            <\/ol><\/li>
          1. Brillo<\/a>
              <\/ol><\/li>
            1. Sem\u00e1foro<\/a>
                <\/ol><\/li>
              1. Pulsador<\/a>
                  <\/ol><\/li>
                1. LDR<\/a>
                    <\/ol><\/li><\/ol><\/div>\n\n\n\n
                    \n\n\n\n

                    El UNO y la Protoboard<\/h2>\n\n\n\n

                    Arduino UNO<\/h3>\n\n\n\n

                    La placa de Arduino UNO va a ser el cerebro de nuestros proyectos. Nos va a proporcionar la l\u00f3gica necesaria para hacerlos funcionar. En s\u00ed misma no hace nada, pero con un poquito de programaci\u00f3n conseguiremos hacer maravillas.<\/p>\n\n\n\n

                    Aqu\u00ed vemos las partes de la placa que nos interesa conocer.<\/p>\n\n\n\n

                    \"\"<\/figure><\/div>\n\n\n\n

                    Conector USB.<\/strong> Nos permite conectar la placa a nuestro ordenador con un cable est\u00e1ndar USB A\/B. Se usa para programar y alimentar la placa.<\/p>\n\n\n\n

                    Jack de alimentaci\u00f3n.<\/strong> Podemos usar este conector para alimentar nuestro Arduino cuando no est\u00e1 conectado al ordenador. Acepta tensiones de entre 7 y 12V. Es frecuente usarlo con una pila de 9V o un alimentador.<\/p>\n\n\n\n

                    Pines digitales<\/strong>. Estos pines proporcionan entradas y salidas digitales. Permiten enviar se\u00f1ales para activar motores, rel\u00e9s, leds, etc. O bien recibir se\u00f1ales digitales de sensores (temperatura, sonido, luminosidad, etc.)<\/p>\n\n\n\n

                    Pines anal\u00f3gicos.<\/strong> Reciben se\u00f1ales anal\u00f3gicas.<\/p>\n\n\n\n

                    Pines de alimentaci\u00f3n.<\/strong> Podemos usar estos pines para alimentar dispositivos externos como motores, sensores u otros circuitos.<\/p>\n\n\n\n

                    Toda la informaci\u00f3n sobre Arduino UNO podemos obtenerla en su p\u00e1gina oficial<\/a>.<\/p>\n\n\n\n

                    La Protoboard<\/h3>\n\n\n\n

                    Es la placa sobre la que haremos todos nuestros montajes electr\u00f3nicos. Se trata de una superficie de pl\u00e1stico en cuyas perforaciones alojaremos los distintos componentes de nuestros circuitos. <\/p>\n\n\n\n

                    \"\"<\/figure><\/div>\n\n\n\n

                    Internamente incluye ciertas conexiones entre las perforaciones que debemos conocer. <\/p>\n\n\n\n

                    \"\"<\/figure><\/div>\n\n\n\n

                    Estas conexiones internas nos permiten conectar nuestros componentes en funci\u00f3n de d\u00f3nde los coloquemos. <\/p>\n\n\n\n

                    \n\n\n\n

                    Encender un led<\/h2>\n\n\n\n

                    Este ser\u00e1 nuestro primer proyecto y empezaremos por lo m\u00e1s sencillo. Vamos a encender y apagar un led a intervalos predefinidos.<\/p>\n\n\n\n

                    El led es un componente electr\u00f3nico emisor de luz ampliamente utilizado como indicador. Se trata de un componente con polaridad, es decir, tiene un terminal positivo y otro negativo. Generalmente los leds tienen las patitas de distinta longitud, la pata corta es la negativa. Si miramos el interior del led al trasluz, el terminal m\u00e1s grande es el negativo.<\/p>\n\n\n\n

                    \"\"<\/figure><\/div>\n\n\n\n

                    Lo utilizaremos siempre junto con una resistencia conectada en serie. El valor de la resistencia depender\u00e1 de la tensi\u00f3n con la que alimentemos el led. En este caso la tensi\u00f3n es de 5V (el voltaje entregado por los pines de Arduino UNO) y la resistencia ser\u00e1 de 220\u03a9.<\/p>\n\n\n\n

                    El circuito que vamos a montar es el siguiente. Prestar especial atenci\u00f3n a la polaridad del led, la pata negativa tenemos que conectarla al pin GND de la placa de Arduino UNO y la pata positiva a la resistencia. La otra pata de la resistencia la conectamos al pin 2 de Arduino.<\/p>\n\n\n\n

                    \"\"<\/figure><\/div>\n\n\n\n

                    La imagen anterior representa el montaje m\u00e1s o menos realista. El esquema del circuito es el siguiente: <\/p>\n\n\n\n

                    \"\"<\/figure><\/div>\n\n\n\n

                    Ya tenemos el circuito montado. Ahora tenemos que hacerlo funcionar. Pasamos a la parte de programaci\u00f3n. <\/p>\n\n\n\n

                    Suponiendo que tenemos el IDE de Arduino instalado y configurado, creamos un nuevo sketch y escribimos el siguiente c\u00f3digo (podemos copiar y pegar, por supuesto). <\/p>\n\n\n

                    \n#define LED_PIN 2\n\nvoid setup() {\n  pinMode(LED_PIN, OUTPUT);\n}\n\nvoid loop() {\n  digitalWrite(LED_PIN, HIGH);\n  delay(250);\n  digitalWrite(LED_PIN, LOW);\n  delay(250);\n}\n<\/pre><\/div>\n\n\n
                    Quiz\u00e1 sea esta la parte m\u00e1s compleja de nuestro proyecto. Si tenemos la sensaci\u00f3n de no entender nada, que no cunda el p\u00e1nico, la programaci\u00f3n tiene su miga y tenemos que ir cogi\u00e9ndole el truqui. Vamos a analizar el c\u00f3digo por partes.<\/p>\n\n\n\n
                    En la primera l\u00ednea indicamos que nuestro led lo hemos conectado al pin 2 de Arduino.<\/p>\n\n\n
                    \n#define LED_PIN 2\n<\/pre><\/div>\n\n\n
                     La siguiente parte del programa es la funci\u00f3n setup() <\/p>\n\n\n
                    \nvoid setup() {\n  pinMode(LED_PIN, OUTPUT);\n}\n<\/pre><\/div>\n\n\n
                     Esta funci\u00f3n se ejecuta una \u00fanica vez cuando se enciende el circuito. Dentro de la funci\u00f3n setup() tenemos la instrucci\u00f3n <\/p>\n\n\n
                    \npinMode(LED_PIN, OUTPUT);\n<\/pre><\/div>\n\n\n
                    La funci\u00f3n pinMode<\/code> le est\u00e1 indicando a la placa de Arduino que el pin 2 (LED_PIN) debe ser tratado como un pin de salida (OUTPUT). Esto quiere decir que es la placa de Arduino la que enviar\u00e1 la se\u00f1al de encendido.<\/p>\n\n\n\n
                    Cuando el pin va a recibir una se\u00f1al, en vez de enviarla (desde un sensor, por ejemplo) usaremos la palabra INPUT.<\/p>\n\n\n\n
                    El siguiente bloque de c\u00f3digo es la funci\u00f3n loop()<\/code><\/p>\n\n\n
                    \nvoid loop() {\n  digitalWrite(LED_PIN, HIGH);\n  delay(250);\n  digitalWrite(LED_PIN, LOW);\n  delay(250);\n}\n<\/pre><\/div>\n\n\n
                    Esta funci\u00f3n se ejecuta indefinidamente, despu\u00e9s de la funci\u00f3n setup()<\/code>. El contenido de la funci\u00f3n loop()<\/code> se ejecuta una y otra vez hasta que se apaga la placa de Arduino.<\/p>\n\n\n\n
                    La primera instrucci\u00f3n dentro de la funci\u00f3n loop()<\/code> es<\/p>\n\n\n
                    \ndigitalWrite(LED_PIN, HIGH);\n<\/pre><\/div>\n\n\n
                    Esta instrucci\u00f3n enciende el led. Le est\u00e1 indicando a la placa de Arduino que el pin 2 (LED_PIN) se ponga en nivel alto (HIGH), es decir, a 5V. Esto da una tensi\u00f3n de alimentaci\u00f3n al led y lo enciende.<\/p>\n\n\n\n
                    La siguiente instrucci\u00f3n<\/p>\n\n\n
                    \ndelay(250);\n<\/pre><\/div>\n\n\n
                    indica un tiempo de espera. El programa se detendr\u00e1 durante 250 milisegundos antes de continuar.<\/p>\n\n\n\n
                    Las dos siguientes instrucciones son las mismas que las anteriores, pero esta vez apagan el led (LOW) y el programa se detiene otros 250 milisegundos.<\/p>\n\n\n\n
                    Estas instrucciones, al estar dentro de la funci\u00f3n loop()<\/code>, se repetir\u00e1n indefinidamente por lo que el led se encender\u00e1, se mantendr\u00e1 encendido el tiempo especificado, se apagar\u00e1, permanecer\u00e1 apagado durante ese tiempo y el proceso se repetir\u00e1 hasta que apaguemos el circuito.<\/p>\n\n\n\n
                    Ejecutando \u201cSubir\u201d (\u201dUpload\u201d) en el IDE de Arduino cargaremos el programa en la placa y el led deber\u00eda comenzar a parpadear a intervalos de 1\/4 de segundo.<\/p>\n\n\n\n
                    Podemos modificar el tiempo de parpadeo cambiando el n\u00famero de milisegundos de la funci\u00f3n delay<\/code>. Podemos hacer que el led est\u00e9 encendido un tiempo dado y apagado un tiempo distinto si ponemos valores distintos en las dos instrucciones delay<\/code>.<\/p>\n\n\n\n
                    Resumen<\/p>
                    Un led siempre debe ir montado en serie con una resistencia. Si la alimentaci\u00f3n es de 5V, la resistencia debe ser de 220\u03a9.La funci\u00f3n setup()<\/code> se ejecuta una vez cuando se enciende la placa de Arduino.La funci\u00f3n loop()<\/code> se ejecuta despu\u00e9s de la funci\u00f3n setup()<\/code> y se repite indefinidamente mientras la placa est\u00e1 encendida.La funci\u00f3n digitalWrite()<\/code> pone a nivel alto (5V) o nivel bajo (0V) un pin digital de la placa de Arduino.La funci\u00f3n delay()<\/code> detiene el programa durante el tiempo especificado. <\/p><\/div>\n\n\n\n
                    \n\n\n\n
                    Brillo<\/h2>\n\n\n\n
                     El circuito del cap\u00edtulo anterior junto con su c\u00f3digo, nos ha permitido encender y apagar un led. Ahora, usando el mismo circuito pero cambiando el c\u00f3digo, vamos a variar la intensidad con la que se enciende el led. Este c\u00f3digo es un poquito m\u00e1s complejo que el anterior, as\u00ed que atenci\u00f3n. <\/p>\n\n\n\n
                    \"\"<\/figure><\/div>\n\n\n\n
                     Creamos un nuevo sketch y escribimos el siguiente c\u00f3digo: <\/p>\n\n\n
                    \n#define LED_PIN 3\n\nint level = 0;\n\nvoid setup() {\n  pinMode(LED_PIN, OUTPUT);\n}\n\nvoid loop() {\n  if(level == 255)\n    level = 0;\n\n  analogWrite(LED_PIN, level++);\n  delay(50);\n}\n<\/pre><\/div>\n\n\n
                    Echando un vistazo a este nuevo c\u00f3digo, vemos tres diferencias importantes respecto del c\u00f3digo anterior. Por un lado, el led lo conectamos a pin 3, no al 2. La segunda diferencia es que definimos la variable level<\/code>, y adem\u00e1s, usamos la funci\u00f3n analogWrite<\/code> en vez de usar digitalWrite<\/code> como antes.<\/p>\n\n\n\n
                    En la segunda l\u00ednea del c\u00f3digo definimos la variable level<\/code> con el valor cero.<\/p>\n\n\n
                    \nint level = 0;\n<\/pre><\/div>\n\n\n
                    Esta variable se define de tipo int<\/code> para contener n\u00fameros enteros, y se le asigna el valor cero. Va a contener el nivel de brillo que queremos aplicar al led.<\/p>\n\n\n\n
                    La funci\u00f3n setup()<\/code> es id\u00e9ntica a la del c\u00f3digo anterior y no requiere ninguna explicaci\u00f3n adicional.<\/p>\n\n\n\n
                    El contenido de la funci\u00f3n loop()<\/code> s\u00ed es diferente y requiere aclaraciones. El primer bloque de c\u00f3digo<\/p>\n\n\n
                    \nif(level == 255)\n\tlevel = 0;\n<\/pre><\/div>\n\n\n
                    La primera l\u00ednea de este bloque usa la sentencia if<\/code> (condicional) y debe entenderse como: \u201csi level<\/code> es igual a 255\u201d. La segunda l\u00ednea indica lo que debe hacerse si se cumple la condici\u00f3n anterior. Estas dos l\u00edneas le est\u00e1n diciendo a la placa de Arduino UNO que si en alg\u00fan momento la variable level<\/code> tiene el valor 255, se le asigne el valor cero. Ahora veremos la raz\u00f3n de hacer esto.<\/p>\n\n\n\n
                    El segundo bloque de c\u00f3digo establece el brillo del led:<\/p>\n\n\n
                    \nanalogWrite(LED_PIN, level++);\ndelay(50);\n<\/pre><\/div>\n\n\n
                    As\u00ed como la funci\u00f3n digitalWrite()<\/code> usada anteriormente, nos permit\u00eda poner un pin a nivel alto (5V) o nivel bajo (0V), la funci\u00f3n analogWrite()<\/code> permite indicar el voltaje que queremos poner en un pin PWM. Es necesario que el pin utilizado en esta funci\u00f3n soporte se\u00f1ales PWM<\/a> (los serigrafiados con ~), por eso en este caso hemos usado el pin 3 y no el pin 2 como us\u00e1bamos en el cap\u00edtulo anterior.<\/p>\n\n\n\n
                    El segundo par\u00e1metro de la funci\u00f3n analogWrite()<\/code> indica el voltaje que queremos obtener. Este par\u00e1metro acepta valores enteros entre 0 y 255, de manera que el valor 0 corresponde a 0V y el 255 corresponde a 5V.<\/p>\n\n\n\n
                    El operador ++<\/code> aplicado a la variable level<\/code> en la funci\u00f3n analogWrite()<\/code> hace que level<\/code> se incremente en una unidad despu\u00e9s de ejecutar la funci\u00f3n. Esto hace que en cada ejecuci\u00f3n de la funci\u00f3n loop()<\/code>, la variable level<\/code> se incremente en una unidad.<\/p>\n\n\n\n
                    Ahora vemos el sentido de la sentencia if<\/code> usada anteriormente. La variable level<\/code> empieza con valor 0, en cada ejecuci\u00f3n de la funci\u00f3n loop()<\/code> se incrementa en una unidad cada 50 milisegundos (delay(50)<\/code>) y cuando llega a tener un valor de 255 se vuelve a poner a 0. Esto har\u00e1 que el voltaje aplicado al led empiece con 0, se incremente en cada ejecuci\u00f3n del loop()<\/code> y, cuando llegue a 5V se volver\u00e1 a poner a 0V. Con esto obtenemos que el led empiece apagado, vaya incrementando su brillo hasta llegar al nivel m\u00e1ximo, se apague de nuevo y se repita el proceso mientras el circuito est\u00e9 encendido.<\/p>\n\n\n\n
                    Resumen<\/p>
                    Podemos definir variables que contengan valores \u00fatiles.La funci\u00f3n analogWrite()<\/code> permite indicar el voltaje que queremos obtener de un pin PWM.El operador ++<\/code> incrementa una variable cada vez que se ejecuta. <\/p><\/div>\n\n\n\n
                    \n\n\n\n
                    Sem\u00e1foro<\/h2>\n\n\n\n
                    Seguimos adentr\u00e1ndonos en el mundo Arduino trabajando con leds. En este cap\u00edtulo vamos a simular el funcionamiento de un sem\u00e1foro. Para ello usaremos tres leds, uno rojo, uno amarillo y uno verde. El circuito es id\u00e9ntico al de cap\u00edtulos anteriores, pero por triplicado.<\/p>\n\n\n\n
                    Como vamos a controlar el encendido y apagado de tres leds, necesitaremos usar tres pines de Arduino, por ejemplo usaremos los pines 2, 3 y 4.<\/p>\n\n\n\n
                    El esquema del circuito a montar es el siguiente:<\/p>\n\n\n\n
                    \"\"<\/figure><\/div>\n\n\n\n
                     Montado en la protoboard, quedar\u00eda algo as\u00ed: <\/p>\n\n\n\n
                    \"\"<\/figure><\/div>\n\n\n\n
                    Veamos ahora el c\u00f3digo necesario para hacer funcionar nuestro sem\u00e1foro. Ya sabemos c\u00f3mo encender y apagar un led as\u00ed que lo tenemos f\u00e1cil. El proceso ser\u00eda el siguiente:<\/p>\n\n\n\n
                    1. Encender el led verde durante 5 segundos.<\/li>
                    2. Hacer que el led \u00e1mbar parpadee 5 veces.<\/li>
                    3. Encender el led rojo durante 4 segundos<\/li><\/ol>\n\n\n\n
                      Analizando el proceso anterior, vemos que necesitamos 2 acciones: Encender y Parpadear.<\/p>\n\n\n\n
                      En programaci\u00f3n, las acciones a realizar se implementan mediante funciones. Una funci\u00f3n es un trozo de c\u00f3digo que podemos ejecutar cuando queramos. La funci\u00f3n Encender podemos implementarla con el siguiente c\u00f3digo:<\/p>\n\n\n
                      \nvoid Encender(int led, int tiempo){\n  digitalWrite(led, HIGH);\n  delay(tiempo);\n  digitalWrite(led, LOW);\n}\n<\/pre><\/div>\n\n\n
                      Esta funci\u00f3n recibe dos par\u00e1metros de tipo int<\/code>: el led que queremos encender y el tiempo que queremos mantenerlo encendido. Usando las ya conocidas funciones digitalWrite<\/code> y delay<\/code>, lo conseguimos f\u00e1cilmente.<\/p>\n\n\n\n
                      La funci\u00f3n Parpadear<\/code> es un poquito m\u00e1s compleja. El c\u00f3digo es el siguiente:<\/p>\n\n\n
                      \nvoid Parpadear(int led, int veces){\n  for(int i = 1; i <= veces; i++){\n    Encender(led, 250);\n    delay(250);\n  }\n}\n<\/pre><\/div>\n\n\n
                       Parpadear recibe dos par\u00e1metros: el led y el n\u00famero de veces que queremos que parpadee. El parpadeo consiste en repetir el encendido. En programaci\u00f3n, las repeticiones se implementar mediante bucles. En el c\u00f3digo anterior hemos usado el bucle for. <\/p>\n\n\n
                      \nfor(int i = 1; i <= veces; i++){\n\t...\n}\n<\/pre><\/div>\n\n\n
                      El bucle for<\/code> se define mediante tres sentencias. La primera indica la variable que va a controlar el bucle y su valor inicial (int i = 1<\/code>), la segunda indica la condici\u00f3n que debe cumplirse para que el bucle siga repiti\u00e9ndose (i <= veces<\/code>) y la tercera sentencia indica el incremento que debe darse a la variable de control en cada repetici\u00f3n (i++<\/code>). El c\u00f3digo incluido en el interior del bucle se repetir\u00e1 mientras se cumpla la condici\u00f3n especificada en la segunda sentencia.<\/p>\n\n\n\n
                      Ahora que tenemos definido c\u00f3mo Encender y c\u00f3mo Parpadear, el programa es sencillo:<\/p>\n\n\n
                      \nvoid loop() {\n  Encender(LED_VERDE, 5000);\n  Parpadear(LED_AMBAR, 5);\n  Encender(LED_ROJO, 4000);\n}\n<\/pre><\/div>\n\n\n
                       Con todo esto, el programa completo es el siguiente: <\/p>\n\n\n
                      \n#define LED_ROJO 2\n#define LED_AMBAR 3\n#define LED_VERDE 4\n\nvoid setup() {\n  pinMode(LED_ROJO, OUTPUT);\n  pinMode(LED_AMBAR, OUTPUT);\n  pinMode(LED_VERDE, OUTPUT);\n}\n\nvoid loop() {\n  Encender(LED_VERDE, 5000);\n  Parpadear(LED_AMBAR, 5);\n  Encender(LED_ROJO, 4000);\n}\n\nvoid Encender(int led, int tiempo){\n  digitalWrite(led, HIGH);\n  delay(tiempo);\n  digitalWrite(led, LOW);\n}\n\nvoid Parpadear(int led, int veces){\n  for(int i = 1; i <= veces; i++){\n    Encender(led, 250);\n    delay(250);\n  }\n}\n<\/pre><\/div>\n\n\n
                      Resumen<\/p>
                      Podemos definir funciones para realizar acciones.Si necesitamos repetir un cierto c\u00f3digo podemos usar un bucle. <\/p><\/div>\n\n\n\n
                      \n\n\n\n
                      Pulsador<\/h2>\n\n\n\n
                      Hasta ahora hemos trabajado con leds. Hemos visto c\u00f3mo encenderlos y apagarlos, as\u00ed como controlar el tiempo de encendido. Ahora vamos a introducir un nuevo elemento: el pulsador. Un pulsador es un interruptor moment\u00e1neo, mantiene el circuito cerrado cuando lo pulsamos y abierto cuando dejamos de pulsar.<\/p>\n\n\n\n
                      Para encender un led us\u00e1bamos un pin digital de Arduino que actuaba como pin de salida, es decir, era la placa de Arduino la que daba la orden de encendido. Ahora queremos que la placa de Arduino reciba la se\u00f1al generada por el pulsador, es decir, vamos a usar un pin digital de Arduino como pin de entrada.<\/p>\n\n\n\n
                      Esta distinci\u00f3n es importante, m\u00e1s adelante veremos c\u00f3mo indicarlo en el c\u00f3digo.<\/p>\n\n\n\n
                      Queremos construir un circuito que al pulsar un pulsador encienda un led y al volverlo a pulsar lo apague. El circuito que tenemos que montar es el siguiente:<\/p>\n\n\n\n
                      \"\"<\/figure><\/div>\n\n\n\n
                      \"\"<\/figure><\/div>\n\n\n\n
                      En el esquema anterior, la parte izquierda formada por le led y R1 ya la conocemos, nada que comentar. Nos centraremos en la parte derecha del esquema, la formada por el pulsador y R2.<\/p>\n\n\n\n
                      Un pin digital de entrada, en este caso el D3, debe estar en un estado bien definido, puede estar a nivel bajo (0V, conectado a GND) o a nivel alto (5V, conectado al pin 5V) pero no vale tenerlo \u201cal aire\u201d sin conectar a ning\u00fan sitio, en este caso podr\u00edamos tener resultados inesperados.<\/p>\n\n\n\n
                      En el esquema anterior, si el pulsador est\u00e1 pulsado, el pin D3 est\u00e1 conectado a 5V, es un estado bien definido. Si el pulsador est\u00e1 sin pulsar, el pin D3 est\u00e1 conectado a GND a trav\u00e9s de la resistencia R2 de 10K\u03a9, tambi\u00e9n est\u00e1 bien definido. As\u00ed, cuando pulsamos el pulsador, el pin D3 recibe una se\u00f1al de 5V y cuando dejamos de pulsar, recibe una se\u00f1al de 0V. Estos dos estados podemos reconocerlos en el c\u00f3digo y saber si el pulsador est\u00e1 pulsado o no.<\/p>\n\n\n\n
                      Para saber si un pin de entrada est\u00e1 a nivel alto o bajo, usaremos la funci\u00f3n digitalRead(PIN)<\/code>. Esta funci\u00f3n devuelve HIGH<\/code> si el pin PIN<\/code> est\u00e1 a nivel alto y LOW<\/code> si est\u00e1 a nivel bajo. As\u00ed pues, si digitalRead(PIN)<\/code> devuelve HIGH<\/code> es que el pulsador est\u00e1 pulsado, si devuelve LOW<\/code> es que no est\u00e1 pulsado.<\/p>\n\n\n\n
                      Podemos definir la funci\u00f3n PulsadorPulsado<\/code> que nos indique si se ha pulsado el pulsador. Entenderemos por pulsaci\u00f3n el acto de presionar y soltar el pulsador. Esta funci\u00f3n devolver\u00e1 el valor true<\/code> (verdadero) si se ha pulsado el pulsador y false<\/code> (falso) si no se ha pulsado.<\/p>\n\n\n
                      \nbool PulsadorPulsado(){\n  if(digitalRead(SW_PIN) == HIGH){\n    while(digitalRead(SW_PIN) == HIGH){\n      delay(100);\n    }\n    return true;\n  }\n  return false;\n}\n<\/pre><\/div>\n\n\n
                       La funci\u00f3n se define de tipo bool para indicar que devuelve un valor booleano (true o false, verdadero o falso). Lo primero que hace la funci\u00f3n es comprobar si el pin SW_PIN est\u00e1 a nivel alto o bajo. <\/p>\n\n\n
                      \nif(digitalRead(SW_PIN) == HIGH)\n<\/pre><\/div>\n\n\n
                      La sentencia if(condici\u00f3n){c\u00f3digo}<\/code> ejecuta el c\u00f3digo s\u00f3lo si la condici\u00f3n es verdadera. En este caso, la condici\u00f3n es digitalRead(SW_PIN) == HIGH<\/code>, es decir, el pin SW_PIN<\/code> est\u00e1 a nivel alto, osea, el pulsador est\u00e1 pulsado. El operador ==<\/code> es un operador de comparaci\u00f3n y se usa para comparar dos valores, no confundir con el operador =<\/code> que es un operador de asignaci\u00f3n.<\/p>\n\n\n\n
                      Si el pulsador est\u00e1 pulsado, se ejecutar\u00e1 el c\u00f3digo que hay en el interior de la sentencia if<\/code>, si no est\u00e1 pulsado, no se ejecutar\u00e1. Si el pulsador no est\u00e1 pulsado, la siguiente instrucci\u00f3n que se ejecuta es return false<\/code> y la funci\u00f3n PulsadorPulsado<\/code> devuelve el valor false<\/code>.<\/p>\n\n\n\n
                      Si el pulsador est\u00e1 pulsado, se ejecuta el c\u00f3digo interno a la funci\u00f3n if<\/code>:<\/p>\n\n\n
                      \n while(digitalRead(SW_PIN) == HIGH){\n    delay(100);\n }\n return true;\n<\/pre><\/div>\n\n\n
                      Este c\u00f3digo espera hasta que se deje de pulsar el pulsador y devuelve true<\/code>. El bucle while(condici\u00f3n)<\/code> se repite mientras la condici\u00f3n sea verdadera. En este caso, se repetir\u00e1 delay(100)<\/code> hasta que dejemos de pulsar el pulsador. Cuando dejemos de pulsar, el bucle termina y la funci\u00f3n PulsadorPulsado<\/code> devuelve true<\/code>.<\/p>\n\n\n\n
                      Ya tenemos controlado el pulsador, ahora queremos que cada vez que se pulsa, cambie el estado del led. Definimos la funci\u00f3n CambiaEstadoLed<\/code>:<\/p>\n\n\n
                      \nvoid CambiaEstadoLed(){\n  if(EstadoLed == false){\n    digitalWrite(LED_PIN, HIGH);\n    EstadoLed = true;\n  }\n  else{\n    digitalWrite(LED_PIN, LOW);\n    EstadoLed = false;\n  }\n}\n<\/pre><\/div>\n\n\n
                      Esta funci\u00f3n es sencilla y usa la variable EstadoLed<\/code> de tipo bool<\/code>. Esta variable la ponemos a true<\/code> cuando el led est\u00e1 encendido y a false<\/code> cuando est\u00e1 apagado. Usamos la sentencia if(condici\u00f3n){c\u00f3digo1}else{c\u00f3digo2}<\/code> que ejecuta c\u00f3digo1<\/code> si condici\u00f3n<\/code> es verdadera y c\u00f3digo2<\/code> si es falsa. Por tanto, si EstadoLed<\/code> es falso, encendemos el led y ponemos EstadoLed<\/code> en verdadero, si no, apagamos el led y ponemos EstadoLed<\/code> en falso.<\/p>\n\n\n\n
                      Por \u00faltimo, s\u00f3lo comentar que el pin que usemos para saber el estado del pulsador tenemos que declararlo como pin de entrada y el pin que usemos para controlar el led ser\u00e1 un pin de salida. Esto lo hacemos en la funci\u00f3n setup<\/code>:<\/p>\n\n\n
                      \nvoid setup() {\n  pinMode(LED_PIN, OUTPUT);\n  pinMode(SW_PIN, INPUT);\n}\n<\/pre><\/div>\n\n\n
                       Con todo esto, el c\u00f3digo completo es el siguiente: <\/p>\n\n\n
                      \n#define LED_PIN 2\n#define SW_PIN 3\n\nbool EstadoLed = false;\n\nvoid setup() {\n  pinMode(LED_PIN, OUTPUT);\n  pinMode(SW_PIN, INPUT);\n}\n\nvoid loop() {\n  if(PulsadorPulsado())\n    CambiaEstadoLed();\n}\n\nbool PulsadorPulsado(){\n  if(digitalRead(SW_PIN) == HIGH){\n    while(digitalRead(SW_PIN) == HIGH){\n      delay(100);\n    }\n    return true;\n  }\n  return false;\n} \n\nvoid CambiaEstadoLed(){\n  if(EstadoLed == false){\n    digitalWrite(LED_PIN, HIGH);\n    EstadoLed = true;\n  }\n  else{\n    digitalWrite(LED_PIN, LOW);\n    EstadoLed = false;\n  }\n}\n<\/pre><\/div>\n\n\n
                      \n\n\n\n
                      LDR<\/h2>\n\n\n\n
                      Una LDR (light dependent resistor) o c\u00e9lula fotoel\u00e9ctrica es un componente electr\u00f3nico cuya resistencia depende de la intensidad de la luz que recibe, decimos que es un sensor de luminosidad.<\/p>\n\n\n\n
                      Vamos a construir un circuito que simule una l\u00e1mpara nocturna. Si es de d\u00eda (mucha luz ambiental) la l\u00e1mpara estar\u00e1 apagada, a medida que anochece, la l\u00e1mpara se ir\u00e1 encendiendo, alcanzando su m\u00e1xima luminosidad cuando es de noche (poca luz ambiental).<\/p>\n\n\n\n
                      Dado que tenemos que variar la luminosidad del led de manera continua, como hicimos en el cap\u00edtulo Brillo, para controlar el led necesitaremos un pin con salida PWM (los serigrafiados con ~), por ejemplo el pin D3.<\/p>\n\n\n\n
                      Para leer el valor de la resistencia ofrecida por la LDR (ya sabemos que depende de la luminosidad ambiental) necesitamos un pin anal\u00f3gico, por ejemplo el A0. Los pines anal\u00f3gicos pueden leer voltajes comprendidos entre 0 y 5V. Nuestro circuito tiene que ser capaz de transformar la resistencia variable de la LDR en un voltaje variable que podamos leer con un pin anal\u00f3gico.<\/p>\n\n\n\n
                      Este es el circuito que vamos a montar:<\/p>\n\n\n\n
                      \"\"<\/figure><\/div>\n\n\n\n
                      \"\"<\/figure><\/div>\n\n\n\n
                      La parte izquierda del esquema formada por la resistencia R1 y el Led ya la conocemos. Vamos a ver la parte derecha formada por la resistencia R2 y la LDR. El circuito formado por R2 y LDR es muy conocido y tiene el nombre de \u201cDivisor de tensi\u00f3n\u201d.<\/p>\n\n\n\n
                      Un divisor de tensi\u00f3n est\u00e1 formado por dos resistencias en serie cuyos extremos se conectan a GND y 5V. La tensi\u00f3n obtenida en el punto central depender\u00e1 de los valores de ambas resistencias.<\/p>\n\n\n\n
                      Vo = Vcc * R2\/(R2 + Rldr)<\/p>\n\n\n\n
                      Donde Vo es la tensi\u00f3n en el punto central A0, VCC es la tensi\u00f3n total del divisor de tensi\u00f3n, 5V en este caso, y Rldr es la resistencia de la LDR. Despejando Rldr tenemos<\/p>\n\n\n\n
                      Rldr = R2(Vcc\/Vo -1)<\/p>\n\n\n\n
                      Es decir, midiendo V0 podemos saber la resistencia que tiene la LDR, y por tanto, la luminosidad que recibe. La relaci\u00f3n entre la resistencia y la luminosidad depende del tipo de material con que est\u00e1 construida la LDR y de la temperatura, no vamos a entrar en esto. Lo importante aqu\u00ed es tener claro que la tensi\u00f3n que midamos en A0 depender\u00e1 de la luminosidad que recibe la LDR.<\/p>\n\n\n\n
                      Para medir la tensi\u00f3n presente en un pin anal\u00f3gico se usa la funci\u00f3n analogRead(Pin)<\/code>. La placa de Arduino UNO tiene una resoluci\u00f3n en sus pines anal\u00f3gicos de 10 bits, lo que significa que esta funci\u00f3n devuelve valores comprendidos entre 0 y 1023 donde 0 corresponde a 0 voltios y 1023 a 5V. Por tanto, podemos definir la funci\u00f3n<\/p>\n\n\n
                      \nint LeeLdr(){\n  int v0 = analogRead(LDR_PIN);\n  if(v0 > MaxLuz) v0 = MaxLuz;\n  return v0;\n} \n<\/pre><\/div>\n\n\n
                      LeeLdr()<\/code> lee el valor del voltaje presente en LDR_PIN (A0) mediante la funci\u00f3n analogRead(pin)<\/code>. Este valor est\u00e1 comprendido entre 0 y 1023. No queremos que el led se encienda hasta que la luminosidad baje de cierto umbral, por eso usamos la variable MaxLuz<\/code> que representa la luminosidad m\u00e1xima por debajo de la cual empezar\u00e1 a encenderse el led, los valores mayores que MaxLuz<\/code> los ignoramos con if(v0 > MaxLuz) v0 = MaxLuz;<\/code>. Por tanto, la funci\u00f3n LeeLdr()<\/code> devuelve un valor comprendido entre 0 y MaxLuz<\/code>.<\/p>\n\n\n\n
                      Para encender el led definimos la funci\u00f3n EnciendeLed(int luminosidad)<\/code> que ya la conocemos del cap\u00edtulo Brillo.<\/p>\n\n\n
                      \nvoid EnciendeLed(int intensidad){\n  analogWrite(LED_PIN, intensidad);\n}\n<\/pre><\/div>\n\n\n
                      Para poder relacionar estas dos funciones, debemos tener en cuenta que ambas trabajan en rangos de valores distintos. LeeLdr()<\/code> devuelve valores entre 0 y MaxLuz<\/code>, EnciendeLed()<\/code> acepta valores entre 0 y 255. No podemos pasar a EnciendeLed()<\/code> el valor devuelto por LeeLdr()<\/code> sin m\u00e1s.<\/p>\n\n\n\n
                      Para transformar una valor de un rango a otro se usa la funci\u00f3n map()<\/code>. Esta funci\u00f3n es un cambio de escala, la sintaxis es la siguiente:<\/p>\n\n\n
                      \nxz = map(xy, ymin, ymax, zmin, zmax)\n<\/pre><\/div>\n\n\n
                       Esta funci\u00f3n convierte un valor xy en el rango (ymin, ymax) a un valor xz en el rango (zmin, zmax). En nuestro caso, queremos convertir un valor en el rango (0, MaxLuz) a un valor en el rango (0, 255), adem\u00e1s, queremos que cuanto mayor sea la luminosidad ambiental, menor sea la intensidad en el led. Por tanto, el cambio de escala ser\u00e1 el siguiente <\/p>\n\n\n
                      \nmap(v0, 0, MaxLuz, 255, 0);\n<\/pre><\/div>\n\n\n
                       Con todo esto, el programa completo es el siguiente: <\/p>\n\n\n
                      \n#define LED_PIN 3\n#define LDR_PIN A0\n\nint MaxLuz = 850;\n\nvoid setup() {\n  pinMode(LED_PIN, OUTPUT);\n}\n\nvoid loop() {\n  int v0 = LeeLdr();\n  EnciendeLed(map(v0, 0, MaxLuz, 255, 0));\n  delay(50);\n}\n\nint LeeLdr(){\n  int v0 = analogRead(LDR_PIN);\n  if(v0 > MaxLuz) v0 = MaxLuz;\n  return v0;\n} \n\nvoid EnciendeLed(int intensidad){\n  analogWrite(LED_PIN, intensidad);\n}\n<\/pre><\/div>\n\n
                      \r\n\r\n\r\n\t\r\n\t\t\r\n\t\t
                      \r\n\t\t\t\r\n\t\t<\/td>\r\n\t\t\r\n\t\t\t
                      Producto en nuestra tienda<\/p>\r\n\t\t\t
                      Kit Arduino UNO R3<\/h3>\r\n\t\t<\/td>\r\n\t<\/tr>\r\n\t
                      \r\n\t\t\t
                      Kit de iniciaci\u00f3n al mundo Arduino. Perfecto para principiantes que quieren descubrir las posibilidades de esta fant\u00e1stica placa.<\/p>\n\t\t<\/td>\r\n\t<\/tr>\r\n<\/table>\r\n<\/a>\r\n\r\n<\/div>","protected":false},"excerpt":{"rendered":"
                      Para empezar a trabajar con la plataforma Arduino, debemos tener instalado el IDE de Arduino en nuestro ordenador. Este proceso podemos verlo con detalle en la p\u00e1gina 15 del Libro de Proyectos de Arduino....<\/p>\n","protected":false},"author":1,"featured_media":1104,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":""},"categories":[2,4],"tags":[],"uagb_featured_image_src":{"full":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3.jpeg",1360,1351,false],"thumbnail":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-150x150.jpeg",150,150,true],"medium":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-300x298.jpeg",300,298,true],"medium_large":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-768x763.jpeg",768,763,true],"large":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-1024x1017.jpeg",1024,1017,true],"1536x1536":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3.jpeg",1360,1351,false],"2048x2048":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3.jpeg",1360,1351,false],"thumb-small":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-160x160.jpeg",160,160,true],"thumb-standard":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-320x320.jpeg",320,320,true],"thumb-medium":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-520x245.jpeg",520,245,true],"thumb-large":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-720x340.jpeg",720,340,true],"thumb-xlarge":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-980x450.jpeg",980,450,true],"thumb-xxlarge":["https:\/\/www.turibot.es\/blog\/wp-content\/uploads\/2023\/01\/0013055_kit-arduino-uno-r3-1320x500.jpeg",1320,500,true]},"uagb_author_info":{"display_name":"Vicente Gras","author_link":"https:\/\/www.turibot.es\/blog\/index.php\/author\/vicen\/"},"uagb_comment_info":0,"uagb_excerpt":"Para empezar a trabajar con la plataforma Arduino, debemos tener instalado el IDE de Arduino en nuestro ordenador. Este proceso podemos verlo con detalle en la p\u00e1gina 15 del Libro de Proyectos de Arduino....","_links":{"self":[{"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/1078"}],"collection":[{"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=1078"}],"version-history":[{"count":18,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/1078\/revisions"}],"predecessor-version":[{"id":1243,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/posts\/1078\/revisions\/1243"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/media\/1104"}],"wp:attachment":[{"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=1078"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=1078"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.turibot.es\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=1078"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}