2. Conectando sensores y actuadores ¿Qué es un sensor? Para responder a esta pregunta, he recurrido a Wikipedia: Un sensor es todo aquello que tiene una propiedad sensible a una magnitud del medio, y al variar esta magnitud también varía con cierta intensidad la propiedad, es decir, manifiesta la presencia de dicha magnitud, y también su medida. Un sensor en la industria es un objeto capaz de variar una propiedad ante magnitudes físicas o químicas, llamadas variables de instrumentación, y transformarlas con un transductor en variables eléctricas. Las variables de instrumentación pueden ser por ejemplo: intensidad lumínica, temperatura, distancia, aceleración, inclinación, presión, desplazamiento, fuerza, torsión, humedad, movimiento, pH , etc. Una magnitud eléctrica puede ser una resistencia eléctrica (como en una RTD ), una capacidad eléctrica (como en un sensor de humedad ), una tensión eléctrica (como en un termopar ), una corriente eléctrica , etc. Digamos que un sensor nos va a permitir medir ciertas propiedades: la humedad en un determinado lugar, la cantidad de luz, de ruido, nuestras pulsaciones, la presión ejercida sobre una determinada superficie, la distancia a la que se encuentra un obstáculo, etc. En los próximos apartados, veremos los diferentes tipos de sensores (aunque hay, por supuesto, hay más...) que podremos utilizar junto con nuestro Arduino para crear vestibles. 1. Sensor de ultrasonidos Este sensor nos permite conocer la distancia a la que se encuentra un determinado objeto. Una explicación detallada sobre este sensor, junto con un ejemplo del código sobre su funcionamiento, la encontramos en este video: Apuntes sobre el vídeo: -La distancia aconsejable suele ser menor a 400cm, ya que en realidad a partir de 50 cm suele comenzar a fallar. -Variables del tipo long: se utilizan para almacenar números enteros bastante grandes. En nuestros proyectos utilizaremos variables numéricas del tipo int para almacenar números enteros, o del tipo float para almacenar números decimales, aunque no está de más que conozcamos que existen otros tipos de variables. 2. Sensor lumínico (fotorresistencia) Este sensor podemos encontrarlo en dos versiones, la que vemos a la izquierda y a la derecha de la foto superior. La versión izquierda nos permite unas lecturas más precisas, pero hemos de tener en cuenta que según cuál sea nuestro proyecto, quizás nos interese más perder un poco de precisión y poder utilizar un sensor con un tamaño menor. En nuestro caso, como estamos trabajando con vestibles, el módulo no nos interesa tanto por su tamaño y por la rigidez de los materiales. En el siguiente video veremos en funcionamiento el módulo de la izquierda, aunque también utiliza como sensor de apoyo la fotorresistencia en su versión sencilla: 3. Sensor táctil Este sensor nos permite detectar si estamos tocando una superficie. Una de las ventajas que presenta es que es más discreto que un pulsador, el cuál veremos un poco más adelante. En este video encontrarás una explicación de este sensor y un ejemplo: 4. Sensor flex Este sensor nos permite medir el grado en el que lo doblamos. Una de las aplicaciones más típicas es utilizarlo en guantes, en la zona de los dedos, para medir si el dedo se encuentra sin doblar o doblado y cómo de doblado está. 5. Pulsador El último sensor que vamos a ver es un pulsador. Este sensor es muy similar el que hemos visto en el apartado 3. La diferencia principal entre ambos es que en este es necesario pulsar el botón, mientras que en el anterior solamente con tocarlo ya se considera pulsado. Este sensor cuenta con 3 pines (como el sensor táctil): uno para la alimentación, otro para masa y otro para enviar la señal que detecta si el pulsador ha sido pulsado o no. No será necesario que veamos video para este sensor, ya que el funcionamiento del sensor táctil podemos extrapolarlo a este. Si quieres conocer más sensores, te aconsejo que visites esta página de otro curso ofrecido en Aularagón. Una vez vistos estos sensores, es el momento de pasar a ver qué acciones podemos activar con ellos... FUENTES: Sensor: https://es.wikipedia.org/wiki/Sensor Tipos de sensores: https://es.wikipedia.org/wiki/Anexo:Sensores#Proximidad_presencia Video sensor ultrasonidos: https://www.youtube.com/watch?v=tdRCGb5sFdI Sensor lumínico: https://www.youtube.com/watch?v=kL23DaxfPyA Sensor táctil: https://www.youtube.com/watch?v=uKxnvFNm8Hw Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¿Qué es un actuador? Un actuador nos va a permitir convertir las señales eléctricas que generarán nuestros sensores, y que procesará nuestro Arduino, en diferentes acciones que percibiremos principalmente de una manera visual, táctil o sonora. En este apartado, vamos a ver algunos de los actuadores que comúnmente se emplean con los proyectos relacionados con Arduino. 1. LED Este componente es uno de los primeros que se utilizan con Arduino, ya que es una manera rápida de obtener una verificación sobre el funcionamiento de nuestro código. Por ejemplo, con nuestro código podemos decir: "Si la medición de un sensor está entre este y aquel valor, enciende el LED; de lo contrario, no hagas nada." Debemos saber que los LED tienen una patilla más larga que la otra. La que es más larga, también llamada ánodo , es la que deberemos conectar a la alimentación (5 o 3.3V) y la más corta, conocida como cátodo , a masa (o GND). Siempre utilizaremos una resistencia para prolongar su vida. 2. Motor de vibración El motor de vibración es un motor de corriente continua de tamaño compacto que nos informa de una variación, detectada por el sensor correspondiente, mediante su vibración . Este sensor no tiene sonido y principalmente se utiliza en los teléfonos móviles, joysticks, o cualquier proyecto que requiera de una señal táctil. En nuestro caso, puede resultarnos útil en proyectos que requieran de un actuador que no sea demasiado perceptible por los demás, por lo que en el caso de los vestibles es bastante usado. Un ejemplo (aunque probablemente el motor vibrador empleado ahí sea más pequeño y sofisticado) lo encontramos en la Sound Shirt que hemos visto en páginas anteriores. 3. Solenoide Un solenoide se encarga de convertir un campo electromagnético, que genera él mismo gracias a una bobina de hilo conductor, en energía mecánica. En el caso de la imagen superior, lo que hace este tipo de solenoide es mover hacia afuera el pequeño tubo metálico que vemos en la parte derecha de la imagen. Esto produce un pequeño golpe, por lo que una de las aplicaciones típicas de estos solenoides es para generar diferentes sonidos. Un ejemplo de su funcionamiento lo encontramos en este video, en el que utilizan solenoides para crear instrumentos musicales: 4. Piezoeléctrico Este componente basa su funcionamiento en su propia deformación. A efectos prácticos pueden funcionar o bien como altavoces o como micrófonos . Un uso muy extendido de los piezos es el de crear micrófonos de contacto . Un micrófono de contacto capta las vibraciones del contacto con objetos. El disco metálico cuenta con un círculo de cristales piezoeléctricos en el centro. Cuando los cristales comienzan a vibrar, se produce un voltaje oscilante que es procesado en nuestro Arduino (y que también puede conectarse directamente a nuestro ordenador, o a un amplificador si lo usamos como micrófono para una guitarra, para obtener el sonido y reproducirlo a través de altavoces). El otro uso de un piezo es como altavoz. Al aplicarle tensión a los cristales piezoeléctricos, estos se deforman y actúan como un transductor electroacústico generando sonido. 5. Servo motor Un servomotor es un dispositivo que nos permite añadir movimiento a nuestros proyectos. La parte más interesante es que podemos controlar tanto su velocidad como su posición. Algunos de ellos giran 360º, mientras que otros giran 180º. Para controlar su movimiento, se utiliza una secuencia de pulsos (PWM) los cuales posicionan a nuestro servo en el ángulo indicado. En Arduino, existe la librería Servo , que nos ayuda a controlarlos fácilmente. Para conocer más detalles sobre los servos, te recomiendo echarle un vistazo a  este video. Si quieres saber más sobre actuadores, te aconsejo echarlo un vistazo a esta página de otro curso de Aularagón. FUENTES: Sensores y actuadores: http://openaccess.uoc.edu/webapps/o2/bitstream/10609/141046/12/PLA3_Sensores%20y%20actuadores.pdf Imagen motor de vibración: http://air.imag.fr/images/thumb/0/03/HapticGlovev0.jpg/1000px-HapticGlovev0.jpg Imagen solenoide: https://danpeirce.github.io/images-actuator/remote-solenoid.jpg Imagen LED: https://moorepants.github.io/eme185/2018/images/microcontroller-tutorial/led.jpg Solenoide: https://es.wikipedia.org/wiki/Solenoide Video solenoides: https://www.youtube.com/watch?v=dhKYxDzyXqI Piezoelectricidad: https://es.wikipedia.org/wiki/Piezoelectricidad Imagen piezo: https://upload.wikimedia.org/wikipedia/commons/thumb/f/f4/Piezo.jpg/1055px-Piezo.jpg Servomotor: https://es.wikipedia.org/wiki/Servomotor Video Servo: https://www.youtube.com/watch?v=mk9UkQCeENc Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Estructuras básicas para entendernos con Arduino De momento ya hemos puesto en funcionamiento nuestro Arduino y hemos visto algunos de los sensores y actuadores que podemos emplear con él. Ahora ha llegado el momento de ver con más detalle cómo darle las órdenes para hacerlo funcionar. Ya hemos visto algo de esto en los ejemplos de apartados anteriores (Véase el apartado Entender el código para encender el LED ) donde aparecían funciones y palabras reservadas. Ahora ha llegado el momento de ir un poco más allá, para poder comunicarnos con Arduino, y para ello, va a ser necesario que conozcamos algunas estructuras básicas comunes a todos los lenguajes de programación imperativa. Un momento... ¿programación imperativa? A la hora de programar nuestros proyectos y dependiendo del propósito de nuestro proyecto, existen diferentes paradigmas de programación. No vamos a ahondar en este tema más allá de mencionarlo, pero al menos, es importante saber qué significa eso de programación imperativa, porque probablemente nos encontremos con ese concepto si continuamos desarrollando proyectos de programación. Básicamente, si programamos utilizando el paradigma imperativo lo que haremos será dar órdenes explícitamente. Un ejemplo de ello sería la sentencia: "Realiza la acción que yo quiera todo el rato". ¿Nos suena de algo? Eso es exactamente lo que hace la función loop() en Arduino. Parece lógico que para programar tengamos que dar órdenes al ordenador o microcontrolador en cuestión, pero existen otros paradigmas como, por ejemplo, el declarativo , que no funcionan así. Un ejemplo de ello sería el caso en el que a nuestro ordenador le proporcionamos una conjunto de hechos y reglas y posteriormente le hacemos una consulta para que nos devuelva esa información. Por ejemplo, si creamos una base de hechos que contenga una serie de libros y su autor, podemos preguntar: ¿Quién ha escrito este libro? Y la aplicación nos devolverá esa información. Si tienes interés en leer más sobre este tema, puedes echarle un vistazo a estas páginas. Existen problemas que podemos resolver empleando ambos paradigmas y cuando programamos es necesario decidir cuál es el más adecuado. No obstante, aquí no vamos a tener ese problema, porque con los proyectos que vamos a ver en este curso siempre vamos a emplear el paradigma imperativo. La estructura de estos programas suele representarse con lo que se conoce como diagrama de flujo . Con él, se representan los diferentes caminos que puede tomar nuestro algoritmo dependiendo de las condiciones que se cumplan o no. Estas condiciones será lo primero que veremos, ya que son la base sobre la que se construye cualquier algoritmo. Para más información sobre diagramas de flujo puedes consultar esta página de otro curso de Aularagón. Condicionales (if-else-else if) Estas estructuras se encargan de controlar qué acciones de nuestro algoritmo van a ejecutarse y cuáles no. Solo hay dos opciones: o bien se cumplirán las condiciones, o no. Las palabras clave de esta estructura son: IF - ELSE IF: A esta palabra le seguirá la condición que deberá cumplirse para ejecutar una serie de acciones . ELSE: irá seguida de las acciones que se ejecutarán en caso de que la condición no se cumpla. Un ejemplo para verlo en acción No hay mejor manera para entender algo que ver una demostración de su uso. Para ello, vamos a recurrir a uno de los ejemplos que nos brinda la IDE de Arduino. Este ejemplo podemos encontrarlo dentro de: Archivo > Ejemplos > 01. Basics > Fade En este ejemplo, lo que hacemos es aumentar y disminuir la luminosidad de un LED de manera progresiva, en lugar de encenderlo o apagarlo del todo, como hacíamos en la práctica del bloque anterior. Para ello, haremos uso de unos pines especiales (PWM) , los cuáles pueden ser configurados para funcionar con modulación por ancho de pulsos. Y, ¿esto qué significa? pues que no solamente tienen dos posiciones (encendido o apagado), sino que podemos controlar cómo de apagado y encendido está controlando la cantidad de energía que recibe.  Regular esta cantidad de energía puede hacerse con la función analogWrite(). Ya habíamos visto la función digitalWrite(). Si no te acuerdas, puedes echarle un vistazo aquí . analogWrite() nos permite darle al pin elegido un valor de 0 a 255, siendo 0 totalmente apagado y 255 totalmente encendido. ¿Cuál es la particularidad de esta función? que, a diferencia de digitalWrite(), que puede ser configurada con cualquier pin, analogWrite() no. Una lista de los pines que admiten PWM dependiendo del Arduino que estemos utilizando la encontramos aquí . De este ejemplo, por el momento, vamos a ver concretamente la parte relacionada con el condicional, pero volveremos a él después para utilizarlo como ejemplo de uso de palabras reservadas y funciones . En este algoritmo, el condicional aparece en las siguientes líneas. if (brightness <= 0 || brightness >= 255) { fadeAmount = -fadeAmount; } En estas líneas encontramos la palabra reservada if seguida de dos condiciones encerradas entre paréntesis. Lo que traducido a español significaría: "Si el brillo es menor o igual que cero o el brillo es mayor o igual que 255". La disyunción nos viene dada por el operador lógico OR que para Arduino se traduce como ||. Otros operadores lógicos muy comunes son AND, que se traduce por && y NOT, que se escribe ! . Entre corchetes { } encontramos la acción a realizar. En este caso, revertir la cantidad de brillo que emitirá nuestro LED: si lo hemos apagado, lo comenzaremos a encender y al revés, si lo hemos encendido completamente, comenzaremos a apagarlo. En este caso, no existe una acción que deba ejecutarse en caso de que no se de alguna de las dos circunstancias encerradas en el condicional, pero si la hubiese aparecería detrás de la palabra else . Por tanto, un esquema de la estructura de los condicionales sería: if (Condición) { Acción A } else { Acción B } Siendo posible también: if (Condición) { Acción } Una última palabra sobre los condicionales: else if Existe también la posibilidad de que tengamos que realizar selecciones que den lugar a más de dos posibilidades, como por ejemplo en el caso que estemos leyendo ciertos valores de un sensor y queramos que un actuador realice diferentes acciones dependiendo de ellos. Si el sensor recibe valores entre 0 y 255 --> Acción A Si el sensor recibe valores entre 256 y 511 --> Acción B Si el sensor recibe valores entre 512 y 1024 --> Acción C Una forma de conseguir esto es anidar varias condicionales. Para ello necesitaremos las palabras else if, las cuales indican una segunda condición, o sucesivas. La estructura sería la siguiente: if (Condición 1) { Acción A } else if (Condición 2) { Acción B } else { Acción C } Iteraciones (for y while) Definiremos como iteración a la ejecución sistemática de una serie de acciones determinadas mientras se dé una condición específica. Existe una condición que se analiza, normalmente, cada vez que se repite dicha iteración. Si esta condición se sigue cumpliendo, volveremos a repetir el proceso; si, por el contrario, ya no se cumple, pasaremos a la siguiente línea de código y ejecutaremos la acción correspondiente. Las dos más comunes son for y while . En la sentencia for, existe un índice cuyo valor va aumentando o disminuyendo conforme se ejecuta el algoritmo y la condición de la iteración va comprobando si se ha alcanzado el límite o no. Un esquema de esta estructura sería: for (int indice= inicial; índice<= final; índice ++){ Acción } Es importante no olvidar colocar los paréntesis, puntos y comas y los corchetes donde corresponda, o Arduino se quejará y no nos hará caso... Un ejemplo para verlo en acción Un ejemplo sencillo de esta estructura, que te aconsejo que construyas para verlo en funcionamiento, lo encontramos en este fragmento de código: // Controlar la luminosidad de un LED usando PWM y analogWrite() int PWMpin = 9; // LED conectado al pin 9, con PWM. void setup() { // no es necesario } void loop() { for (int i = 0; i <= 255; i++) { analogWrite(PWMpin, i); delay(10); } } Como podemos comprobar, el bucle for se ejecuta continuamente por estar dentro de la función void loop() y lo que hace es encender continuamente el LED. En este caso únicamente lo enciende, no se encarga de apagarlo. 1. Conectaremos con un cocodrilo uno de nuestros LED al pin 9. Para ello, conectaremos un extremo del cocodrilo al signo + del LED y el otro extremo del cocodrilo al pin 9, con MUCHO CUIDADO de que el cocodrilo exclusivamente esté en contacto con ese pin y no con los de los laterales: 2. Conectaremos un cocodrilo al signo - del LED y el otro extremo a un pin GND de nuestro Arduino. 3. Copiaremos y pegaremos el código anterior a un sketch nuevo de Arduino, lo guardaremos, lo subiremos a nuestro microcontrolador y...  aquí lo podemos ver en funcionamiento: A parte del bucle for existe el bucle while , cuyo esquema general sería: while (condición){ Acción } Un ejemplo, para verlo en funcionamiento aunque no tengo mucha utilidad real, sería: int var = 0; while (var < 200) { // haz algo 200 veces var=var+1; //también podría escribirse como var++. } En él, hemos creado una variable con el valor 0, la cuál es aumentada dentro del bucle while con la operación var = var+1. Antes de aumentar este valor, en la línea superior deberíamos escribir la acción a ejecutar 200 veces. Palabras reservadas En los fragmentos de código que hemos ido viendo a lo largo de los apartados anteriores, ya aparecían estos términos especiales. Palabras como int, for, void loop() o if se consideran palabras reservadas porque poseen un significado especial dentro del lenguaje de programación que estamos empleando. Una manera de identificar a estas palabras especiales es porque aparecen con un color diferente . ... para tipos de datos Estas palabras tienen diferentes objetivos. Uno de ellos es para denotar los tipos de datos que podemos usar en nuestros programas. A estas palabras se les conoce como tipos predefinidos,  las escribimos delante de aquellas variables que vamos a emplear en nuestro programa y algunas de ellas son: int: almacena un número entero de un tamaño máximo de 16 bits. float: almacena un número decimal de 32 bits. char: almacena un caracter boolean: almacena el valor verdadero (TRUE) o falso (FALSE). long: almacena el valor de un número entero de 32 bits Por ejemplo podemos crear una variable que almacene el valor numérico que obtengamos con un sensor. Podríamos crearla así: int valorSensorTemperatura = 0; Lo que haría que el valor de esa variable inicialmente sea cero, siendo modificado cuando lo asignemos al pin de nuestro Arduino al que hemos conectado el sensor. ... para funciones Como ya hemos visto, existe una serie de funciones que ya vienen preprogramadas y que podemos utilizar directamente. Las dos fundamentales son void setup() y void loop() , pero existen muchas otras. Algunas de ellas son: delay(): detiene el programa durante el tiempo indicado (en milisegundos). random() : genera números pseudoaleatorios. float() : convierte un número, por ejemplo del tipo int, a un número decimal. Librerías Existen ciertos sensores y actuadores a los que no basta con conectarlos y programarlos para que hagan lo que nosotros queramos, sino que para poder controlarlos es necesario emplear código adicional que siempre es el mismo. Para almacenar este código y evitar que tengamos que programarlo nosotros se crean las librerías . Existen cientos de librerías, por lo que no vienen preinstaladas con la IDE desde la que programaremos nuestro Arduino. Lo que haremos será incluir en nuestro proyectos únicamente las que necesitemos, si es que necesitamos alguna. En las prácticas posteriores haremos uso de algunas de ellas y veremos cómo se instalan. Estas librerías suelen contener una serie de funciones que también nos facilitan el manejo de la información en nuestro proyecto, por lo que es conveniente consultar la documentación al respecto antes de ponernos a programar, no sea que estemos programando una función que ya viene preprogramada en la librería que vamos a usar. Puerto serie Una parte fundamental de nuestro Arduino es el puerto serie. Gracias a él se comunicará con nuestro ordenador y seremos capaces de enviar y recibir información con nuestro Arduino. ¿Existen otras maneras? Sí, pero esta es la que emplearemos a lo largo de este curso para ver qué valores reciben nuestros sensores a través de la pantalla de nuestro ordenador. Para abrir nuestro puerto serie en Arduino necesitaremos hacer click en la lupa que se encuentra en la parte superior derecha de nuestro sketch: Si tenemos nuestra placa de Arduino conectada, se nos abrirá esta ventana: Pero si no, nos dará un error similar a este:  Existen ciertos parámetros que podemos modificar en la ventana de nuestro puerto serie, dependiendo de a qué velocidad o baudios nos tengamos que comunicar con nuestro Arduino. En los proyectos de este curso no será necesario modificar nada, porque emplearemos los 9600 baudios que aparecen por defecto. FUENTES: Programación imperativa y programación declarativa: https://www.cs.us.es/cursos/pd/temas/T1_Introduccion_PD_PF.pdf Imagen diagrama de flujo: https://c.pxhere.com/photos/cc/97/mark_marker_hand_leave_production_planning_control_organizational_structure_work_process-774947.jpg!d Analogwrite(): https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/ Sentencia for en Arduino y ejemplo: https://www.arduino.cc/reference/en/language/structure/control-structure/for/ Sentencia while en Arduino y ejemplo: https://www.arduino.cc/reference/en/language/structure/control-structure/while/ Cerrada Somolinos, J. A., & Collado Machuca, M. E. (2015). Fundamentos de programación . Editorial Universitaria Ramón Areces : UNED. Puerto serie: https://www.luisllamas.es/arduino-puerto-serie/ Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Práctica 2.1: Encendemos un LED... de otra manera En este punto, somos capaces de encender el LED que se encuentra en nuestro propio Arduino. También conocemos una serie de sensores y actuadores que podemos conectar a nuestra placa y las estructuras básicas para poder programarla. Ha llegado el momento, entonces, de comenzar a conectar algo físicamente a nuestro Arduino. ¿Con cables? Pues no precisamente... Coser conexiones La forma tradicional de crear circuitos consiste en utilizar cables, pero lo que vamos a hacer en esta práctica es sustituir los cables por hilo conductor . Esto nos va a permitir que nuestros circuitos sean menos rígidos y sea más fácil insertarlos en materiales como la tela. Aunque en este caso no vamos a usar cables, es necesario que cuando hacemos un circuito, antes de soldar las conexiones, utilicemos una protoboard y cables con diferente entradas (macho-hembra, hembra-hembra, macho-macho) dependiendo del tipo de Arduino que estemos utilizando y del tipo de sensor. Una protoboard tiene un aspecto así: Existen protoboards de diferentes tamaños, más alargadas o más cuadradas. Dependiendo del circuito que vayamos a construir, necesitaremos una u otra. Un ejemplo de los cables que se usan con una protoboard los encontramos en esta imagen: Volviendo al hilo conductor que ya hemos mencionado, y que utilizaremos en esta práctica, cabe mencionar que existen diversos tipos. Algunos tienen una textura y consistencia similar a la de la lana, mientras que otros tienen una consistencia más cercana al alambre, aunque más fino y maleable. La desventaja que presenta el hilo conductor frente a los cables, es que en el caso de los hilos muy finos, pueden perder conductividad con el tiempo. Aparte de eso, algunos, como los que tienen tacto lanoso, pueden deshilarse y eso nos puede generar cortocircuitos. Por ello, es importante manejarlos con cuidado y teniendo presente que a través de ellos va a circular corriente eléctrica. Si vemos que alguno de nuestros circuitos realizado con hilo conductor presenta alteraciones, será necesario arreglarlo antes de encenderlo. Probando, probando.... En un circuito en el que vamos a usar hilo en lugar de cables, una de las opciones para probar nuestro circuito, en lugar de usar protoboard, es emplear unos cables con pinzas en sus extremos conocidos comúnmente como cocodrilos . Es importante utilizarlos antes de coser nuestro circuito definitivamente. Un instrumento esencial a la hora de crear circuitos es un multímetro . En este curso, los circuitos que vamos a construir son muy sencillos y no será imprescindible tener uno, pero sí que es recomendable tener un multímetro cerca para probar las conexiones antes de poner a funcionar un circuito. Comenzamos con el circuito Para comenzar a construir nuestro circuito para poder encender un LED, lo primero que necesitaremos es tener una lista con los materiales que vamos a utilizar: Arduino Nano 33 IoT 2 Cocodrilos 1 LED cosible 1 cable micro USB El aspecto del LED cosible es el siguiente: Los orificios de los laterales son los que coseremos a nuestro circuito. El orificio que en la imagen superior se encuentra a la izquierda y que va acompañado del signo + lo tendremos que conectar al pin de nuestro Arduino que le dará la señal de encendido o apagado. El orificio de la derecha, acompañado por un signo - , lo tendremos que coser al pin de nuestro Arduino en el que aparecen escritas las letras GND . Si observamos nuestro Arduino, veremos que en ambos laterales aparecen pines con las letras GND. Esto es así porque según como diseñemos nuestro circuito, nos puede interesar más utilizar el de un lado o el de otro. Como verás a continuación, he utilizado uno de los pines digitales y el pin de GND del lado contrario para evitar que al coser el circuito se crucen las costuras: El código necesario /* LED parpadeante Basado en el ejemplo proporcionado desde el IDE de Arduino 'Blink'. This example code is in the public domain. https://www.arduino.cc/en/Tutorial/BuiltInExamples/Blink */ int pinLED = 3; // the setup function runs once when you press reset or power the board void setup() { // Hemos modificado el número del pin, escribiendo el número del pin al que coseremos nuestro LED pinMode(pinLED, OUTPUT); } // the loop function runs over and over again forever void loop() { digitalWrite(pinLED, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(pinLED, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second } En mi caso, he decidido conectar el LED al pin digital número 3 (D3) Para ello, se ha sustituido la palabra LED_BUILTIN por pinLED . A esta variable, le he dado el valor 3 en la parte superior, antes del void setup() ¿Podría haber escrito el número 3 directamente en lugar de crear una variable? Sí, pero imagina que en lugar de utilizar el pin número 3, tienes que cambiarlo por el pin 5. En este caso, no sería una tarea muy tediosa tener que sustituir el 3 por el 5, pero si tuviésemos muchas líneas de código, podría llegar a ser más costoso tener que sustituirlo en todas, por lo que se considera como una buena práctica emplear una variable que guarde el valor del pin y así, si decidimos variar ese número, solo será necesario sustituirlo una vez, escribiendo int pinLED = 5 ; en lugar de int pinLED = 3; ¿Cómo lo cosemos? Hemos de tener cuidado con los hilos sueltos y con las conexiones. Es muy importante evitar cortocircuitos, o nuestro Arduino comenzará a echar humo y lo podemos estropear. Resultado final Esto es algo parecido a lo que tendremos que obtener una vez realicemos la práctica. ¿Qué tenemos que presentar? Lo único que tenemos que presentar es un video grabado con nuestro móvil, similar al que encontramos en el apartado anterior. En tu caso tendrás que conectar dos LED (en lugar de uno) y  darles diferente frecuencia de iluminación, alternarlos , etc... Piensa en las variaciones del código que tendrás que introducir (variables pinLED1, pinLED2...) Por ello, antes de realizarlo, será necesario que comentéis con la tutora cómo pensáis hacerlo, para aseguraros de que las conexiones están bien y que funcionará correctamente. FUENTES: Protoboard imagen: https://i.stack.imgur.com/CdvOQ.jpg Cables imagen: http://i.stack.imgur.com/y7eu5.jpg Cocodrilo imagen: https://www.brainpad.com/wp-content/uploads/2019/12/alligatorClip-1.jpg Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Práctica 2.2: Detectamos el movimiento y la posición de nuestro Arduino Nuestro Nano 33 IoT fue el Arduino elegido porque, aparte de tener un tamaño bastante reducido y permitirnos realizar proyectos que incluyesen el internet de las cosas (IoT), lleva integrado un módulo que nos permite medir la posición relativa de nuestro microcontrolador. Este tipo de módulos reciben el nombre de IMU o Inertial Measurement Unit. En el caso de nuestro microcontrolador, el IMU que contiene es el LSM6DS3. Lo encontramos aquí: Este sensor hace uso de acelerómetros y giroscopios para calcular esa posición relativa. Un acelerómetro se encarga de medir los cambios en la velocidad de un objeto mientras que un giroscopio mide los cambios en la rotación. Ambos permiten detectar el movimiento rotacional en 3 ejes y que en nuestro ejemplo lo traduciremos a los cambios producidos en dos direcciones: de izquierda a derecha y de arriba a abajo. La librería del LSM6DS3 Como ya comentábamos en la página anterior, las librerías nos van a facilitar las cosas a la hora de trabajar con ciertos sensores, y en esta práctica vamos a hacer uso de una de ellas. Para instalarla vamos a seguir los siguientes pasos: 1. En la parte superior de la IDE de Arduino iremos a Programa > Incluir Librería > Administrar Bibliotecas 2. Se nos abrirá una nueva ventana en la que nos aparecerán todas las librerías disponibles ordenadas alfabéticamente 3. En la parte superior derecha de esta ventana, escribiremos LSM6DS3 4. La primera que nos aparecerá será Arduino_LSM6DS3 y nos dará la opción de instalarla. En la imagen superior me aparece como ya instalada, pero si es la primera vez que realizáis este proceso os la permitirá instalar. Una vez seguidos estos pasos, la librería ya está incluida en la IDE de Arduino, lista para ser incluida en los proyectos que la necesitemos. Y... ¿cómo la incluimos? Aunque para esta práctica, vamos a utilizar un sketch en el que ya aparece incluida, vamos a abrir un sketch en blanco para ver el proceso. 1. Abrimos un nuevo sketch de Arduino en blanco en Archivo > Nuevo . 2. Vamos a Programa > Incluir Librería > Arduino LSMD6DS3. 3. Veremos que en la primera línea de nuestro sketch aparece #include . Esa sentencia le indica a nuestro programa que tiene que hacer uso, #include , de la librería cuyo nombre se encuentra entre los símbolos < > . Este archivo en blanco no lo guardaremos, solamente lo hemos usado para ver cómo se incluye una librería. A continuación veremos el código que emplearemos en esta práctica y qué hace cada una de sus líneas. Cómo calcular la posición relativa El código que vamos a utilizar en esta práctica se corresponde a uno de los ejemplos que acompañan a la librería de nuestro IMU, con ligeras modificaciones. Primero lo explicamos y luego ya podrás comprobarlo tú. /* Arduino LSM6DS3 - Accelerometer Application This example reads the acceleration values as relative direction and degrees, from the LSM6DS3 sensor and prints them to the Serial Monitor or Serial Plotter. The circuit: - Arduino Nano 33 IoT Created by Riccardo Rizzo Modified by Jose García 27 Nov 2020 This example code is in the public domain. */ Esta primera parte es un comentario. Como ya hemos visto al principio de todos los programas, se utiliza para indicar la finalidad del algoritmo, el autor y aquellas especificaciones que el autor crea convenientes. Como vemos en la última línea, el código se encuentra en el dominio público, lo que significa que podemos utilizarlo y modificarlo libremente en nuestros proyectos. La siguiente línea que nos encontramos es la que ya hemos visto y que se refiere a la inclusión de la librería en nuestro sketch: #include Posteriormente, antes de comenzar a escribir nuestros bucles void setup() y void loop() encontramos las variables que utilizaremos en nuestro programa. La primera línea nos dice que vamos a tener 3 variables del tipo float (decimal) que van a ser x, y, z . A esas tres variables no les hemos asignado un valor inicial. En cambio, a las dos siguiente, que son del tipo int (entero), sí que les hemos asignado el valor 0. Es decir, nuestro IMU se va a considerar que comienza su movimiento en 0 grados respecto al eje X e Y: float x, y, z; int degreesX = 0; int degreesY = 0; Lo próximo que nos encontramos es la ya conocida llamada a void setup() En ella inicializaremos aquellos procesos que solamente han de ejecutarse una vez. El primero será el puerto serie, sobre el que ya hablamos en este apartado anterior. Iniciaremos la comunicación en serie con Serial.begin(9600) . Seguido a ello, tenemos un bucle while, lo que nos dice este bucle es: "mientras que el Serial no reciba información, entra en bucle y no hagas nada, solo espera a que se establezca conexión a través del puerto serie". El signo de exclamación ! significa NOT , es la negación para nuestro Arduino. Por lo tanto, while (!serial) es lo mismo que while(serial NOT true) es lo mismo que while(serial==false). Con nuestro NANO, no deberíamos tener problema, ni entrar en ese bucle while y deberíamos rápidamente ver en nuestro monitor serie la palabra " Started ". void setup() { Serial.begin(9600); while (!Serial); Serial.println("Started"); A continuación encontramos un condicional en el que se indica qué hacer en caso que nuestro IMU no esté enviando información. Al igual que con el puerto serie, comprobamos si nuestro IMU ha iniciado su actividad. Si no ha sido así, imprimiremos por pantalla que ha fallado. Si todo ha salido bien y nuestro Arduino se comunica perfectamente con nuestro ordenador a través del puerto serie, nuestro programa imprimirá por el puerto serie la velocidad de muestreo de nuestro IMU: if (!IMU.begin()) { Serial.println("Failed to initialize IMU!"); } Serial.print("Accelerometer sample rate = "); Serial.print(IMU.accelerationSampleRate()); Serial.println("Hz"); Ahora que ya hemos establecido la comunicación correctamente, ha llegado el momento de averiguar la posición relativa. Esto lo vamos a lograr haciendo uso de unas cuantas sentencias condicionales if dentro del bucle void loop() . La primera de ellas va a depender de si existe aceleración, es decir si ha habido un cambio de posición a algún punto. Eso lo conseguimos con la función accelerationAvailable(), que acompaña a nuestra palabra reservada IMU. Si dicha aceleración existe, leeremos esa aceleración en los tres ejes, x, y, z: void loop() { if (IMU.accelerationAvailable()) { IMU.readAcceleration(x, y, z); } A continuación, lo que nos queda por hacer es realizar los cálculos y transformaciones para obtener los grados que se está moviendo nuestro IMU. Existen cuatro bloques if que se encargan de ello, dos para el eje X y dos para el eje Y. Nos limitaremos a comentar los dos referentes al bloque X, porque los del bloque Y son similares. En el primer bloque if nos encontramos con la condición de que exista una variación en X mayor que 0.1, que sería lo mínimo perceptible para nuestro sensor. Si esto ocurre, multiplicaremos ese valor de x por 100 y realizaremos un mapeo de estos valores. ¿Cómo? Empleando la función map() , la cual se encarga de mapear un valor de un rango a otro. La estructura de esta función sería: map(valor, valorInferiorInicial, valorSuperiorInicial, valorInferiorFinal, valorSuperiorFinal) Por lo que estaríamos mapeando el valor de x desde el valor inicial 0 al 97, que son los valores que nos da el IMU, hasta los valores en grados 0 y 90; es decir, que la inclinación que vamos a conseguir abarcará desde los 0 a los 90 grados. Lo mismo haremos si la x varía de forma negativa -0.1, eso significará que lo inclinamos hacia el lado contrario. En este caso el mapeo irá de los valores 0 y -100 hasta el 0 y 90 grados. Visto cómo funciona en el eje x, no se considera necesario explicar lo que sucede con eje Y, ya que es exactamente igual: if (x > 0.1) { x = 100 * x; degreesX = map(x, 0, 97, 0, 90); Serial.print("Tilting up "); Serial.print(degreesX); Serial.println(" degrees"); } if (x < -0.1) { x = 100 * x; degreesX = map(x, 0, -100, 0, 90); Serial.print("Tilting down "); Serial.print(degreesX); Serial.println(" degrees"); } if (y > 0.1) { y = 100 * y; degreesY = map(y, 0, 97, 0, 90); Serial.print("Tilting left "); Serial.print(degreesY); Serial.println(" degrees"); } if (y < -0.1) { y = 100 * y; degreesY = map(y, 0, -100, 0, 90); Serial.print("Tilting right "); Serial.print(degreesY); Serial.println(" degrees"); } La última sentencia que nos encontramos es: delay(1000); En ella le decimos a nuestro programa que se detenga durante un segundo, con la función delay() de la que ya habíamos hablado. El código completo lo puedes copiar de aquí y pegarlo en un nuevo sketch de Arduino para poder probarlo: /* Arduino LSM6DS3 - Accelerometer Application This example reads the acceleration values as relative direction and degrees, from the LSM6DS3 sensor and prints them to the Serial Monitor or Serial Plotter. The circuit: - Arduino Nano 33 IoT Created by Riccardo Rizzo Modified by Jose García 27 Nov 2020 This example code is in the public domain. */ #include float x, y, z; int degreesX = 0; int degreesY = 0; void setup() { Serial.begin(9600); while (!Serial); Serial.println("Started"); if (!IMU.begin()) { Serial.println("Failed to initialize IMU!"); } Serial.print("Accelerometer sample rate = "); Serial.print(IMU.accelerationSampleRate()); Serial.println("Hz"); } void loop() { if (IMU.accelerationAvailable()) { IMU.readAcceleration(x, y, z); } if (x > 0.1) { x = 100 * x; degreesX = map(x, 0, 97, 0, 90); Serial.print("Tilting up "); Serial.print(degreesX); Serial.println(" degrees"); } if (x < -0.1) { x = 100 * x; degreesX = map(x, 0, -100, 0, 90); Serial.print("Tilting down "); Serial.print(degreesX); Serial.println(" degrees"); } if (y > 0.1) { y = 100 * y; degreesY = map(y, 0, 97, 0, 90); Serial.print("Tilting left "); Serial.print(degreesY); Serial.println(" degrees"); } if (y < -0.1) { y = 100 * y; degreesY = map(y, 0, -100, 0, 90); Serial.print("Tilting right "); Serial.print(degreesY); Serial.println(" degrees"); } delay(1000); } Para obtener los valores correctos es necesario sujetar el Arduino en esta posición y posteriormente inclinarlo de manera lateral y frontal, veremos cómo los valores cambian en la ventana de nuestro puerto serie: Pues a mí no me funciona... ¿qué puede haber salido mal? Puede que... 1.  Hayamos conectado nuestro Arduino al puerto incorrecto del ordenador. 2. No esté bien conectado el cable. 3. No hayamos copiado el código completo. 4. No hayamos colocado nuestro Arduino en la posición inicial correctamente, por lo que podemos cerrar la ventana del puerto serie, volver a subir el código y comenzar con el Arduino en posición horizontal y con la zona del USB más cerca de nosotros. ¿Qué tenemos que presentar? Lo único que tenemos que presentar es un video grabado con nuestro móvil en el que se vean los movimientos de nuestro Arduino y el puerto serie abierto en el que se vea la variación de los valores en los ejes X e Y. Para ello sigue las instrucciones de la tarea correspondiente del curso. FUENTE: Tutorial sobre Nano 33 IoT y acelerómetro: https://docs.arduino.cc/tutorials/nano-33-iot/imu-accelerometer Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Práctica 2.3: ¿Cuánta luz hay aquí? Ha llegado el momento de que veamos un nuevo sensor, el cual resulta interesante tanto por la facilidad de su uso como por su reducido coste. Existen diferentes versiones, como podemos ver en este apartado ,  ya debería sonarte porque lo vimos hace solo unas páginas. Para esta práctica, vamos a utlizar la versión sencilla, directamente la fotorresistencia, ya que al estar trabajando alrededor de la idea de construir un vestible, algo que podamos llevar puesto, es necesario que nuestros proyectos sean lo menos aparatosos posible. Bueno, o no, dependerá de qué tipo de proyecto queramos hacer... Antes de empezar, ¿qué es un divisor de voltaje? Ya hemos visto que para trabajar con Arduino, son necesarias una serie de estructuras de programación. Aparte de eso, a veces vamos a necesitar ciertos componentes que permitan leer los valores de nuestros sensores. La mayor parte de los sensores que utilizamos con Arduino son plug-and-play, es decir, no necesitan nada extra para funcionar, pero, en ocasiones, necesitaremos alguna cosilla extra. Ese es el caso de nuestra fotorresistencia. Para poder leer esa variación en la fotorresistencia que se produce cuando aumenta o disminuye la luz, necesitaremos conectar una resistencia extra que funcionará como divisor de voltaje . Esta resistencia también podría ser un potenciómetro, o lo que es lo mismo, una resistencia con un valor variable que podemos ajustar. Con un divisor de voltaje, seremos capaces de obtener a partir de la variación en la resistencia, una variación en el voltaje que será lo que lea nuestro Arduino a través del pin que configuremos como entrada. Para saber más sobre divisores de voltaje puedes visitar esta página . Materiales Para realizar esta práctica necesitaremos: 1. Nuestro Arduino Nano 33 IoT 2. 3 Cables macho-macho . ¿Por qué se llaman así? pues porque ambos extremos se insertan en alguna parte. Existen también cables macho-hembra y hembra-hembra, los cuales son útiles dependiendo del tipo de pines que tengan tanto el microcontrolador como los sensores y actuadores que usemos. 3. 1 resistencia de 10KOhm que funcionará como divisor de voltaje . 4. Cable microUSB para conectar nuestro Arduino. 5. La fotorresistencia . En la imagen superior podemos ver la colocación de los cables macho en nuestro Arduino. Realmente esta no es la manera más correcta de realizar las conexiones. Lo correcto sería soldar unos pines en nuestro Arduino, pero como necesitaremos los agujeritos para coserlos despues, introduciremos los cables como se ve en la siguiente imagen: Estableciendo la conexión Las conexiones que tenemos que realizar son las siguientes: Para realizar este circuito se ha utilizado Tinkercad , una aplicación online nos permite diseñar circuitos de una manera visual. También podríamos haberlo hecho usando Fritzing, otra aplicación de código abierto que también tiene versión de escritorio. En este caso la versión de escritorio requiere de un pago/donación (8€), si bien una versión anterior está disponible para los equipos Vitalinux a través de Vitalinux Play. Ya te habrás dado cuenta de que el Arduino que aparece en la imagen no es el NANO 33, pero los pines a los que has de conectar los cables son los mismos. Ahí vemos que estamos empleando 3 pines: A0: va desde ahí hasta una pata de nuestra resistencia, la cual está conectada a una pata de la fotorresistencia. 3.3V: va desde ahí hasta la pata de la fotorresistencia que no está conectada a la resistencia. GND: va desde ahí hasta la pata de la resistencia que no está conectada a nada. Tenemos que tener cuidado con varios aspectos a la hora de realizar las conexiones en nuestra protoboard. El más importante es que todos esos puntitos están conectados unos con otros en línea. Es decir, en la posición en la que está colocada la protoboard de la imagen superior, los puntos están conectados en líneas verticales ( pistas ), de arriba a abajo, pero no de forma horizontal. Eso es así para las líneas centrales pero no para  las líneas roja y negra señalizadas con el símbolo + y - respectivamente ( buses ), las cuales están conectadas de izquierda a derecha, si mantenemos la posición de la protoboard de la imagen de arriba. Por tanto, vemos que nuestro cable negro está conectado a uno de los extremos de nuestra resistencia, mientras que el otro extremo se conecta a un extremo de la fotorresistencia y al pin A0 de nuestro Arduino. Para más información sobre las conexiones en pistas y buses en una protoboard consultar aquí . Una vez hemos terminado nuestro circuito va a llegar el momento de ver el código que necesitaremos para que funcione: /* * Created by ArduinoGetStarted.com * * This example code is in the public domain * * Tutorial page: https://arduinogetstarted.com/tutorials/arduino-light-sensor * Modificado por Marta Pérez */ void setup() { // comienza la comunicación del puerto serie en 9600 bits por segundo: Serial.begin(9600); } void loop() { // Lee el valor de A0 (entre 0 y 1023) int analogValue = analogRead(A0); Serial.print("Lectura analógica: "); Serial.print(analogValue); // lectura del valor analógico obtenido // Definiremos los umbrales dependiendo de la cantidad de luz recibida if (analogValue < 10) { Serial.println(" - Oscuro"); } else if (analogValue < 200) { Serial.println(" - Tenue"); } else if (analogValue < 500) { Serial.println(" - Iluminado"); } else if (analogValue < 800) { Serial.println(" - Bastante iluminado"); } else { Serial.println(" - Mucha luz"); } delay(500); } En la práctica anterior se ha explicado línea a línea. En este caso al ser un código compuesto por condicionales en su mayoría,  no se ha considerado necesario explicar este código línea a línea. El resultado que obtenemos con el código superior es: De la protoboard a la tela El próximo paso es trasladar nuestro circuito desde la protoboard a la tela. Para ello será necesario modificar levemente tanto la resistencia como nuestro fotorresistencia, para que adquieran el siguiente aspecto: Para modificarlos, una manera sencilla de hacerlo es enrollar los extremos alrededor de la punta de un lápiz. Una vez los tengamos así, podemos comenzar a coserlos a nuestro trozo de tela, para obtener algo parecido a esto. Ciertas cosas a tener en cuenta... 1. Cuando cosemos circuitos, es necesario que tengamos en cuenta que la corriente no se transmite igual de bien que si estuviésemos usando un cable , por lo que si el hilo que empleamos es demasiado fino, puede que sea necesario que realicemos varias costuras en lugar de una, para hacer que el hilo sea más grueso y se transmita mejor la electricidad.  Tenemos que tener en cuenta que, con el tiempo, la conductividad del hilo se va perdiendo al estar expuesto a la intemperie, no como un cable que está protegido por plástico. 2.  Es muy importante que cortemos todos los hilos largos que se crean al hacer los nudos, ya que si, por ejemplo se tocan el hilo que va GND y el que va a 3.3V tendremos un cortocircuito que puede, a parte de hacer que salga algo de humo, llegar a romper nuestro Arduino.  Un buen sustituto para realizar conexiones en nuestros wearables que se encuentra a medio camino entre los cables y el hilo conductor es el hilo de cobre esmaltado. Se trata de unos filamentos de cobre que pueden llegar a ser bastante finos, aunque no tanto como el hilo, los cuales se encuentran cubiertos de una capa aislante. Estos pueden usarse a modo de hilo si tenemos una aguja con un ojal lo suficientemente grande, o si no, podemos coserlos con hilo no conductor a la tela. Al ser más finos que los cables, es más fácil disimularlos en un vestible. ¿Qué tenemos que presentar? En este caso será suficiente con que me envíes un gif o enlace al video con el circuito hecho en la protoboard en el que se vea también la medición del sensor en el puerto serie, similar al video que aparece al final del apartado "Estableciendo la conexión". Sigue las instrucciones descritas en la tarea moodle del curso. No es obligatorio coser el circuito, pero si lo haces, puedes enviármelo o comentarme cualquier duda o dificultad que te haya surgido. FUENTES: Arduino y sensor lumínico: https://arduinogetstarted.com/tutorials/arduino-light-sensor Divisor de voltaje: https://mielectronicafacil.com/analisis-de-circuitos/divisor-de-voltaje/#potenciometros Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Práctica 2.4: Sensor + LED En esta última práctica del bloque 2 se propone que escojas entre el IMU y el sensor lumínico , que ya hemos probado y demostrado su funcionamiento, para controlar la luminosidad de un LED . Es decir, un programa que en función o de la luz o del movimiento que perciba en su entorno, accione una luz. ¿Qué tenemos que tener en cuenta? Será necesario que creemos un contexto para nuestro proyecto. No sirve con únicamente elegir los sensores y crear un circuito, sino que debemos tratar de resolver un problema o plantear una pregunta, una reflexión sobre una determinada situación , al igual que sucedía con los vestibles que hemos visto en este apartado y en este . Eso es a lo que se refiere la LOMLOE cuando habla de trabajar sobre situaciones de aprendizaje. Algo que podría ser interesante, pero no es obligatorio, es que el proyecto este pensado para que luego lo puedan realizar vuestros alumnos. Es aconsejable que cuando tengáis una idea, busquéis en internet si se ha realizado algo parecido, porque quizá nos puede dar ideas sobre como realizar las conexiónes y cómo escribir el código. Existen gran cantidad de proyectos y tutoriales en internet que podemos utilizar, mezclar, recombinar, para nuestros propios proyectos. ¿Qué tenemos que presentar? Esta práctica la desarrollaremos en dos etapas . En la primera será necesario presentar la idea en un texto escrito de no más de 100 palabras y un boceto del circuito que se plantea construir. La segunda consistirá en un video en el que se vea el proyecto realizado y su funcionamiento, junto con una memoria de no más de 4 páginas con los siguientes apartados: 1. Título del proyecto 2. Objetivos 3. Explicación del proyecto 4. Circuito (se recomienda utilizar Fritzing o Tinkercad ) Y, ¡no olvides el video! Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU