Microcontroladores vestibles y conectados a internet 0. Introducción ¿Qué vamos a hacer en este curso? ¡Bienvenidxs! En este curso vamos a trabajar con un microcontrolador perteneciente a la familia más famosa de todos ellos: Arduino . Antes de comenzar a utlizarlo, tendremos que saber qué es exactamente un microcontrolador, por qué vamos a necesitar uno si queremos crear un proyecto con elementos interactivos, y también veremos ejemplos de otros proyectos pertenecientes a los ámbitos tanto artístico como educativo que nos puedan dar alguna pista e inspirarnos para aplicar en el aula lo aprendido en este curso. No será necesario que conozcamos en profundidad cómo funciona un microcontrolador, pero sí que será muy importante que entendamos cómo funciona antes de integrarlo en un proyecto.  Inténtalo, inténtalo de nuevo... Una vez tengamos claro qué es (y qué no es) un microcontrolador, veremos la diferencia entre sensores y actuadores y comenzaremos a utilizar nuestro Arduino para poder llevar a la práctica todo lo que vamos aprendiendo. Sobre todo, es muy importante tener en cuenta algo (que repetiré más veces a lo largo de este curso) y es que las cosas puede que no nos funcionen a la primera. Algo que vamos a aprender en este curso va a ser a desarrollar nuestra paciencia y a no desesperarnos cuando algo no funcione y no sepamos el por qué. Nos va a pasar muchas veces y es algo normal. Bueno, quizá esa imagen ha sido demasiado dramática, pero es posible que a veces no sepamos muy bien por qué no nos funcionan las cosas cuando estamos utilizando nuestro Arduino y será el momento de REVISAR, Y VOLVER A REVISAR , hasta que encontremos el fallo. Otras veces, será suficiente con que reiniciemos el ordenador. Buscando la interconexión Una vez nos hayamos familiarizado con nuestro querido Arduino y hayamos conectado y desconectado nuestros sensores y actuadores; el próximo paso será conectarlo a internet y enviar la información con la que trabaja Arduino a la nube . Para ello utilizaremos la plataforma Arduino IoT Cloud. Bueno, ¿qué tal si empezamos..? FUENTES: Imagen 1: Photo by Vishnu Mohanan on Unsplash Imagen 2: Photo by Stormseeker on Unsplash Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Materiales del Kit Cada set contiene: Arduino Nano 33 IoT:   Cable microUSB a USB 2 LED Lilypad 1 fotorresistencia simple (LDR) 2  res istencias de 10kOhm 1 Protoboard Cables macho-macho (10) Cocodrilos (10) 250-300 cm de hilo Conductor (aprox) Además para realizar el curso el alumnado deberá aportar por su parte Hilo normal Aguja Tela (~50x50cm) Aquí tenéis un presupuesto estimado y enlaces donde comprar, por si os planteáis reproducirlo en el aula con el alumnado. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Relación de los contenidos con la LOMLOE Los principios metodológicos en los que se apoya esta formación son el fomento de la creatividad, preparación para la resolución de problemas en contextos reales y la inclusión  de tecnologías digitales como medio para que explorar las posibilidades para aprender, comunicarse y realizar creaciones propias. En la nueva normativa educativa publicada el año 2022 se impulsa de forma decisiva la enseñanza de contenidos relacionados con la programación y robótica tanto desde las primeras etapas como por supuesto en Secundaria y Bachillerato. También es decidido el impuso a las tecnologías emergentes y la interconexión de dispositivos. En concreto los contenidos abordados en este curso corresponden a: La temática de vestibles (o tal y como aparecen en la ley, wearables ) se cita en la ORDEN ECD/1172/2022, de 2 de agosto de Currículo en Secundaria Obligatoria, en las materias optativas de Digitalización (4º de ESO) y Programación y Robótica (3º de ESO). En la materia de 4º aparecen dentro de los Saberes básicos, en el Bloque A. Dispositivos digitales, sistemas operativos y de comunicación, como ejemplo de dispositivos conectados, configuración y conexión. En la materia optativa autonómica de 3º se cita el conocimiento de los vestibles e internet de las cosas también en los Saberes básicos dentro del Bloque C. Pensamiento computacional, programación y robótica , como ejemplo de sistemas de control programado, montaje físico, uso de simuladores y programación sencilla de dispositivos. En el currículo de Bachillerato, si bien no aparece el término citado expresamente en la ORDEN ECD/1173/2022, de 3 de agosto, en concreto en los Saberes Básicos de la materia de Tecnología e Ingeniería hay dos Bloques, uno dedicado a Sistemas Informáticos y otro a Saberes Automáticos, donde se especifica la necesidad del abordaje de proyectos que partan de objetos reales próximos, y que integren conocimientos informáticos y electrónicos, lo que pensamos que encaja perfectamente con el contenido del curso. Si nos referimos a la temática del Internet de las Cosas (IoT), el currículo de Educación Secundaria Obligatoria lo cita en numerosas ocasiones, en concreto en las materias de Tecnología y Digitalización (3ºESO), Programación y Robótica (3º de ESO), Digitalización (4º) y Tecnología (4º) Lo hace dentro de sus Competencias Específicas: es el caso de la CE.PR.4 Desarrollar algoritmos y aplicaciones informáticas en distintos entornos, aplicando los principios del pensamiento computacional e incorporando las tecnologías emergentes, para crear soluciones a problemas concretos, automatizar procesos y aplicarlos en sistemas de control o en robótica. o la CE.T.4 Desarrollar soluciones automatizadas a problemas planteados, aplicando los conocimientos necesarios e incorporando tecnologías emergentes, para diseñar y construir sistemas de control programables y robóticos.  También aparece en los Saberes Básicos del Bloque C. Pensamiento computacional, programación y robótica , presente en todas ellas.  En el currículo de Bachillerato, aparte de los Bloques E y F de Saberes Básicos de las materias de Tecnología e Ingeniería (I y II) ya citados anteriormente, también está presente en las materias de Informática (I y II)  en el Bloque D. Datos de los Saberes Básicos, e incluso se ejemplifica una situación de aprendizaje con esta temática. Si atendemos al concepto de creaciones artísticas , aparecen en la materia de Educación Plástica, Visual y Audiovisual relacionadas con este curso las siguientes competencias específicas: La CE.EPVA.5 y CE.EPVA.7. La CE.EPVA.5 habla de r ealizar producciones artísticas con creatividad seleccionando y  aplicando herramientas, técnicas y soportes en función de la intencionalidad .La  CE.EPVA.7 consiste  en   aplicar técnicas, recursos de los lenguajes artísticos, e incorporar de forma creativa, las posibilidades que ofrecen las diversas tecnologías, para integrarlos y enriquecer el diseño y la realización de un proyecto artístico. También en la materia de Expresión Artística de 4º de ESO se relaciona con la  CE.EA.4 que consiste en la creación de  producciones artísticas, realizadas con diferentes técnicas y herramientas.  Por último, la ley hace especial énfasis en el carácter competencial de los aprendizajes , y en la conveniencia de enmarcarlos en situaciones de aprendizaje concretas que permitan ver su aplicabilidad, su conexión con la vida real, y la resolución de problemas. Por todo ello, tanto los ejemplos descritos en el curso como las tareas a realizar hacen hincapié no solo en el manejo de componentes y de un software, sino en la contextualización de los mismos mediante la presentación de memorias documentales. El hecho de que diferentes materias asociadas a diferentes departamentos estén relacionadas con los contenidos del curso también abre posibilidades a trabajar de forma interdisciplinar , constituyéndose en oportunidad para la creación de situaciones de aprendizaje que involucren enseñanzas de diferentes áreas, y que incrementen la significatividad de lo aprendido, favoreciendo la colaboración no solo del alumnado sino entre docentes. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU 1. Toma de contacto En esta primera parte se realizará una introducción teórico práctica a Arduino y a los vestibles, asentando las bases sobre las que se apoyarán los siguientes bloques del taller. Comenzamos: Microcontroladores ¿Qué es un microcontrolador? Un microcontrolador es un "microordenador" en un chip. Tiene una CPU, RAM (memoria de acceso aleatorio), registros de funciones especiales, memoria ROM de programa, memoria ROM de datos, de uno a varios puertos paralelos de E/S (entrada/salida), y puede tener una gran cantidad de periféricos en el chip que incluyen, pero no se limitan, a un convertidor analógico-digital (ADC), un convertidor digital-analógico (DAC), una UART serie, uno o varios temporizadores, comparadores/referencia de tensión en el chip, módulo de captura/comparación/PWM (Pulse Width Modulation), puerto serie síncrono maestro para comunicaciones SPI (Serial Peripheral Interface)/I2C (Inter Integrated Circuit), puerto USB, puerto ethernet, osciladores en el chip, junto con una serie de otros periféricos.  Todo esto nos puede parecer farragoso en un primer momento, pero si lo vemos con imágenes, aplicado a un ejemplo de Arduino en concreto y os lo voy comentando, lo vamos a acabar entendiendo perfectamente. Espera un segundo, pero ¿Arduino es un microcontrolador? Aunque utilicemos Arduino y microcontrolador como sinónimos, Arduino en realidad es una plataforma de desarrollo que entre otros componentes, contiene un microcontrolador. Junto a este microcontrolador encontraremos una serie de entradas y salidas que nos permitirán añadir interactividad a nuestros proyectos, empleando los sensores y actuadores que hemos mencionado en la página del kit. El nacimiento y propósito de los Arduinos Aquí no vamos a hablar de quiénes o cuándo crearon Arduino, ya que eso lo podemos encontrar fácilmente en este enlace (el cual os aconsejo leer) En cambio, sí que vamos a hablar del propósito inicial con el que fue creado: facilitar la comunicación entre un microcontrolador y otros dispositivos. De esta manera, es sencillo incentivar el desarrollo de procesos creativos y el diseño de proyectos tanto a  personas de una edad temprana, como a aquellas que sin tener conocimientos amplios de informática o electrónica quieran embarcarse a experimentar con proyectos interactivos. El formato de Arduino hace posible que podamos adentrarnos en la electrónica sin sentirnos abrumados con información demasiado técnica. Bueno, a continuación, paso a mostraros la imagen de una placa Arduino: Como podemos ver, la placa Arduino cuenta con muchos componentes dentro de su tarjeta, algunos de los cuales ya hemos mencionado en la cita que abre esta página. No voy a entrar a explicar cada uno de ellos, pero sí los más importantes, los que nos ayudarán a entender cómo funciona un microcontrolador y para qué (y para qué no) lo podemos utilizar. Un buen símil para un Arduino es el de una caja negra . ¿Por qué? Porque no vamos a necesitar conocer el funcionamiento de cada parte para poder utilizarlo. Lo que es importante conocer es que cuenta con componentes que son de entrada, otros procesan la información y otros son de salida.  ____________     ____________ __________ | ENTRADA |-->| PROCESO |-->| SALIDA | A continuación, veremos cuáles son los componentes de entrada, procesamiento y salida sin perder de vista la definición del comienzo de la página.  Partes que debemos conocer Uno de los primeros componentes mencionados es el propio microcontrolador . Y es que, el Arduino en sí ya hemos dicho que no es un microcontrolador, sino una placa de desarrollo. El microcontrolador del Arduino es este: Se llama ATMEGA 328P y es el que tiene el modelo de placa Arduino que estamos viendo en este apartado: el Arduino UNO. Pero claro, existen otros tipos de Arduinos, los cuales cuentan con otros microcontroladores. Cuando lleguemos al apartado en el que os presente el Arduino que utilizaremos en este curso, veréis que el microcontrolador que utiliza es otro y tiene otro aspecto. Para profundizar sobre el ATMEGA328P podéis encontrar más información aquí . Este microcontrolador, como podéis ver, cuenta con una serie de 'patitas'  llamadas pines . (Esta palabra es una de las importantes y la cual vamos a leer en bastantes ocasiones a lo largo de estas páginas). Estos pines son los que nos van a permitir programar, recibir y enviar la información. Para poder acceder al microcontrolador Arduino nos facilita las cosas con una serie de pines de entrada y salida que encontramos en la imagen siguiente: Como podéis comprobar, esos pines se encuentran a ambos lados del ATMEGA 328P, aunque visualmente no parezcan directamente en contacto. Ya veremos qué cables y cómo los tenemos que conectar más adelante... Por el momento, nos quedaremos con que esos pines serán los que tendremos que utilizar para conectar los sensores y actuadores. También veremos que algunas de estas entradas son digitales y otras analógicas, pero de eso nos ocuparemos más adelante... Por tanto, nuestro ATMEGA 328P cuenta con una CPU, RAM (memoria de acceso aleatorio), registros de funciones especiales, memoria ROM de programa, memoria ROM de datos, puertos paralelos de E/S (entrada/salida), etc. Para el tipo de proyecto que vamos a construir, no es necesario preocuparse sobre la ROM ni sobre la RAM, ya que no vamos a escribir programas excesivamente extensos (quizás en el futuro... ). Los componentes que se mencionan en la definición que abre esta página y que sí vamos a necesitar conocer son otros como por ejemplo el puerto USB. En el Arduino UNO, el puerto USB se encuentra aquí: Y el cable que necesitaremos es este, se llama AB USB: Con él, conectaremos nuestro Arduino al ordenador y seremos capaces de programarlo y también de proporcionarle el voltaje necesario para alimentarlo a él y a los sensores que conectemos a él. Tendremos que tener cuidado con qué sensores conectamos, porque algunos de ellos necesitarán más alimentación que la que proporcionamos a nuestro Arduino a través del USB, que son 5V. Algunos sensores y actuadores funcionan a 12V o a voltajes mayores. Para este curso no será una preocupación, porque ninguno de los sensores empleados necesita alimentación extra. No obstante, tendremos que tenerlo en cuenta si en el futuro queremos emplear unos sensores diferentes. Aparte de mediante el puerto USB, es posible alimentar nuestro Arduino UNO utilizando una pila de 9V y un adaptador o un cargador conectado a la corriente con un voltaje de 7 a 12V como máximo. Para saber más sobre las maneras de alimentar nuestro Arduino, puede ser útil este artículo . El lugar al que conectaremos nuestra pila o adaptador es este: Como puedes comprobar, no se han explicado todas las partes que conforman el Arduino UNO. Esto es, porque para los propósitos de este curso no va a ser necesario conocer esta placa en profundidad, sino entender qué función realizan las partes que vamos a utilizar y hacernos una idea general sobre las partes que comparten la mayoría de los Arduinos. En este curso no vamos a utlizar un Arduino UNO, por lo que más adelante veremos las partes que componen el Arduino que emplearemos, y observaremos cómo la mayor parte de ellas son comunes, aunque nuestro Arduino posee alguna función que no encontramos en el Arduino UNO que acabamos de ver. FUENTES: Definición de microcontrolador:   https://www.microcontrollertips.com/a-beginners-guide-to-microcontrollers-faq/ [Consultada el 9 de junio de 2022] Partes del Arduino: https://arduino.cl/principales-partes-de-un-arduino/ [Consultada el 9 de junio de 2022] Imagen ATMEGA328: By oomlout - Flickr: ATMEGA328 - IC-ATM328-01, CC BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=23315198 Imagen AB USB: https://www.arduino.cc/en/Guide/ArduinoUno Fuentes de alimentación para Arduino: https://www.geekfactory.mx/tutoriales-arduino/alimentar-el-arduino-la-guia-definitiva/ Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Os presento al Arduino Nano 33 IoT Como podéis comprobar en la imagen superior, nuestro Arduino Nano 33 IoT tiene un tamaño bastante más reducido que el Arduino UNO que hemos visto hasta ahora. Este reducido tamaño nos va a permitir incluirlo en nuestros proyectos, ya que al ser proyectos vestibles nos interesa poder ocultarlos con facilidad y que no se vean demasiado. De todas formas, si no hemos visto nunca un Arduino UNO, no podemos imaginarnos fácilmente el tamaño real de estos controladores. Nos queda claro que el Arduino 33 IoT es más pequeño que el UNO, pero una imagen que nos va a ayudar a hacernos una idea más aproximada al tamaño real de nuestro Arduino es la siguiente: Un beneficio que presenta el 33 IoT sobre el UNO, es que se vende con los pines sin soldar. ¿Y eso qué significa? ¿Y qué eran los pines? Podemos volver a la página anterior para verlo, pero también os voy a poner una foto de cómo son los conectores (pin headers) que en este Arduino no nos vienen soldados de manera predeterminada: Esos conectores (las dos tiras que aparecen en la parte superior) son los que nos permitirán conectar nuestro Arduino a diferentes sensores y actuadores, pero lo bueno que tiene nuestro 33 IoT es que al venir los pines sin soldar, podemos utilizar los circulitos dorados para coser directamente los sensores, eso sí, con hilo conductor. Si soldásemos los conectores a los pines, nuestro Arduino tendría el siguiente aspecto: ¿Qué diferencia hay entre uno y otro? Pues aparte de que con los pines sin soldar, podemos coser cosas a nuestro Arduino y dado el momento podemos elegir qué tipo de conectores soldar (no, no hay solamente de un tipo), los beneficios terminarían aquí. Por otra parte, tener los pines soldados nos aporta algún beneficio más, por ejemplo el poder realizar conexiones con cables de testeo (jumper wires) y una placa de prototipado (bread board). De esta manera hacer y deshacer un circuito se convierte en algo muy rápido y sencillo. En este curso no vamos a soldar los conectores a los pines, así que no nos preocuparemos más sobre ellos. Partes que debemos conocer Existen ciertas partes de nuestro Arduino que vamos a tener que conocer, mientras que otras no va a ser imprescindible conocerlas. Al igual que ya vimos con el UNO, la parte principal es el microcontrolador . En este caso, el procesador principal es el SAMD21 Arm® Cortex®-M0 de bajo consumo. Lo que nos permite este microcontrolador es que nuestro Arduino pueda funcionar a 3.3V en lugar de a los 5V que funciona el Arduino UNO. Y eso, ¿por qué es importante? En nuestro caso, que vamos a hacer un proyecto vestible, es bastante importante a la hora de alimentar nuestro proyecto. La mayoría de las baterías funcionan a 3.3V, por ejemplo las baterías Li-Po o las pilas de botón. Haz clic sobre el nombre para saber más sobre baterías Lipo y Pilas de botón La fuente de alimentación que recomiendo para nuestros proyectos y el 33IoT es una batería externa (power bank) del mismo tipo que se utilizan para cargar los móviles, pero eso ya lo veremos más adelante. En la siguiente imagen se muestra el microcontrolador de nuestro 33IoT: Este microcontrolador nos proporciona 8 entradas analógicas , las cuales podemos ver en la siguiente imagen numeradas del 0 al 7 (A0...A7).  En el otro lado, encontramos 10 pines digitales de entrada/salid a (D2...D12): Otros pines importantes que vamos a necesitar para nuestros proyectos son el que pone 3.3V y cualquiera de los dos en los que pone GND . Te será fácil localizarlos. Si volvemos a darle la vuelta a nuestro Arduino nos vamos a encontrar algo que ya hemos visto en el UNO, el puerto USB para conectarlo a nuestro ordenador y poder programarlo. En el caso del 22 IoT el puerto USB es un microUSB, lo que nos permitirá fácilmente conectarlo a una power bank cuando llegue el momento. Es importante manejar con cuidado el puerto USB al conectar y desconectar el cable, ya que al sobresalir puede dañarse. Si se daña, no será posible programar nuestro Arduino. Otro componente importante de nuesto Arduino es el botón de reinicio (reset). Este se encuentra muy cerca del microUSB. Si todo va bien, no lo necesitaremos; pero si nuestro programa no responde, tendremos que pulsarlo para reiniciarlo. Los dos siguientes componentes son los que nos van a permitir conectar nuestro Arduino a Internet y el primero de ellos es el que también nos proporcionará Bluetooth®. Este primero es el módulo NINA-W102 (marcado en la imagen siguiente con un cuadrado azul). El  NINA-W102 nos va a permitir establecer una conexión con internet haciendo uso del segundo componente: la antena. Si miramos en la imagen siguiente, es el componente plateado que está colocado justo a la derecha del NINA-W102: Es importante manejar con cuidado la antena, ya que al sobresalir puede dañarse con facilidad. Si se daña, no será posible conectar nuestro Arduino a Internet. Otro componente importante en nuestro 33IoT es el IMU: Inertial Measurement Unit o lo que es lo mismo, la suma de un acelerómetro y de un giroscopio. El nombre de ese componente es LSM6DS3. Una de las cosas que podemos conseguir con él es medir la posición relativa de la placa. Esto se logrará utilizando los valores de los ejes del acelerómetro y posteriormente imprimir los valores de retorno a través del Monitor Serial de Arduino IDE, pero ya lo veremos más adelante con un ejemplo práctico. Hasta aquí nuestra introducción a los componentes que vamos a necesitar conocer de nuestro Arduino antes de comenzar a programarlo, así que... una vez leído esto, podemos pasar a la acción. FUENTES: Arduino Noano 33IoT: https://lab.bricogeek.com/tutorial/guia-de-modelos-arduino-y-sus-caracteristicas/arduino-nano-33-iot Componentes Arduino Nano 33 IoT: https://antonio2709839759912.wordpress.com/2021/11/27/arduino-nano-33-iot/ Batería LiPo: https://vermabaterias.com/baterias-lipo-que-son/ Pilas de botón: https://es.wikipedia.org/wiki/Pila_de_bot%C3%B3n IMU: 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 1.1: Descargar la IDE de Arduino y encender un LED Esta práctica es obligatoria, ya que realizándola nos aseguramos poder continuar el taller correctamente. Para su entrega, se especificarán los detalles en Moodle. Y es que después de la teoría tenía que llegar la práctica. Ahora que ya conocemos las partes de nuestro 33IoT, es el momento de ver qué podemos hacer con él, comenzando por lo más sencillo: encender un LED . Para evitar tener que realizar conexiones, vamos a encender el LED con el que cuenta nuestra placa. A este LED se le conoce con el nombre LED_BUILTIN , y esa es exactamente (no vale cambiar las mayúsculas por minúsculas, añadir espacios o escribir los guiones mal) la palabra que utilzaremos para encenderlo y apagarlo. Instalar la IDE de Arduino Lo primero que tenemos que hacer es instalar la IDE (Entorno de Desarrollo Integrado) de Arduino en nuestro ordenador. Dependiendo del sistema operativo que empleemos, tendremos que seguir unas instrucciones u otras.  A continuación te dejo los enlaces para instalarlo tanto en Windows, Linux o Mac. Arduino IDE Linux Arduino IDE macOS Arduino IDE Windows La descarga e instalación nos puede llevar de 5 a 20 minutos, dependiendo de la velocidad de nuestra conexión a internet y del sistema operativo que tengamos, ya que el procedimiento varía notablemente de uno a otro. En este curso, recomendamos instalar la IDE de Arduino en vuestro ordenador, aunque si durante la instalación tuviéseis muchos problemas (que no suele ser común, aunque puede suceder si, por ejemplo el ordenador que utilizáis tiene un sistema operativo muy antiguo) podrías utilizar la versión online. Para ello es necesario crear una cuenta en la web de Arduino y seguir los siguientes pasos.   Abrimos la aplicación Una vez hayamos instalado la IDE, estaremos listos para abrirla y nos encontraremos con algo muy similar a esto: A través de esta aplicación programaremos nuestro Arduino. Lo primero que vamos a hacer es ver qué podemos hacer con algunos de los botones que utilizaremos con más frecuencia. Comenzaremos de arriba a abajo y de izquierda a derecha. Se recomienda abrir la aplicación para poder ir viendo cada botón conforme se explica su función. Símbolo tick (Verificar): con él, comprobaremos que el código que queremos subir a nuestro Arduino no contiene fallos sintácticos. ¿Dónde nos comunicará la aplicación si nuestro código tiene fallos o no? Lo veremos en el rectángulo negro de la parte inferior. Esa parte se denomina consola. ¿Siempre que nuestro código pase satisfactoriamente el paso de verifiación nos aseguramos de que funciona correctamente? Pues, desafortunadamente no. Esta verificación nos asegura que no existen fallos sintácticos: palabras mal escritas, expresiones incorrectas... pero no nos asegura que la lógica de nuestro programa sea la correcta. Flecha a la derecha (Cargar): una vez nos hayamos asegurado de que nuestro código es correcto sintácticamente, al darle a la flecha, comenzaremos a cargarlo en nuestra placa Arduino. Hoja de papel (Nuevo): este botón abre una pestaña nueva para que podamos escribir código. No la utilizaremos en este taller. Flecha arriba (Abrir): nos permite abrir un archivo (sketch) existente. Flecha abajo (Guardar): permite guardar el archivo en el que estamos trabajando actualmente. Lupa (monitor serial): abre una ventana que nos permite ver la información serie que la placa transmite. Es muy útil para encontrar fallos en el código y ver si el programa y la placa Arduino funcionan correctamente. Lo veremos con más detalle en las partes prácticas del taller. Nombre del sketch: en esta pestaña encontraremos el nombre de nuestro sketch. Por defecto será algo similar a sketch_fecha Área de escritura: en esta zona escribiremos nuestro programa. Área de mensajes: en esta parte, el IDE nos indicará si existen errores en el código. Consola de texto: la consola nos mostrará los mensajes de error completos, es muy útil a la hora de depurar nuestro código. Placa y puerto serie : se muestra el nombre de la placa (Arduino) que tenemos conectada (o la última que hemos conectado, si no hay ninguna conectada) y el puerto al que está conectada. Aparte de estas herramientas, contamos con una barra de herramientas en la parte superior (Arduino, Archivo, Editar...). El aspecto de esta barra de herramientas puede variar ligeramente de un sistema operativo a otro, pero las funciones serán las mismas. Algunas de ellas las veremos a continuación. Cuando Arduino IDE se instala por primera vez en un equipo, crea en el mismo una carpeta llamada Arduino donde almacenará las bibliotecas y otras utilidades que necesita, y donde colocará nuestros proyectos si nosotras no le indicamos lo contrario. Para saber en nuestro equipo dónde ha colocado esa carpeta, podemos verlo desde el menú Archivo/Preferencias. Por supuesto podemos modificar la ubicación de esta carpeta desde aquí, cambiar el idioma, así como algunas otras opciones que pueden ser interesantes para la accesibilidad de la herramienta como el tamaño de letra o el tema a utilizar. Para más opciones sobre cómo configurar la accesibilidad de arduino por ejemplo para personas con deficiencia visual consulta aquí . Conectamos nuestro 33 IoT al ordenador Llegadas a este punto, estamos listas para conectar nuestro Arduino al ordenador. Para ello, necesitaremos nuestro cable USB-microUSB. Una vez hayamos conectado un extremo a nuestro Arduino y el otro al puerto USB de nuestro ordenador, tendremos que ayudar a la IDE a que reconozca a nuestro Arduino. Lo primero que veremos será un LED amarillo que se enciende y junto al que pone ON. Eso nos indica que la placa está recibiendo corriente desde nuestro ordenador. Los usuarios de Windows (seguramente) tendrán que instalar una serie de drivers una vez se conecte el Arduino al ordenador. Lo siguiente que tendremos que hacer es ir a la barra de herramientas superior y precisamente en Herramientas tendremos que configurar dos cosas, la placa y el puerto : Configuramos la placa En la imagen superior, en Placa ya nos aparece nuestro 33 IoT, pero cuando lo abras por primera vez.... no tendrás tanta suerte. Lo que tendrás que hacer es descargar lo que se conoce como SAMD core y que permitirá que nuestro ordenador reconozca la placa con la que vamos a trabajar. Como puedes comprobar, es una placa un poco especial, que requiere una serie de pasos hasta que podamos conectarla correctamente a nuestro ordenador. Para ello, tendremos que ir a Herramientas > Placa > Gestor de tarjetas. Una vez ahí, nos aparecerán una serie de cores que podemos instalar, pero el que nosotras necesitaremos será el Arduino SAMD Boards (32-bits ARM Cortex-MO+) :  Lo podemos buscar en la barra de búsqueda de la derecha o hacer scroll hacia abajo hasta que lo encontremos. Una vez lo hayamos localizado, lo instalaremos haciendo clic en INSTALAR (en la imagen superior no se puede instalar, porque ya está instalado). El proceso de instalación puede tardar algunos minutos, de nuevo depende de la conexión a internet y de la velocidad del ordenador desde el que estemos realizando la instalación. Una vez lo hayamos instalado, nos aparecerá la palabra INSTALLED , como puedes ver en la imagen superior, y a continuación podremos ir a Herramientas > Placa > Arduino SAMD (32-bits ARM Cortex-MO+) Boards y seleccionar la nuestra: Arduino Nano 33 IoT. Al seleccionarla, le estamos diciendo a nuestro Arduino "¡Hey! Prepárate, voy a conectarte un Arduino Nano 33 IoT", por lo que si al final conectásemos otro tipo de Arduino, la IDE no la reconocería y no podríamos programarla. Si utilizamos otro tipo de Arduino, lo primero que tenemos que hacer es decírselo a Arduino seleccionando la placa correcta en Placa , como acabamos de hacer. Configuramos el puerto Una vez le hemos dicho la placa que vamos a conectar, nuestro IDE necesita saber en qué puerto USB la hemos conectado. Para ello, tendremos que ir a Herramientas > Puerto Para los usuarios de Windows podría tener esta apariencia: (Arduino NANO 33 IoT) Para los de  MAC o Linux , la apariencia puede ser parecida a esta: /dev/cu.usbmodem14112 (Arduino NANO 33 IoT) Una vez hayamos seleccionado nuestra placa y puerto, pasaremos a encender el LED. Y se hizo la luz Para encender nuestro LED, vamos a utilizar un ejemplo de los que se nos proporcionan desde la propia IDE de Arduino. Estos ejemplos nos pueden ser útiles para descubrir lo que podemos hacer con estas placas, por lo que os recomiendo que les echéis un vistazo. El ejemplo que vamos a utilizar se llama Blink y nos va a venir bien para asegurarnos de que la instalación y toda la configuración se han realizado correctamente. Para abrir y subir este ejemplo a nuestro Arduino tenemos que navegar a: Archivo > Ejemplos > 01.Basics > Blink . Una vez hagamos click, se abrirá una nueva ventana de Arduino con el código que permitirá que nuestro LED comience a parpadear. El código que veremos será el siguiente: /* Blink Turns an LED on for one second, then off for one second, repeatedly. Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to the correct LED pin independent of which board is used. If you want to know what pin the on-board LED is connected to on your Arduino model, check the Technical Specs of your board at: https://www.arduino.cc/en/Main/Products modified 8 May 2014 by Scott Fitzgerald modified 2 Sep 2016 by Arturo Guadalupi modified 8 Sep 2016 by Colby Newman This example code is in the public domain. https://www.arduino.cc/en/Tutorial/BuiltInExamples/Blink */ // the setup function runs once when you press reset or power the board void setup() { // initialize digital pin LED_BUILTIN as an output. pinMode(LED_BUILTIN, OUTPUT); } // the loop function runs over and over again forever void loop() { digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second } Ahora, no vamos a entrar a explicar qué significa este código, eso lo haremos en la página siguiente. Lo que sí vamos a hacer es darle a la flecha a la derecha para subir ese código a nuestro 33IoT: Y si todo ha ido bien, lo que veremos será un LED naranja, justo en el lado del microUSB en el que no está el LED amarillo,  permanecer un segundo encendido, un segundo apagado. ¡Y ya lo tenemos! Es posible que nos de algún error y que no funcione. Eso no significa que algo esté roto. Como ya avisé en la primera página del taller, no siempre funciona todo a la primera. Si en la consola vemos algún error, tendremos que asegurarnos de que hemos seleccionado el puerto y la placa correctas y que hemos seguido todos los pasos correctamente, sin olvidar ninguno. Ha habido casos en los que usuarios de Linux se han encontrado con un problema de permisos . Puede que el puerto esté bien seleccionado, pero que el usuario no tenga permiso para acceder al puerto. Para obtener permiso ese necesario emplear el comando: "sudo usermod -a -G dialout ". Tras reiniciar debería funcionar.   FUENTES: Arduino Nano 33 IoT: https://docs.arduino.cc/hardware/nano-33-iot Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Entender el código para encender el LED Como ya te comenté en la página anterior, lo que vamos a hacer ahora es entender el código que hemos utilizado para programar nuestro Arduino. El lenguaje de programación que empleamos para programar nuestro 33IoT (o cualquier otro Arduino o placa basada en Arduino que programemos con la IDE que acabamos de descargar) se llama también Arduino y está basado en el lenguaje de programación C++ . Diremos que es una versión simplificada de C++. Es importante tener ciertas nociones de inglés para poder programar Arduino, ya que al ser un lenguaje basado en C++, C++ tiene como lenguaje natural de referencia el inglés. Para entender el código que ha iluminado nuestro LED, lo que vamos a hacer es ir viéndolo párrafo a párrafo y así, explicaremos diferentes características que necesitaremos conocer para trabajar en nuestros propios proyectos. ¿Y por qué copiamos código en lugar de escribir el nuestro? Esta pregunta puede venirnos a la cabeza y es normal. A la hora de comenzar a trabajar con Arduino, suelen seguirse los siguientes pasos: 1. Buscar ejemplos similares a lo que queremos hacer. 2. Entender lo que hace el código y copiarlo . 3. Realizar las modificaciones necesarias para adaptarlo a nuestro proyecto. ¿Y por qué se suele hacer eso en lugar de escribir código desde cero? Arduino se creó con la finalidad de que gente que no pertenece al mundo de la electrónica y la programación fuese capaz de programar y de realizar proyectos interactivos. Por ello, existe una amplia comunidad de creadores que comparten sus proyectos (tanto el hardware como el software ) de manera libre, para que la gente pueda reutilizarlo y adaptarlo a sus necesidades. Muchos de los proyectos que queramos realizar, ya habrán sido realizados antes y además la gente que los comparte suele explicar detalladamente cómo replicarlos y por qué los han realizado de una manera determinada. Aparte de facilitarnos el trabajo, reutilizar código nos puede enseñar funciones y características de Arduino que desconocíamos. Y por supuesto, siempre podremos decidir hacer las cosas de otra manera cuando tengamos los conocimientos suficientes. En algunas ocasiones es bueno intentar crear algo desde cero, pero en muchas ocasiones no es necesario tratar de reinventar la rueda . ¿No estamos plagiando/robando otros proyectos? - No, los proyectos de Arduino que se comparten son de código abierto (open source) y eso significa que podemos reutilizarlos y adaptarlos a nuestras necesidades sin ningún problema. Comencemos a entender el idioma de Arduino Cuando programemos nuestro Arduino, tenemos que tener en mente que el código que escribamos, aparte de ser procesado por nuestro Arduino, es leído por nosotros y por cualquier otra persona que colabore en nuestro proyecto. Como ya se ha comentado, Arduino nació con la finalidad de aproximar la electrónica y la programación a cualquier persona que le interesase sin que sea necesario que tenga amplios conocimientos de programación. Por ello, el trabajo colaborativo y compartir el código es algo muy común. Para que eso se realice correctamente es necesario que nuestro código sea comprensible por nosotros y por cualquiera que pueda trabajar con nosotros en el proyecto. Una manera de explicar y clarificar la finalidad de nuestro código es el uso de comentarios . Los comentarios son aquellas oraciones que no van destinadas a que las procese nuestro Arduino, sino que el destinatario somos nosotros mismos u otras personas. ¿Nosotros mismos? Sí. Imagina que estás trabajando en un proyecto de Arduino, pero que por alguna circunstancia tienes que dejar de trabajar en él y lo retomas un año después. Quizá después de tanto tiempo no recuerdas bien para qué habías escrito ese código... Los comentarios pueden ayudarte en esa tarea. Échale un vistazo a este fragmento de código: /* Blink Turns an LED on for one second, then off for one second, repeatedly. Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to the correct LED pin independent of which board is used. If you want to know what pin the on-board LED is connected to on your Arduino model, check the Technical Specs of your board at: https://www.arduino.cc/en/Main/Products modified 8 May 2014 by Scott Fitzgerald modified 2 Sep 2016 by Arturo Guadalupi modified 8 Sep 2016 by Colby Newman This example code is in the public domain. https://www.arduino.cc/en/Tutorial/BuiltInExamples/Blink */ Como puedes ver, se trata de un código separado en párrafos: Blink : Lo primero que nos encontramos es el título del proyecto. Descripción del proyecto: Breve descripción de la finalidad del código y explicación. Modificaciones y autores: Fechas de modificación y los autores que lo han editado. Arduino se basa en compartir y reutilizar código, por ello es necesario indicar quién ha creado ese código y quién lo ha modificado. No debemos apropiarnos del código de otra persona sin mencionarlo. Dominio público: cualquiera puede utilizar este código con los fines que prefiera, comerciales o no. Web: Tutorial en el que se explica el proyecto. Cuando nosotras creemos un proyecto, será muy conveniente que nos acostumbremos a escribir algo parecido a esto al principio de nuestro código. Y si te has fijado bien, al principio y al final encontramos /* y */ eso nos indica que lo que escribamos entre ambos símbolos es un comentario, sin importar que nos ocupe una línea o varias. Normalmente se utiliza para comentar párrafos. Su función es evitar que Arduino lo lea, y que cuando el código sea compilado se obvie. Si Arduino intentase procesar ese texto escrito en inglés (los comentarios también podríamos hacerlos en español) daría error porque no está escrito en el lenguaje de Arduino. Otra manera de escribir comentarios cuando solamente ocupan una línea es empleando // solamente al principio. Con Arduino abierto con el sketch Blink, vamos a guardarlo con otro nombre y podremos hacer pruebas con el texto de los comentarios. Guardar un archivo preexistente de Arduino Para guardar una copia del sketch Blink, lo que haremos será ir a Archivo > Guardar como...  y ahí se nos abrirá una ventana en la que podremos escribir un nuevo nombre y elegir la ubicación para guardarlo. Recordar que nos mostrará por defecto la carpeta que tenga configurada en Preferencias. Yo os recomiendo que para guardar los sketches que escribamos en este taller os creéis una carpeta, por ejemplo en Documentos o en el Escritorio, y ahí Arduino os creará una subcarpeta para cada archivo nuevo que guardemos. Al guardar un archivo por primera vez, se genera el archivo con la extensión .ino y una carpeta que lo contiene. Cada sketch necesita estar dentro de una carpeta con su mismo nombre. ¿Por qué? Nosotros en este taller no vamos a emplear archivos externos aparte del sketch en nuestro proyecto, pero podría darse el caso que para funcionar, los necesitásemos; estos archivos deben estar dentro de la carpeta, sino, el programa no funcionaría correctamente. void setup() Una vez hemos entendido qué son los comentarios y cómo guardar nuestros archivos, vamos a continuar leyendo el código: // the setup function runs once when you press reset or power the board void setup() { // initialize digital pin LED_BUILTIN as an output. pinMode(LED_BUILTIN, OUTPUT); } Lo próximo que nos encontramos (tras el comentario // que ya hemos explicado en el párrafo anterior) son las palabras void setup(). Bueno, la estructura correcta sería esta: void setup() { // aquí escribimos los comandos a ejecutar } Es muy importante que no olvidemos ningún paréntesis ni corchete , o el programa no funcionará. Eso es una función. Y, ¿qué es una función dentro del mundo de Arduino? Una función es un fragmento de código, un subalgoritmo dentro de nuestro algoritmo, que tiene como propósito resolver una tarea determinada. La palabra void , significa que esta función no nos devuelve ningún valor (sea un número, un caracter, un string, etc.) y la palabra reservada setup indica que el código que escribamos entre las llaves {} se ejecutará una sola vez al inicio del programa. Una palabra reservada es aquella que dentro de un lenguaje de programación tiene un significado determinado. Lo iremos entendiendo a lo largo del taller. Más ejemplos. Tienes una lista completa con las funciones que podemos encontrar en Arduino, aquí . En este caso, el código escrito dentro de la función setup() es:   pinMode(LED_BUILTIN, OUTPUT); Esta línea está compuesta por una función y dos palabras reservadas . pinMode(pin, modo) : es una función que nos ayuda a configurar los pines digitales de nuestro Arduino para que funcionen, o bien como entrada, o como salida de la información. El primer parámetro de esta función recibe el número (o en este caso nombre, porque es un pin especial) del pin que vamos a utilizar. El segundo parámetro recibe el modo: INPUT o OUTPUT, si lo vamos a utilizar como pin de entrada o de salida respectivamente. La palabra LED_BUILTIN es una palabra reservada y se refiere al LED que viene dentro de nuestra placa, como se ha comentado en la página anterior. Por tanto en esta línea le estamos diciendo a Arduino: "Oye, coge el pin al que llamas LED_BUILTIN y configúramelo como pin de salida, por favor." Para finalizar, añadimos un ; . Esto es importante, porque sin él tendríamos un error al verificar el código. void loop() // the loop function runs over and over again forever void loop() { digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second } Ahora que ya hemos visto qué es una función, nos va a resultar más fácil ver qué es esto de void loop(). Si la función void setup() ejecutaba el código que contenía solamente  una única vez  al arrancar el programa, la función loop lo hace en bucle (como su propio nombre indica), ejecutando indefinidamente el código que escribimos {} entre las llaves. En este caso encontramos dos funciones, la primera es digitalWrite() y la segunda es delay() . digitalWrite() : recibe dos parámetros, el primero es el led que utilizaremos, y que previamente habremos configurado como pin de salida (como hemos hecho con pinMode() ), y el segundo es lo que haremos con ese pin. Al ser digital solo existen dos acciones, activar o desactivar el pin ( HIGH o LOW ). Si la acción es HIGH, el pin tendrá un voltaje de salida de 3.3V si la acción es LOW, el voltaje será 0V. delay(): esta función hace que el arduino se detenga una determinada cantidad de tiempo, medido en milisegundos. Solamente cuenta con un parámetro. Por tanto, a nuestro Arduino, dentro de void loop() le estamos diciendo: "Hey, enciéndeme el LED un segundo y apágalo otro segundo, por favor. Al principio, puede parecer un poco farragoso, pero poco a poco iremos familiarizándonos con el lenguaje de Arduino y nos iremos entendiendo mejor. Para practicar, te aconsejo que modifiques los valores dentro de delay (sin que sean menores a 500ms) y subas esas modificaciones a Arduino, para que veas cómo cambia la frecuencia con la que parpadea el LED. FUENTES: Lenguaje Arduino: https://descubrearduino.com/lenguaje-arduino/ C++: https://es.wikipedia.org/wiki/C%2B%2B Código abierto (open source): https://es.wikipedia.org/wiki/Sistema_de_c%C3%B3digo_abierto pinMode(): https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/ Funciones de Arduino: https://www.arduino.cc/reference/en/ Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¿Qué es un vestible? Ahora que ya sabemos qué es un Arduino y hemos visto qué lenguaje habla, es el momento de que veamos qué es un vestible y cómo podemos aunar ambos. Vamos a entender por vestible (o wearable) a aquello que podemos llevar puesto, ya sea un accesorio o prenda de vestir. En este caso, la idea de vestible llevará implícita que aparte de poder llevarlo puesto, utilizará sensores y actuadores para hacerlo interactivo. Con lo que vamos a trabajar en este taller es con la idea de vestible electrónico . Un ejemplo de vestible que todos conocemos (y en el que probablemente habrás pensado al oir hablar de vestibles + electrónica) es el smartwatch o pulsera de actividad. Denominaciones para los vestibles Algunas maneras de llamar a estas prendas de vestir y accesorios electrónicos son:  Wearables Fashionable Technology (Fashion Tech) Tecnología vestible Ropa tecnológica Ropa inteligente Casi más conocido que el nombre de vestible es el de wearable , el cuál tiene su origen en el año 2004, cuando los diseñadores de la marca CuteCircuit denominaron así a una de sus creaciones, Hug Shir t. En este video podemos ver el vestible en acción: Aunque el video está en inglés, podemos hacernos una idea de lo que sucede con esa camiseta. Contiene una serie de sensores de presión , los cuales a través de una placa, que podría ser Arduino o similar, envían a una aplicación de nuestro teléfono móvil las zonas y la presión con la que hemos tocado la camiseta. Nuestro móvil, envía esa información al móvil de la otra persona a la que queremos enviarle un abrazo y activa en su camiseta diferentes motores que vibran en las mismas zonas que han sido activadas en la primera camiseta. En 2004, quizá podía sonarnos extraño enviar abrazos a distancia, aunque después de la pandemia... quizás no es una idea tan descabellada :) Otras placas para hacer vestibles En este taller trabajarás con el Arduino Nano 33 IoT, porque en la última parte del taller vamos a conectarlo a internet y es una de las placas más pequeñas que nos permiten hacer eso. Otras alternativas para realizar nuestros proyectos vestibles son las placas denominadas Lilypad y las Flora. Placas Lilypad. Fuente: https://docs.arduino.cc/retired/getting-started-guides/ArduinoLilyPad Placa Flora. Fuente: https://www.instructables.com/How-to-use-the-Adafruit-Flora-board-Arduino-Tutori/ Estas placas han sido diseñadas para ser cosidas y algunas de ellas incluso son lavables. También, cuentan con conectores para baterías LiPo. Nuestro Arduino no cuenta con ese tipo de conector, pero, como ya he comentado, lo alimentaremos con una batería externa del tipo power bank. FUENTES: Fashionable Technology: https://link.springer.com/book/10.1007/978-3-211-74500-7 Flora: https://www.instructables.com/How-to-use-the-Adafruit-Flora-board-Arduino-Tutori/ Lilypad: https://docs.arduino.cc/retired/getting-started-guides/ArduinoLilyPad Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Vestibles 1 : algunos ejemplos dentro del arte y el diseño En esta página vamos a ver una serie de proyectos que emplean Arduino (o tecnología basada en esta placa) para crear proyectos dentro del mundo del arte y el diseño. ¿Con qué finalidad? El propósito principal es ver las posibilidades que nos ofrece Arduino y que nos pueda inspirar y dar ideas para los proyectos que podemos llegar a diseñar empleando placas de desarrollo basadas en Arduino. Sound Shirt , Cute Circuit La SoundShirt cuenta con 28 microactuadores incrustados en el tejido de la prenda. Estos actuadores reciben de forma inalámbrica y en tiempo real el sonido, transformado en datos táctiles, que capta una aplicación móvil. De este modo, se crea una sensación de inmersión total para todo aquel que quiera disfrutar de la música. Así el sonido se convierte en una serie de sensaciones hápticas (similares al tacto) en el torso de la persona que lleva puesta la camiseta. El diseño de la camiseta es cómodo y está hecho con un tejido suave y elástico. La Sound Shirt carece de cables ya que está construida con textiles inteligentes y tecnología vestible muy avanzada.  Nuestros proyectos sí que van a llevar cables, sensores y no van a utlizar tecnología vestible muy avanzada, pero algunos de los sensores que veremos se aproximan a las funcionalidades de la SoundShirt . Tools for Improved Social Interacting , Lauren McCarthy Fuente: Web de la artista: https://lauren-mccarthy.com/Tools-for-Improved-Social-Interacting Antes de que yo te explique qué hace cada uno de esos vestibles, me gustaría que vieses el vídeo de los tres proyectos. Bien, ¿ya lo has visto? Espero que sí. Como la propia creadora explica en su web, el Anti-Daydreaming Scarf contiene un sensor de radiación térmica que detecta si existe otra persona cerca con la que podemos estar en conversación. Lo que hace este dispositivo es que, mientras estamos en esa posible conversación, la bufanda vibra periódicamente para recordarnos que debemos prestar atención a la conversación y dejar de despistarnos. El Happiness Hat sirve para entrenarnos en sonreir más. Un sensor flexible enganchado a la mejilla mide el tamaño de nuestra sonrisa. A su vez, un servo motor mueve una punta de metal en nuestra cara con una profundidad inversamente proporcional al tamaño de nuestra sonrisa. El Body Contact Training Suit requiere que quien lo lleve puesto mantenga contacto físico con otras personas si quiere poder escuchar con normalidad. Si dejamos de tocar a alguien durante demasiado tiempo, unos auriculares comienzan a reproducir ruidos impidiendo que escuchemos con claridad. Un sensor capacitivo mide el contacto piel a piel  con un brazalete de metal cosido en la manga. A diferencia de la Sound Shirt , estos tres proyectos se aproximan más a lo que podemos conseguir con los sensores que veremos más adelante y nuestro 33 IoT. Diana Eng, Heartbeat Hoodie Fuente: Jim Driscoll. https://www.flickr.com/photos/netdance/137143816/ El propósito de este vestible es que recordemos las cosas que nos emocionan. ¿Y eso cómo se consigue? Esta camiseta  contiene un monitor de ritmo cardíaco (pulsómetro) y una cámara, conectados entre sí. Cuando el ritmo cardíaco aumenta, entendiéndose así que nos estamos emocionando, la cámara comienza a grabar. Por tanto, este proyecto se basa por un lado en emplear como sensor un pulsómetro y como actuador una cámara que se activará en el momento en que nuestras pulsaciones se hayan elevado hasta un cierto número. Anouk Wipprecht, Spider Dress Este proyecto no está basado en Arduino, sino en el Intel Edison; una placa más cercana a un pequeño ordenador que a un microcontrolador. ¿La diferencia? Su complejidad. No obstante, una versión simplificada de este proyecto podría replicarse con Arduino, un sensor de ultrasonidos, el cuál es el encargado de medir distancias, y unos servomotores. ¿Cuál es la idea detrás de este vestido? Este 'vestido araña' evita que la gente invada nuestro espacio personal haciendo que si alguien se acerca a menos de una determinada distancia, unos motores se activen y muevan una especie de 'patas' que harán que esa persona se aleje de nosotros. Marta PCampos, Anxiume El último proyecto que vamos a ver es Anxiume. Se trata de un accesorio que podría ser considerado como una interfaz para mediar en nuestra relaciones con otras personas, ( human-to-human interface ). Su nombre es un acrónimo de las palabras ansiedad ( anxiety ) y perfume ( perfume ).  Contiene un circuito que libera un perfume agradable, que busca relajar a quien lo lleva puesto. Este perfume es liberado cuando el portador comienzar a sudar y su pulso se acelera, ambas señales consideradas como indicadores de nerviosismo y ansiedad. El propósito de Anxiume es ayudar a que aquellas personas introvertidas se relajen cuando se encuentran en eventos públicos utilizando la aromaterapia. Por un lado, Anxiume puede ayudarnos a mejorar nuestro día a día, pero por otro lado, actúa como una crítica a nuestra actual dependencia en todo tipo de dispositivos tecnológicos y apps que nos prometen una vida más fácil.  En la creación de aromas con propiedades relajantes colaboró la perfumista Isabel Guerrero , cuya amplia experiencia y conocimientos sobre las propiedades aromacológicas de algunos componentes químicos sirvió para elaborar dos aromas diferentes.  A continuación, podéis ver un dibujo del circuito que compone este proyecto: Como puedes ver, no cuenta con muchos sensores ni actuadores. Exactamente, sus componentes son: Placa: Arduino Lilypad (circular y morada) Sensor: Un pulsómetro (a la derecha, con un corazón blanco dibujado) Actuador: Un difusor (en la parte inferior) Alimentación: Dos Baterías LiPo (a la izquierda) Veremos estos sensores junto con otros un poco más adelante... Anxiume nos va a permitir enlazar los proyectos vistos en esta página, más relacionados con el mundo del diseño y el arte, con otros proyectos orientados a la educación. FUENTES: Hug Shirt: https://cutecircuit.com/hugshirt/ Sound Shirt: https://cutecircuit.com/soundshirt/ Heartbeat Hoodie: http://www.electricfoxy.com/electricfoxy/tag/heartbeat+hoodie Anxiume: https://martapcampos.com/proyectos/anxiume/ Intel Edison: https://en.wikipedia.org/wiki/Intel_Edison Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Vestibles 2: algunos ejemplos dentro de la educación Anxiume ¿Otra vez? Sí, volvemos a este proyecto porque hay algo que nos interesa, y es que, aparte de ser un proyecto que podemos considerar desde el punto de vista del mundo artístico y del diseño, va acompañado de un tutorial que nos invita a replicarlo en nuestra casa. El tutorial, aunque esté en inglés no es complicado de seguir. Puedes echarle un vistazo en este enlace . Como veis, la conexión entre un proyecto perteneciente al mundo del arte/diseño y la educación puede ser muy estrecha. Continuemos con otros proyectos que se sitúan en esta misma línea. Kobakant Kobakant es un dúo de artistas formado por Mika Satomi y Hannah Perner-Wilson. En su página web , la cual te aconsejo que visites, podrás encontrar gran cantidad de proyectos y talleres que han realizado en los últimos años. En ellos, trabajan con sensores que fabrican ellas mismas, tratando de utilizar materiales suaves y flexibles. Un ejemplo de ello lo encontramos en su cinturón para medir la respiración . Se trata de una propuesta para un sensor que busca captar el movimiento de la respiración torácica o estomacal mediante un sensor elástico tejido con un hilo de acero inoxidable y poliéster: El funcionamiento de este sensor se basa en que las fibras de acero inoxidable del hilo conductor son cortas, y la resistencia eléctrica entre ellas es alta (cuando está sin estirar <1M Ohm). Sin embargo, cuando se estira el hilo, la resistencia desciende por debajo de 1K Ohm (dependiendo de la longitud del hilo que se mida). De esta manera, al conectarlo a uno de los pines analógicos de nuestro Arduino usando un divisor de voltaje , que a efectos prácticos consiste en conectar una resistencia o un potenciómetro, detectaremos si la persona que lo lleva puesto está respirando y con qué profundidad lo está haciendo: Lo bueno de los proyectos de Kobakant es que tienen tutoriales de todos sus proyectos para facilitar que cualquiera pueda construirlos. A parte de eso, suelen utilizar materiales fácilmente accesibles. Para ver el tutorial completo de este proyecto, te aconsejo que visites la página web . Taller: Sensonautas (Colonias Etopia Kids 2019, Zaragoza) El tercer proyecto es un taller que se impartió a chavalxs de 13 a 16 años durante las colonias de verano de Etopia Kids y en el que los protagonistas (a parte de lxs participantes) eran un Arduino + diversos sensores. Una vez conocieron las herramientas y algunas fuentes de inspiración, se les propuso trabajar a lo largo de una semana en un proyecto que tenían que conceptualizar de manera grupal para posteriormente construirlo. Dos ejemplos de los resultados obtenidos los encontramos a continuación: El primero de ellos fue el resultado de un grupo que pensó en aquellas personas con problemas graves de visión. Para ellas creo un vestible consistente en unas gafas, las cuales en la parte frontal contaban con un sensor de ultrasonidos que se encarga de medir la distancia a la que se encuentra un obstáculo. Aparte de con el sensor, las gafas contaban con un piezo que funcionaba como actuador y emitía diferentes sonidos para evitar que quien lleva puestas las gafas se choque y pueda hacerse daño con obstáculos que estén demasiado cerca de su camino. Todo ello era controlado por un Arduino. La segunda imagen nos muestra otro proyecto en el que en lugar de usar un Arduino, el grupo diseñador del proyecto utilizó un Lilypad (que como ya hemos visto, también está basado en Arduino). El usuario tiene que colocarse la banda negra, sobre la que están cosidos los diferentes componentes, alrededor del cuello. Una vez colocada, el sensor flex (que está colocado en la parte central y tiene forma alargada) se encarga de detectar si hemos inclinado demasiado la cabeza hacia abajo.... ¿y esto por qué? Pues porque sus creadores querían evitar quedarse dormidos mientras están estudiando. Por eso, si el usuario inclina demasiado la cabeza, un zumbador comienza a vibrar para despertarlo. En Sensonautas, lxs participantes tenían la opción de elegir entre una serie de componentes dependiendo del tipo de proyecto que quisiesen desarrollar. Lo importante era que trabajasen en equipo, se familiarizasen con el mundo de la electrónica y el de los vestibles/wearables y pensasen en diferentes aplicaciones que para ellos fuesen necesarias/valiosas. Gesture Drawings Gloves Workshop El objetivo del wokshop Gesture Drawing Gloves, diseñado por la artista koreana Aesun Kim, es diseñar una interfaz que permita reflexionar sobre los propios gestos de comunicación no verbal que se puedan dar entre los participantes. También, sirvió de introducción a la utilización de materiales conductores de una manera creativa. La parte principal del taller está basada en la idea de que, al analizar la comunicación y la expresión gestual y comparar las diferencias de origen social y nacional, es posible analizar las expresiones de identidad. Esto resultaba interesante en este taller, ya que los participantes eran personas procedentes de diferentes países. En este vídeo, podemos ver una breve muestra de algunos resultados del taller: Como has podido comprobar, este taller no utiliza un Arduino, ni ningún tipo de circuito integrado o microcontrolador. Unicamente se emplean una serie de componentes sencillos que permiten construir circuitos muy básicos con los que experimentar creando vestibles. FUENTES: Anxiume, Marta PCampos: https://www.instructables.com/Anxiume/ Data Polluters, César Escudero: https://escuderoandaluz.com/2016/01/01/data-polluters/ Gesture Drawing Gloves Workshop, Aesun Kim: https://aesunkim.com/Gestural-drawing-workshop Imágenes sensor cinturón respiración: https://www.kobakant.at/DIY/?p=8171 Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Práctica 1.2: un vestible ideal En esta práctica de final de bloque, tendremos que conceptualizar un vestible al que denominaremos como ideal . ¿Y por qué lo vamos a calificar así? Básicamente porque no vamos a tener que pensar exactamente cómo llevarlo a cabo. Vamos a idearlo y no vamos a tener que materializarlo. El propósito es que dejemos volar nuestra imaginación y que con los ejemplos que hemos visto ideemos un vestible y pensemos en ciertos puntos que será importante que también tengan en cuenta los alumnos cuando se enfrenten a realizar un proyecto utilizando Arduino. 1. ¿Para qué? El punto principal de nuestro proyecto es saber para qué lo queremos construir. Como hemos visto en los proyectos de las páginas anteriores, existen motivos de todo tipo. Puede ser que queramos ayudar a aquellas personas que se encuentran limitadas por algunos de sus sentidos, como en el caso de la Sound Shirt. Como hemos visto, es vestible permite que sientan el sonido aquellas personas  que carecen de audición. En el caso de la Sound Shirt , incluso puede ser interesante que la usen personas cuyas capacidades auditivas están intactas, para ver sus impresiones. Otro proyecto que se orientó en esa misma dirección es el de las gafas con sensor de distancia que se realizaron en el taller "Sensonautas". Si elegimos crear un proyecto pensando en esta línea, una opción es centrarnos en pensar sobre problemas y limitaciones que podemos encontrar en determinadas circunstancias y plantearnos si sería posible crear un vestible que lo solucionase de alguna manera. Otro planteamiento es generar una reflexión sobre un determinado tema. Para seguir esa línea, podemos escoger un tema de actualidad y posicionarnos ente él de tres maneras: a favor, en contra o tratando de restarle relevancia (si se te ocurre otro posicionamiento, también es posible). Esta reflexión puede estar planteada desde una perspectiva totalmente seria o con un toque de humor . ¿Qué tipo de proyecto de los que hemos visto pueden considerarse en esa línea? Por ejemplo los realizados por Lauren McCarthy, en los que reflexiona sobre sus propias habilidades sociales planteando una serie de vestibles sin dejar de lado el sentido del humor. 2. ¿Qué tecnología y materiales necesito? Esta parte es la que a priori nos puede parecer más contradictoria, ¿no habíamos quedado en que no era necesario construirlo? Sí, eso es cierto, no es necesario que lo construyamos. No obstante, vamos a tener que pensar en su funcionamiento hipotético : qué tipo de sensores necesitaríamos, qué tipo de actuadores, qué tipo de Arduino... No es necesario que sepamos si los sensores/actuadores que queramos usar existen o no, ni tampoco que, en el caso que existan, conozcamos su nombre. Es suficiente con que sepamos describir su funcionamiento, aunque sea vagamente: "sería necesario un sensor que nos permita medir/detectar.... " 3. ¿Cuál será su aspecto? A parte de pensar y escribir, va a ser necesario que dibujemos un poco. Para ello, no hace falta que seamos unos expertos dibujantes, simplemente es importante que realicemos un boceto de su aspecto. De esta manera, me va a resultar más fácil visualizarlo mientras leo su descripción. El dibujarlo también va a hacer que te plantees modificaciones y que tengas que pensar en dónde y cómo colocarías cada componente, cómo lo podrías coser, etc. 4. ¿He visto algo parecido antes? Puede ser que no se nos ocurra nada y que busquemos inspiración en internet o hablando con otros compañeros. Eso no es ningún problema, pero deberemos incluirlo como "Referencias". Estas referencias pueden ser imágenes, vídeos, artículos de prensa, etc. No es necesario emplear ningún formato determinado, pero si lo ves necesario, puedes indicarme en qué medida cada una de esas referencias han influenciado el diseño de tu vestible. En resumen, ¿qué tenemos que entregar? Para esta práctica es necesario que realices una memoria de no más de 5 páginas. Las partes de esta memoria son: 1. Portada con el título y tu nombre y apellidos 2. Breve descripción del vestible (5 líneas) 3. Objetivos y finalidad del vestible 4. Tecnología y materiales 5. Bocetos 6. Referencias Entrégala siguiendo las instrucciones descritas en la tarea de Moodle correspondiente. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU 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 3. Nos conectamos a Internet El internet de las cosas (IoT) El Internet de las cosas (Internet of Thing IoT) describe objetos físicos —o grupos de estos— con sensores, capacidad de procesamiento, software y otras tecnologías que se conectan e intercambian datos con otros dispositivos y sistemas a través de internet u otras redes de comunicación.​ El Internet de las cosas se ha considerado un término erróneo porque los dispositivos no necesitan estar conectados a la Internet pública. Sólo necesitan estar conectadas a una red y ser direccionables individualmente Fuente Wikipedia IoT Internet de las cosas CC-BY-SA En nuestro caso, lo que vamos a hacer es conectar nuestro Arduino a Internet y ver cómo mandamos la información desde nuestra placa a la plataforma Arduino IoT. Veremos cómo nuestro Arduino Nano 33 IoT nos permite conectarnos a una red wifi, que en nuestro caso sí que va a estar conectada a Internet, pero también podríamos utilizar nuestro Arduino para conectarlo a una red local que no necesariamente estaría conectada a Internet.  De Drawed by Wilgengebroed on FlickrTranslated by Prades97 CC BY-SA 3.0 Conectamos objetos entre sí Aunque en este curso no vamos a conectar diferentes objetos entre sí, está bien conocer que el Internet de las cosas se creó originalmente con esa intención. Estamos hablando de dispositivos que se conectan a internet de forma desatendida, por vía hardware (o mejor dicho firmware) a diferencia de un ordenador, tablet o móvil, donde tienes que configurar por software el dispositivo y hay un diálogo entre usuario y dispositivo sobre el uso de Internet (el software solicita tal página web, tales datos etc por voluntad del usuario o por diálogo con el usuario) Aquí los dispositivos están ya configurados de los datos que se comunican. Es decir "conectar y olvidar".  Piensa en la diferencia entre un enchufe inteligente y un ordenador, el primero es lo que se considera dentro de IoT FUENTES: IoT: https://libros.catedu.es/books/rover-marciano-con-arduinoblocks-e-internet-de-las-cosas-iot/page/internet-de-las-cosas-iot Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Arduino IoT Cloud Si queremos conectar nuestro Arduino a Internet para enviar información, una de las maneras más sencillas es empleando nuestro Arduino Nano 33 IoT y la plataforma online Arduino IoT Cloud. Los usos que se le pueden dar a esta plataforma son:   Monitorización de datos: es posible monitorizar fácilmente los valores de los sensores de Arduino a través de un panel de control.   Sincronización de variables: la sincronización de variables nos permite sincronizar variables entre dispositivos, permitiendo la comunicación entre dispositivos con una codificación mínima. Programación : podemos programar trabajos para que se activen/desactiven diferentes funciones durante una cantidad de tiempo específica (segundos, minutos, horas). Cargas Over-The-Air (OTA): permite cargar nuestro código a dispositivos no conectados al ordenador. Webhooks: integra tu proyecto con otro servicio, como IFTTT . Soporte de Amazon Alexa: permite que nuestro proyecto sea controlado por voz con la integración de Amazon. Dashboard Sharing: comparte tus datos con otras personas de todo el mundo.  Si quieres echarle un vistazo a la plataforma IoT Cloud, puedes hacerlo en este enlace . Una de las ventajas principales con las que cuenta esta plataforma es que al haber sido creada desde Arduino, existe mucha documentación y tutoriales sobre ella, lo que nos va a facilitar su uso. En nuestro caso, vamos a enviar información a esta plataforma y gracias a ella produciremos ciertos cambios como hacer sonar una alarma. Aunque primero, tendremos que conectar nuestro Arduino a internet... ¿Qué modelos de placa Arduino pueden usar IoT Cloud? En realidad, cualquier placa que esté basada en el microcontrolador ESP32/ESP8266 puede conectarse, ya que es necesario utilizar Wi-Fi. Nuestro Nano 33 IoT cuenta con una antena integrada que nos permite la conexión, lo veremos un poco más adelante, cuando la conectemos. En la próxima página pasaremos a ver algunos proyectos que emplean Arduino y el internet de las cosas y que nos puede resultar interesante conocer. FUENTES: Arduino IoT Cloud: https://docs.arduino.cc/arduino-cloud/getting-started/iot-cloud-getting-started Foto de C Dustin en Unsplash. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Proyectos que usan IoT y Arduino A continuación, vamos a ver algunos proyectos a modo de ejemplo, que nos pueden dar ideas de lo que podríamos hacer en el aula con nuestro Arduino y la plataforma IoT Cloud. Se ha intentado crear una selección de proyectos que abarquen tanto a aquellos que tendrían cabida dentro del mundo del arte y el diseño, como otros más centrados en el ámbito educativo. iNecklace Este primer proyecto consiste en un collar que se ilumina según los colores que configuramos desde nuestro ordenador. En este proyecto hay varios aspectos interesantes que me gustaría comentarte. El primero de ellos es la manera en la que está creado el vestible. Para conectar los LED a Arduino se han utilizado cables de cobre esmaltado enrollados en lana, como podemos ver en esta imagen: En cuanto al software, hace uso de un repositorio para poder conectar Arduino a la misma red a la que tenemos conectado nuestro ordenador y también para controlar a los LED que en este caso, al cambiar de color, requieren de una librería especial. Aparte de ello, existe una aplicación, programada por sus creadores, pero que ponen a disposición de cualquiera, que es la que directamente controla el color de cada uno de los LED. En la página de Instructables , una web en la que podrás encontrar gran cantidad de proyectos basados en Arduino, los creadores de iNecklace han creado un tutorial sobre este proyecto , pero requiere de unos conocimientos de Arduino más avanzados que lo que se va a ver en este curso. Este punto es importante, ya que veremos que muchos de los proyectos creados con Arduino cuentan con tutoriales para facilitar que cualquiera los pueda replicar o reutilizar realizando modificaciones. Brazo robótico con materiales reciclados Este segundo proyecto propone el uso de materiales que mayormente podrían considerarse como de desecho, como son una botella de plástico y trozos de madera, para construir un brazo robótico. En este proyecto, los creadores no han utilizado el internet de las cosas, sino que el brazo lo controlan empleando un joystick. No obstante, utilizando otro Arduino (en este caso usan un Arduino Uno) como por ejemplo nuestro Arduino Nano 33 IoT podríamos conectar nuestro brazo robótico a una red Wi-Fi y controlarlo remotamente desde un ordenador. Lo más interesante de este proyecto es cómo con muy pocos materiales consiguen un buen resultado. Como ya he comentado, para controlar el movimiento emplean un joystick y el movimiento lo realizan unos motores servo, sobre los cuales ya hemos hablado en el apartado sobre actuadores . Puedes ver el tutorial del proyecto en el siguiente enlace . Comunicador humano-planta Con ese llamativo título parece que vayamos a ser capaces de mantener una conversación con nuestras plantas, pero en realidad, de lo que trata este proyecto es de que seamos capaces de monitorizar ciertos aspectos, como si la planta nos dijese que está bien o que le falta algo. Para ello, se utilizan sensores que controlan la cantidad de humedad y luz , así como la temperatura . Por ejemplo, la cantidad de luz es medida con un sensor como el que hemos utilizado en una de las prácticas del bloque anterior . Este proyecto está realizado con una placa de Arduino diferente a la que nosotros empleamos, pero también con la capacidad de conectarse a una red Wi-Fi para que, al igual que el nuestro, pueda comunicarse fácilmente con otros dispositivos. Una de las librerías empleadas en este proyecto es la que controla que cada día nuestra planta nos envíe un email compartiéndonos 'cómo está' a una determinada hora. Esto lo veremos en un apartado posterior, pero de momento te puedo decir que es posible hacerlo gracias a que nuestro Arduino tiene un reloj a tiempo real. Puedes echarle un vistazo al tutorial de este proyecto aquí . Almohada ILoveYou No es difícil adivinar cuál es el propósito de este proyecto: enviar abrazos a distancia. Si recordáis la sección en la que vimos una selección de proyectos dentro del arte y el diseño , uno de ellos era un proyecto que nos permitía sentir el sonido, la Sound Shirt . Pues bien, sus creadores también cuentan entre sus diseños con la Hug Shirt , la cual realiza una función parecida a la de nuestra almohada. La diferencia de base entre ambos proyectos es que el primero es de código abierto, mientras que el segundo es una prenda de vestir comercializable. Otra diferencia principal es que nuestra almohada cuenta con un circuito más sencillo que el de la camiseta. Como podemos ver en este tutorial. Aparte de un Arduino, utilizan un zumbador , papel de aluminio , cables , una resistencia y una pila . En el área del software emplea la aplicación de mensajería instantánea Telegram para crear un bot, que se encargará de enviar nuestro amor, con la forma del emoji de un corazón 💗, a quien escojamos. El papel de aluminio lo utilizan para crear un sensor capacitivo el cual genera un campo eléctrico que es modificado al aproximarse a él un objeto que conduzca la electricidad, en nuestro caso nuestro cuerpo al abrazar el cojín. Este principio es el que se usa en las pantallas táctiles, por ejemplo. Aquí tienes un ejemplo. Por otro lado, el zumbador lo emplean para crear la sensación de un corazón latiendo. El tutorial de este proyecto puedes verlo al completo aquí . FUENTES: iNecklace: https://github.com/Lilooo/iNecklace Brazo robot con materiales reciclados: https://create.arduino.cc/projecthub/circuito-io-team/robotic-arm-from-recycled-materials-7e318a/ Comunicador humano-planta: https://create.arduino.cc/projecthub/arduino/plant-communicator-7ea06f?ref=tag&ref_id=iot&offset=6 Almohada ILoveYou: https://create.arduino.cc/projecthub/arduino/love-you-pillow-f08931 Sensor capacitivo y Arduino: https://www.aranacorp.com/es/creando-un-sensor-capacitivo-con-arduino/ Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¡Vamos a conectarnos! (Parte 1) Llegados a este punto, veamos cómo conectar nuestro Nano 33 IoT al IoT Cloud.  Creamos una cuenta El primer paso, y además obligatorio, es crearnos una cuenta dentro de la web de Arduino. Esto es lógico, ya que tendremos que guardar la información que recopilemos con los sensores de nuestro Arduino y enviarla a esta plataforma. El proceso es similar a cuando tenemos que crearnos una cuenta en cualquier plataforma. Nos irán pidiendo diferentes datos como nuestra fecha de nacimiento, nombre de usuario, email, etc; así que, vamos a omitir este paso en el tutorial. También te da la opción de conectarte usando tus credenciales de Google, GitHub, Facebook o Apple. Si ya tienes una cuenta con Arduino, puedes saltarte este paso y acceder directamente usando tu nombre de usuario y contraseña. FUENTES: https://docs.arduino.cc/arduino-cloud/getting-started/iot-cloud-getting-started Instalar Create Agent: https://support.arduino.cc/hc/en-us/articles/360014869820-Install-the-Arduino-Create-Agent Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¡Vamos a conectarnos! (Parte 2) Accedemos a IoT Cloud Una vez hemos creado nuestra cuenta, ya podemos entrar y veremos algo parecido a esto. Para acceder a IoT Cloud, clicaremos arriba a la derecha Una vez dentro de IoT Cloud accederemos a la siguiente pantalla: En la barra superior puedes ver 5 apartados diferentes: Things, Dashboards, Devices, Integrations y Templates. De momento, vamos a comenzar con el primero: Things . Dentro de este apartado incluiremos todas las cosas que vamos a conectar a IoT Cloud. Así que para poder conectar nuestro Arduino, lo primero que tenemos que crear es una thing, una cosa . Obviamente, si no hemos utilizado antes IoT Cloud no tendremos nada creado y veremos algo parecido a esto: Dentro de los cuadrados rojos tenemos las partes más importantes de nuestra thing : Variables: En este apartado incluiremos todas las variables que queramos monitorizar. Device: aquí configuraremos nuestro dispositivo para que se comunique con IoT Cloud. Network: para conectar nuestro dispositivo a Wi-Fi necesitaremos introducir el nombre y contraseña de nuestra red. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¡Vamos a conectarnos! (Parte 3) Instalamos Arduino Create Agent Para poder conectar nuestro dispositivo a IoT Cloud, vamos a tener que instalar un programita adicional, el Arduino Create Agent. Lo que nos va a permitir es que nuestro Arduino sea reconocido por la plataforma, podremos subir los programas que escribamos y podremos ver la información transmitida por el puerto serie directamente. MAC OS Haremos click en START y nos aparecerá la siguiente pantalla en la cual ya podremos descargar la aplicación: Una vez se haya descargado, iremos a la carpeta de Descargas y haremos doble click en el instalador.  Una vez ahí, seguiremos las instrucciones. Si vas a usar un navegador que no sea Google Chrome o Mozilla Firefox, asegúrate de responder Sí en el paso de compatibilidad con el navegador (Browser Support) . Una vez lo hayamos instalado, haremos click en siguiente (NEXT) y veremos el icono de Arduino en la parte superior de nuestro ordenador:  LINUX El proceso es muy similar, también tendremos que descargar la aplicación. Nos descargará un ejecutable comprimido en tar.gz (formato de Linux) y al hacer doble clic sobre él, el asistente nos guiará para su instalación. Si todo ha ido bien, veremos al final una pantalla como esta: WINDOWS El proceso es muy similar, también tendremos que descargar la aplicación, solo que en este caso nos dará la opción de descargarlo para Win32 o Win64, dependiendo de la arquitectura de nuestro ordenador. Si no lo sabemos, nos aparecerá marcada en verde oscuro la opción correcta: Una vez se haya descargado, iremos a la carpeta de Descargas y haremos doble click en el instalador. Una vez ahí, seguiremos las instrucciones. Si vas a usar un navegador que no sea Google Chrome o Mozilla Firefox, asegúrate de responder Sí en el paso de compatibilidad con el navegador (Browser Support) . En Windows, puede que recibas una advertencia de seguridad y se te pedirá que apruebes la instalación de un certificado raíz (root) de Arduino. Elige Sí para instalar el certificado y continúa con la instalación. Si la instalación ha ido bien, verás esta pantalla:  ¿Cómo comprobamos que Create Agent funciona? Para asegurarnos de que Create Agent no está en pausa, buscaremos el icono del Create Agent   en la parte superior derecha de la barra de menús (macOS ) o en la parte inferior derecha de la barra de tareas (Windows, Linux), normalmente dentro de la bandeja del sistema. Si hace click en él y la opción Reanudar Agente (Resume Agent) está disponible, el agente está actualmente en pausa. Haga clic en Reanudar Agente para reanudar. Cuando esté funcionando, nos dará la opción de pausarlo haciendo click en Pause Agent : ¿Qué problemas podemos encontrarnos? Tenemos que asegurarnos de tener permiso de administrador; si el ordenador que estás utilizando no es tu propio ordenador personal, pide a tu administrador de TI un perfil actualizado. A veces la instalación del agente puede ser bloqueada por el cortafuegos (firewall) o el software antivirus; en este último caso, puedes intentar añadir el agente a tu lista blanca de antivirus. FUENTES: Instalar Create Agent: https://support.arduino.cc/hc/en-us/articles/360014869820-Install-the-Arduino-Create-Agent Cómo comprobar si Create Agent está funcionando: https://support.arduino.cc/hc/en-us/articles/4980687506844-Check-if-the-Arduino-Create-Agent-is-installed-and-running Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¡Vamos a conectarnos! (Parte 4) Configuramos nuestro dispositivo El proceso de configuración es rápido y sencillo (bueno, eso nos dicen desde Arduino, pero ya veremos...), y se puede realizar pulsando el botón "Seleccionar dispositivo" ( Select Device ) en la vista general de Thing. Cuando ya tengamos placas vinculadas, podremos elegir entre cualquier placa que haya sido configurada, o seleccionar la opción "Configurar nuevo dispositivo". Una vez ahí nos dará dos opciones:  Escogeremos la primera y nos pedirá que conectemos nuestro dispositivo, en este caso el Arduino Nano 33 IoT, al ordenador. Es aconsejable que si tenemos otros dispositivos conectados a nuestro ordenador a través de algún puerto USB, los desconectemos: Una vez lo hayamos conectado a uno de nuestros puertos USB, tendremos que tener bastante paciencia. ¿Por qué? Bueno, en este punto nos pueden pasar varias cosas: 1. Esta pantalla nos puede dejar varios minutos esperando hasta decirnos si nuestro dispositivo ha sido reconocido o no, y después de haber esperado un rato, puede que nos diga que el dispositivo no ha sido reconocido. No pasa nada, lo que haremos será desconectar nuestro Arduino , cerrar la ventana emergente de Setup device y repetir el proceso anterior. 2. Si a la segunda no nos funciona, lo intentaremos una tercera vez. 3. Si así tampoco, lo conectaremos a otro puerto USB y repetiremos el proceso. Finalmente obtendremos esto:  Haremos click en CONFIGURE y la próxima ventana emergente nos mostrará nuestro Arduino, al que le habrán asignado un nuevo nombre. Nosotros podremos cambiarlo por otro si queremos, aunque no es necesario: Una vez tengamos el nombre, haremos click en NEXT y comenzará un proceso que, al igual que en el paso Setup Device, nos puede llevar varios minutos y acabar generándonos errores, por lo que es posible que tengamos que repetir el proceso varias veces. Así que, paciencia. Veremos esta ventana emergente: Nos dicen que en el primer paso van a subir un programita a nuestro Arduino que hará que sea configurado para comunicarse de manera segura con IoT Cloud. Nos avisan de que puede costar hasta 5 minutos, pero puedo asegurarte que, en ocasiones, puede alargarse unos cuantos minutos más. Una vez el sketch haya sido subido a nuestro Arduino, pasará al paso 2: En ese paso se comprobará la conectividad, y es el paso que nos puede dar errores... haciendo que tengamos que desconectar nuestro Arduino y volver a conectar. Sobre todo, NO DESCONECTES EL ARDUINO SI NO TE HA DICHO QUE HA HABIDO UN ERROR, porque es probable que el proceso esté funcionando correctamente, solo que por problemas de conexión esté tardando más tiempo del que se consideraría normal. Por eso, te pido, PACIENCIA. Y una vez lo hayamos conseguido:  Y ya, por fin, nos aparecerá nuestro Arduino en la parte derecha como dispositivo asociado ( Associated Device ) a nuestra cuenta de IoT Cloud: Si ahora vamos al apartado Devices (Dispositivos), veremos que ya nos aparece nuestro Nano 33 IoT. Aunque esté conectado, pondrá que está Offline, no te preocupes, eso ya lo veremos más adelante: Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU ¡Vamos a conectarnos! (Parte 5) Ahora, necesitaremos proporcionar nuestro nombre y clave de red Wi-Fi para poder conectar nuestro proyecto a Internet. Estas credenciales se añadirán automáticamente al programa que cargaremos en nuestro Arduino, de eso no tendremos que preocuparnos nosotros, se encarga IoT Cloud.  Una vez hagamos click en Configure del apartado Network : Nos aparecerá esta ventana emergente, en la que introduciremos los datos: Este proceso no debería generarnos ningún error, a no ser que no hayas escrito correctamente alguno de los dos campos. Asegúrate y revísalos si te da algún problema. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Conectemos nuestro microcontrolador a la red Wifi Antes de comenzar con la parte práctica sobre el internet de las cosas (IoT), vamos a ver un componente de nuestro Arduino Nano 33 IoT que es el que nos va a permitir la interconexión con redes Wi-Fi. Como ya hemos visto, nuestro Arduino tiene un LED integrado, un acelerómetro y un giroscopio; pues aparte de eso, también tiene un módulo que permite que nos conectemos a una red Wi-Fi: el NINA-W102 . ¿Qué es el módulo NINA-W102? El componente que vemos dentro del recuadro azul claro es el que nos va a permitir la conexión a una red Wi-Fi. Consta de una memoria Flash, un cristal, una antena y otros componentes de adaptación y filtrado que nos permiten conectarnos con seguridad a la red. La antena es la parte que sobresale un poco, en la imagen es la parte que está más a la izquierda. Esta antena es bastante delicada , al igual que el conector USB, así que tenemos que tener cuidado de no golpearla o romperla, porque, si no, el módulo dejará de funcionar La librería WiFiNINA Esta librería nos va a permitir utilizar el módulo NINA-W102 sin tener que entrar en programación demasiado complicada. Desde los años 90 hasta ahora, se han desarrollado protocolos de seguridad que permiten conexiones más seguras como el WEP, WPA y WPA2, todos ellos son soportados por nuestra librería WiFiNINA. Si quieres saber más sobre estos tipos de cifrado, haz click aquí . ¿Qué vamos a hacer en este proyecto? En este proyecto, vamos a: 1. Obtener la información de una red Wi-Fi como el SSID, la IP de la placa y la fuerza de la señal. Con esta información podremos hacer que el LED_BUILTIN de la placa parpadee más rápido o más lento en función de la intensidad de la señal de la red. 2. Aprender cómo usar el Arduino Web Editor . En lugar de usar la IDE de Arduino , que ya hemos utilizado para programar nuestro proyecto en las prácticas anteriores, en este caso vamos a programar nuestro proyecto desde el editor online . ¿Por qué? Aparte de para que veas que también tienes esta opción, porque nos va a facilitar la vida a la hora de crear una cosa llamada Secret Tab . ¡Comenzamos! Para este proyecto vamos a necesitar la cuenta de Arduino que ya hemos creado y también será necesario haber instalado el Arduino Create Agent, que también deberías tener instalado si has seguido en orden este curso. Lo primero que haremos será acceder a Arduino Web Editor . Una vez hayamos introducido nuestro usuario y contraseña, veremos una pantalla similar a esta, en la que lo primero que haremos será crear un nuevo sketch: Por defecto, se habrá creado con el nombre 'sketch' seguido del mes, el día, y una letra del abecedario. En la imagen superior, puedes ver que el nombre por defecto que me ha creado ha sido sketch_sep29a . Así que, a continuación, renombraremos nuestro sketch de una manera que nos podamos acordar fácilmente de qué va el proyecto. Por ejemplo, yo lo renombraría Conexion-wifi . Te aconsejo que no uses tildes ni caracteres especiales. Para renombrarlo, haremos click en la flecha que aparece a la derecha del nombre de nuestro sketch recién creado y seleccionaremos la opción Rename Sketch... : Importamos la librería Una vez tengamos nuestro sketch creado y renombrado, vamos a importar la librería WiFiNINA . Para ello iremos a la columna azul de la izquierda y haremos click sobre Libraries: Veremos que en la columna blanca de la izquierda ahora nos aparecen diferentes opciones. En la parte superior pone LIBRARY MANAGER y justo debajo un campo en color gris, SEARCH LIBRARIES (te lo indico con una flecha)en el que nos permite buscar entre las diferentes librerías: Cuando busquemos WIFININA , veremos que no nos aparece : Así que, tendremos que hacer click en LIBRARY MANAGER y se nos abrirá una ventana emergente. Ahí encontraremos una librería que se llama WIFININA_GENERIC. Tendremos que añadirla a nuestras librerías favoritas haciendo click sobre la estrella: Una vez la hemos añadido, haremos click en DONE. Nos aparecerá en la pestaña de nuestras librerías favoritas y desde ahí pondremos nuestro ratón encima de la librería y veremos que nos aparece el botón INCLUDE. Haremos click y veremos que una nueva línea se ha añadido a nuestro sketch: Si recuerdas, este proceso de importar una librería ya lo hicimos en la Práctica 2.2 . En ese caso desde la IDE de Arduino, en lugar desde el editor online.  Conectamos nuestro NANO 33 IoT Conectaremos nuestro Arduino y nos aseguraremos de seleccionarlo en la barra horizontal en la que pone --Select Board or Port-- : Creamos una Secret Tab A continuación, crearemos una Secret Tab que se encargará de almacenar las credenciales de nuestra red Wi-Fi. Para ello, haremos click en el triángulo negro hacia abaj o que aparece en la parte superior de nuestro sketch, al lado de ReadMe.adoc: Veremos que ahora tenemos 3 pestañas: Conexión_wifi.ino, ReadMe.adoc y Secret: Añadimos las credenciales de nuestra red Volveremos a nuestra pestaña Conexion_wifi.ino y pegaremos lo siguiente: //introducimos nuestras credenciales char ssid[] = SECRET_SSID; // SSID de la red(nombre) char pass[] = SECRET_PASS; // contraseña de la red Si  ahora volvemos a la pestaña Secret, veremos que aparecen dos campos nuevos en los cuales podemos escribir nuestro usuario y contraseña de la red WiFi. En SECRET_SSID escribiremos el nombre de la red y en SECRET_PASS la contraseña: Veamos el código Antes de la función setup() Ahora que ya tenemos nuestra Secret Tab configurada, podemos volver a la pestaña Conexion_wifi.ino y ver el código necesario para que el LED de nuestro Arduino parpadee más rápido cuando la intensidad de la señal de nuestra red sea mayor. Lo primero que necesitaremos será  inicializar cinco variables  para almacenar el estado de la radio Wi-Fi, el estado del LED y la hora de la última actualización. int status = WL_IDLE_STATUS; // estado de la radio Wi-Fi int ledState = LOW; //Estado del LED (encendido o apagado) unsigned long previousMillisInfo = 0; //almacenará la última vez que se actualizó la información del Wi-Fi unsigned long previousMillisLED = 0; // almacena la última vez que se actualizó el LED const int intervalInfo = 5000; // intervalo al que actualizaremos la información En estas 5 variables encontramos distintos tipos, el int ya lo conocemos, es un n úmero entero , pero el unsigned long es nuevo. Lo que significa es que el valor que almacena es un entero que puede alcanzar un valor bastante alto, pero a diferencia de los long normales, los unsigned long solo pueden almacenar valores positivos . En la línea 5, vemos que delante de int aparece la palabra const . Esto significa que este valor será constante y que, aunque queramos, no lo vamos a poder modificar. Tu sketch debería tener el siguiente aspecto: Dentro de la función setup() En la función setup() iniciamos la comunicación en serie a 9600 baudios , seguido de while(!Serial) que básicamente significa que a menos que abramos el Monitor Serial el programa no se ejecutará. Luego usamos pinMode() para establecer el pin LED_BUILTIN como un OUTPUT. void setup() { //Inicializa el puerto serial y lo abre Serial.begin(9600); while (!Serial); // Configuramos el LED como salida pinMode(LED_BUILTIN, OUTPUT); A continuación seguiremos añadiendo líneas dentro de setup() Crearemos un bucle while() que comprobará si estamos conectados a la Wi-Fi. Si no lo estamos, intentará conectarnos a ella. Para ello utilizamos status = WiFi.begin(ssid, pass) ; para empezar a conectarnos a la Wi-Fi, y un retraso de 10 segundos para darle tiempo a conectarse: // Intentamos conectar a red Wi-Fi while (status != WL_CONNECTED) { Serial.print("Attempting to connect to network: "); Serial.println(ssid); // Conectamos a red WPA/WPA2: status = WiFi.begin(ssid, pass); // Esperamos 10 segundos para conectar delay(10000); } Al final de la función setup() utilizamos dos Serial.println() para imprimir en el monitor serie que, si todo va bien, ahora estamos conectados a la red y para separar el bloque de datos. // Una vez estamos conectados, imprimimos la información Serial.println("You're connected to the network"); Serial.println("---------------------------------------"); } El aspecto final de la función setup() sería el siguiente: Dentro de la función loop() En  la función loop() inicializaremos una nueva variable que almacenará el tiempo desde que el sketch comienza a ejecutarse. A continuación, utilizaremos un if() para comprobar si el tiempo después de la última actualización es mayor que el intervalo que hemos establecido antes, en las 5 variables del principio . void loop() { unsigned long currentMillisInfo = millis(); // Comprueba si el tiempo que ha pasado desde la última actualización es mayor que el intervalo fijado if (currentMillisInfo - previousMillisInfo >= intervalInfo) { Si entramos en el if, significa que ha llegado el momento de actualizar la información, así que lo primero que haremos dentro de la función if() es darle a la variable previousMillisInfo el valor del momento actual con currentMillisInfo. Luego imprimiremos tres tipos diferentes de información usando tres funciones que nos proporciona la librería WifiNINA: La dirección IP de la placa usando la función WiFi.localIP() Nombre de la red a la que está conectada usando la función WiFi.SSID() Intensidad de la señal utilizando la función WiFi.RSSI() previousMillisInfo = currentMillisInfo; Serial.println("Board Information:"); // Imprime la dirección IP de nuestro Arduino: IPAddress ip = WiFi.localIP(); Serial.print("IP Address: "); Serial.println(ip); // Imprime el SSID de nuestra Red: Serial.println(); Serial.println("Network Information:"); Serial.print("SSID: "); Serial.println(WiFi.SSID()); // Imprime la fuerza de señal recibida: long rssi = WiFi.RSSI(); Serial.print("signal strength (RSSI):"); Serial.println(rssi); Serial.println("---------------------------------------"); } Después de esto, ya solo nos queda ocuparnos del LED. Necesitaremos inicializar otras dos variables, una para llevar la cuenta del tiempo del LED y otra para convertir la fuerza de la señal medida por la función WiFi.RSSI() a un intervalo de tiempo que será la velocidad a la que parpadeará nuestra lucecita. unsigned long currentMillisLED = millis(); // measure the signal strength and convert it into a time interval int intervalLED = WiFi.RSSI() * -10; Por último, creamos otro if() para comprobar si el tiempo después del último parpadeo es mayor que el intervalo, de la misma manera que hicimos antes. Dentro de la sentencia if() añadimos una nueva sentencia else if() para encender el LED si estaba apagado y viceversa, y una sentencia digitalWrite() para establecer el estado del LED. // Comprueba si el tiempo desde el último parpadeo del LED es mayor que el intervalo fijado if (currentMillisLED - previousMillisLED >= intervalLED) { previousMillisLED = currentMillisLED; // si el LED está apagado, enciéndelo y viceversa if (ledState == LOW) { ledState = HIGH; } else { ledState = LOW; } // set the LED with the ledState of the variable: digitalWrite(LED_BUILTIN, ledState); } } El aspecto de tu función loop() debería ser el siguiente: De todas formas, aquí tiene todo el código en un bloque, por si lo prefieres copiar de una vez y evitar fallos: // WiFiNINA_Generic - Version: Latest #include //please enter your sensitive data in the Secret tab char ssid[] = SECRET_SSID; // your network SSID (name) char pass[] = SECRET_PASS; // your network password (use for WPA, or use as key for WEP) int status = WL_IDLE_STATUS; // the Wi-Fi radio's status int ledState = LOW; //ledState used to set the LED unsigned long previousMillisInfo = 0; //will store last time Wi-Fi information was updated unsigned long previousMillisLED = 0; // will store the last time LED was updated const int intervalInfo = 5000; // interval at which to update the board information void setup() { //Initialize serial and wait for port to open: Serial.begin(9600); while (!Serial); // set the LED as output pinMode(LED_BUILTIN, OUTPUT); // attempt to connect to Wi-Fi network: while (status != WL_CONNECTED) { Serial.print("Attempting to connect to network: "); Serial.println(ssid); // Connect to WPA/WPA2 network: status = WiFi.begin(ssid, pass); // wait 10 seconds for connection: delay(10000); } // you're connected now, so print out the data: Serial.println("You're connected to the network"); Serial.println("---------------------------------------"); } void loop() { unsigned long currentMillisInfo = millis(); // check if the time after the last update is bigger the interval if (currentMillisInfo - previousMillisInfo >= intervalInfo) { previousMillisInfo = currentMillisInfo; Serial.println("Board Information:"); // print your board's IP address: IPAddress ip = WiFi.localIP(); Serial.print("IP Address: "); Serial.println(ip); // print your network's SSID: Serial.println(); Serial.println("Network Information:"); Serial.print("SSID: "); Serial.println(WiFi.SSID()); // print the received signal strength: long rssi = WiFi.RSSI(); Serial.print("signal strength (RSSI):"); Serial.println(rssi); Serial.println("---------------------------------------"); } unsigned long currentMillisLED = millis(); // measure the signal strength and convert it into a time interval int intervalLED = WiFi.RSSI() * -10; // check if the time after the last blink is bigger the interval if (currentMillisLED - previousMillisLED >= intervalLED) { previousMillisLED = currentMillisLED; // if the LED is off turn it on and vice-versa: if (ledState == LOW) { ledState = HIGH; } else { ledState = LOW; } // set the LED with the ledState of the variable: digitalWrite(LED_BUILTIN, ledState); } } Una vez hayamos copiado el código a nuestro sketch, habrá llegado el momento de verificar que todo está correcto. En este caso, si hemos seguido todos los pasos , no nos debería dar ningún problema, pero cuando escribamos nuestro propio código, podemos obtener errores. Para verificar el código, haremos click sobre el símbolo tick , que aparece en la siguiente imagen dentro de un recuadro rojo . Una vez lo hayamos verificado, nuestro código estará listo para ser subido a nuestro Arduino. Así que, haremos click sobre la flecha hacia la derecha , que en la imagen aparece dentro de un recuadro azul : Nuestro Arduino puede tardar unos segundos (a veces algún minuto) en subir el código y cuando lo haga veremos el mensaje ' Sucess:...' dentro del cuadrado verde, en la zona de la consola de nuestro sketch. Para ver los diferentes valores que obtenemos necesitaremos abrir el puerto serie de nuestro Arduino. Para ello iremos a la columna de la izquierda y haremos click sobre Monitor . Veremos que en la columna justo a la derecha se comenzarán a actualizar valores y aparecerá información como el nombre de la red a la que estamos conectados y la fuerza de la señal que recibimos. Si estamos trabajando con un ordenador portátil, puedes experimentar acercándote con él y tu Arduino hacia tu router. Verás como la luz de Arduino parpadea más rápido y también los valores que aparecen a la derecha de signal strength aumentan. ¿Qué tenemos que entregar? Graba un video en el que primero se vea la pantalla con el monitor serie abierto y cómo se actualiza la información sobre la intensidad con la que se recibe la señal y luego muevas la cámara para enfocar tu NANO con el LED parpadeando. Para enviarlo puedes mandar el video en formato gif o subirlo a Youtube o a Drive, configurarlo como oculto solo para aquellos que tengan el enlace, y compartir el enlace en la tarea correspondiente del moodle del curso. FUENTES: Conectar Arduino a WiFi: https://docs.arduino.cc/tutorials/nano-33-iot/wifi-connection Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Tic tac, tic tac Ahora que ya hemos conectado nuestro Arduino a internet, iremos un paso más allá y conectaremos nuestro Arduino a IoT Cloud para crear una alarma que funcione con el reloj interno de nuestro Arduino. Esta alarma lo que hará es encender un LED virtual cuando sea la hora que nosotras decidamos. No vamos a necesitar material adicional únicamente nuestro NANO 33 IoT y el cable USB para conectarlo a nuestro ordenador. RTC: el reloj de nuestro Arduino Un reloj en tiempo real es un reloj que lleva la cuenta de la hora actual y puede utilizarse para programar acciones específicas en un momento determinado. El término reloj en tiempo real (RTC) se utiliza para evitar la confusión con los relojes de hardware ordinarios , que son sólo señales que gobiernan la electrónica digital, y no son usados para contar en horas, minutos y segundos, sino que se utilizan para el funcionamiento interno del propio componente electrónico. La mayoría de los RTC (Real Time Clock) utilizan un oscilador de cristal cuya frecuencia es de 32,768 KHz (la misma frecuencia utilizada en los relojes de cuarzo). Además, el RTC sigue funcionando en modo de reposo, por lo que se puede utilizar para despertar el dispositivo de los modos de reposo de forma programada. Cada vez que se alimenta la placa, el RTC se resetea y comienza desde la fecha estándar. Para mantener la hora y el RTC en funcionamiento es necesario mantener el dispositivo alimentado. Para utilizar este reloj, usaremos la librería RTCZero . Esta librería nos permite controlar y utilizar el RTC interno en todas las placas Arduino con la arquitectura SAMD (como la que tiene nuestro NANO 33 IoT). La librería se encarga de la inicialización del RTC interno e incluye varias funciones que utilizaremos en esta práctica. Para saber más sobre esta librería, haz click aquí . Primer paso: Creamos nuestra primera Thing Para poder conectar a nuestro NANO 33 IoT, tendremos que crear un componente virtual llamado 'Thing'. Estas 'cosas' son las que permiten que nuestros proyectos se comuniquen con IoT Cloud. Como dicen en la imagen siguiente, estas Thing pueden también comunicarse entre ellas, aunque por el momento, nosotros solo crearemos una de ellas. Para crearla, iremos al menú horizontal superior (Things, Dashboards, Devices, Integrations and Templates) y haremos click donde pone Things . Renombramos nuestra thing como Nano Alarm , aunque puedes escoger otro nombre si lo prefieres, te aconsejo que sea descriptivo, haciendo click sobre el rectángulo en el que pone Untitled : Una vez hemos cambiado el nombre, el siguiente paso será vincular un dispositivo a nuestra Thing. En este punto, conectaremos nuestro Arduino al ordenador por USB.  Ahora, haremos click en el apartado Associated Device y ahí en  Select Device.  Como ya lo habíamos asociado antes, nos debería aparecer esta pantalla, en la que IoT Cloud ya lo reconoce, si no, seguiremos los pasos que nos indique y que serán parecidos a los que ya seguimos :  Segundo paso: creamos nuestras variables Cuando hayamos configurado nuestro NANO 33 IoT, nos aparecerá en la columna de la derecha, como en la imagen inferior. Aunque en esta imagen aparezca online, por el momento no te preocupes si el tuyo aparece offline . Para añadir nuestras variables, haremos click en ADD VARIABLE.  Esto abrirá una nueva ventana, donde podemos elegir el nombre, el tipo de datos, la configuración de permisos y la configuración de actualización. Nos aparecerá la siguiente ventana:  En ella introduciremos la información de nuestra primera variable: Name: alarm_state Select variable type: boolean Variable Permission: Read & Write Variable Update Policy: On change Le daremos a ADD VARIABLE y nos aparecerá así: Haremos lo mismo con las siguientes variables: Nombre  Tipo de datos Permiso de la variable Uso alarm_state boolean Read & Write Activa o desactiva la alarma hours_alarm int Read & Write Establece la hora de la alarma minutes_alarm int Read & Write Establece los minutos de la alarma seconds_alarm int Read & Write Establece los segundos de la alarma led boolean Read Only Indica si la alarma está activada o no El tipo de datos int nos aparecerá como Integer Numbe r: Una vez hayamos creado todas las variables, nos aparecerán como en la siguiente imagen: El orden en que nos aparezcan puede variar, pero eso no es problema. Lo importante es que alarm_state y led tengan valores boolean y que tanto hours_alarm, minutes_alarm y seconds_alarm tengan valores integer. Tercer paso: introducimos las credenciales de nuestro Wi-Fi No debemos olvidar introducir las credenciales de nuestra red . Ese proceso ya te lo he explicado en este apartado . Una vez hayamos introducido el nombre y contraseña de nuestro Wi-Fi, haremos click sobre el apartado Dashboards, justo a la derecha de Thing . Cuarto paso: creamos nuestro dashboard Una vez hagamos click sobre Dashboards , veremos la siguiente pantalla, en la que pulsaremos sobre BUILD DASHBOARD : Es el momento de cambiar el nombre de nuestro dashboard " Untitled " por Nano Alarm y empezar a añadir los diferentes widgets que necesitaremos: Para ello hacemos clic en el botón ADD, en la esquina superior izquierda y nos aparecerá esta ventana emergente:  El dashboard necesita cinco widgets en total, cada uno de ellos aparece en la siguiente tabla. Widget Variable a la que se conecta value hours_alarm value minutes_alarm value seconds_alarm switch alarm_state led led Una vez que seleccionemos cada uno de los widgets, necesitaremos vincular cada widget a una de las variables que ya creamos en el paso anterior. Revisa la tabla de arriba para conocer las correspondencias entre widgets y variables. Una vez hayamos creado todos los widgets, podemos organizarlos como queramos pulsando el botón de las flechas de la parte superior izquierda, pero realmente, si los has creado en orden, deberían tener este aspecto, que está bastante organizado: Quinto paso: creamos el código Todas las configuraciones que hemos hecho hasta ahora, han sido básicamente compiladas en un sketch especial. Este sketch contiene información sobre el dispositivo que estamos utilizando, un ID único de nuestra Thing, las variables que hemos creado y la información de red que hemos introducido. Todo lo que tenemos que hacer ahora, es añadir algo de código al sketch para crear la alarma. Le daremos a Things  en el menu superior horizontal y nos aparecerá Thing llamada "Nano Alarm". Ahí, hacemos clic en la pestaña Sketch . Aquí, deberíamos ver un boceto generado automáticamente. Este boceto es prácticamente un "caparazón" para el código que añadiremos a continuación, lo que significa que aún no tiene ninguna funcionalidad. Lo primero que haremos será añadir las librerías que necesitaremos y crear un objeto llamado alarma, del tipo RTCZero: #include "thingProperties.h" #include "RTCZero.h" RTCZero alarm; Después, necesitaremos iniciar la comunicación a través del puerto serial en 9600 baudios, como ya hicimos en la práctica del acelerómetro : void setup() { // Initialize serial and wait for port to open: Serial.begin(9600); Para asegurarnos de que nuestro Arduino se conecta a IoT Cloud, le pediremos que nos imprima la información sobre esa conexión con printDebugInfo(). Seguidamente inicializaremos nuestro objeto alarm, que hemos creado un poco antes y apagaremos nuestro LED dándole el valor false: ArduinoCloud.printDebugInfo(); alarm.begin(); led = false; } Ahora, pasaremos al la función loop(). Después de actualizar la información enviada a IoT Cloud con la función update(), imprimiremos por el puerto serie la hora, minutos y segundos reales: void loop() { ArduinoCloud.update(); Serial.print(alarm.getHours()); Serial.print(":"); Serial.print(alarm.getMinutes()); Serial.print(":"); Serial.println(alarm.getSeconds()); } Ahora, veremos que después del loop() hay algunas funciones vacías. Estas funciones han sido creadas automáticamente desde la nube y no deben ser eliminadas o el sketch no compilará. Estas funciones se crean cuando añadimos una nueva variable con permiso de lectura y escritura, y son llamadas cada vez que cambiamos el valor de la variable desde IoT Cloud. Así, para establecer una nueva hora de alarma cada vez que cambiamos el valor desde la nube, tenemos que añadir una función .setAlarmTime() dentro de las funciones que estaban vacías: void onHoursAlarmChange() { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); } void onMinutesAlarmChange() { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); } void onSecondsAlarmChange() { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); } La función onAlarmStateChange() es llamada cada vez que encendamos o apaguemos nuestra alarma desde el interruptor (Switch) que hemos creado antes en nuestra Dashboard. Activaremos la alarma si el interruptor está en ON (true) y lo desactivaremos si lo colocamos en OFF (false). Aquí, necesitaremos un condicional para ver si el interruptor está encendido o apagado. Si la alarma está encendida, usaremos las funciones .setAlarmTime() , .enableAlarm() y . attachInterrupt() , que ya vienen programadas y vinculadas a nuestro objeto alarm, para activarla. Si el interruptor está apagado, usaremos la función .disableAlarm() para desactivar nuestra alarma y apagaremos nuestro LED: void onAlarmStateChange() { if (alarm_state == true) { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); alarm.enableAlarm(alarm.MATCH_HHMMSS); alarm.attachInterrupt(alarmMatch); } else { alarm.disableAlarm(); led = false; } } El último paso es crear una nueva función llamada .alarmMatch() que controlará lo que ocurre cuando la alarma coincida con la hora real enviada por nuestro NANO 33 IoT. En este caso, usaremos esta función para encender el LED de la Nube poniendo el valor del LED a true: void alarmMatch() { led = true; } Por si te has perdido en algún paso copiando y pegando el código, lo encuentras todo a continuación: /* Sketch generated by the Arduino IoT Cloud Thing "Nano_Alarm" Arduino IoT Cloud Variables description The following variables are automatically generated and updated when changes are made to the Thing int hours_alarm; int seconds_alarm; int minutes_alarm; bool alarm_state; bool led; Variables which are marked as READ/WRITE in the Cloud Thing will also have functions which are called when their values are changed from the Dashboard. These functions are generated with the Thing and added at the end of this sketch. */ #include "thingProperties.h" #include "RTCZero.h" RTCZero alarm; void setup() { // Initialize serial and wait for port to open: Serial.begin(9600); // This delay gives the chance to wait for a Serial Monitor without blocking if none is found delay(1500); // Defined in thingProperties.h initProperties(); // Connect to Arduino IoT Cloud ArduinoCloud.begin(ArduinoIoTPreferredConnection); /* The following function allows you to obtain more information related to the state of network and IoT Cloud connection and errors the higher number the more granular information you'll get. The default is 0 (only errors). Maximum is 4 */ setDebugMessageLevel(2); ArduinoCloud.printDebugInfo(); alarm.begin(); led = false; } void loop() { ArduinoCloud.update(); Serial.print(alarm.getHours()); Serial.print(":"); Serial.print(alarm.getMinutes()); Serial.print(":"); Serial.println(alarm.getSeconds()); } void onHoursAlarmChange() { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); } void onMinutesAlarmChange() { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); } void onSecondsAlarmChange() { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); } void onAlarmStateChange() { if (alarm_state == true) { alarm.setAlarmTime(hours_alarm, minutes_alarm, seconds_alarm); alarm.enableAlarm(alarm.MATCH_HHMMSS); alarm.attachInterrupt(alarmMatch); } else { alarm.disableAlarm(); led = false; } } void alarmMatch() { led = true; } Una vez lo tengamos en nuestro sketch, llegará el momento de verificarlo, haciendo click sobre el icono del tick y posteriormente subirlo a nuestro Arduino haciendo click sobre la flecha hacia la derecha: Una vez lo hayamos subido, veremos algo parecido a esto: Si te has fijado, la hora en mi ordenador son las 14:50 y no las 12:50 cuando la alarma se enciende. Eso es porque mi Arduino daba la hora con 2h de retraso. ¿Cómo podemos solucionarlo? Muy fácil, en nuestro código he modificado una línea, la que aparece en el siguiente bloque en la línea 3, y le he restado 2h a la hora a la que he fijado mi alarma, para que así coincida con la hora de mi Arduino: void onAlarmStateChange() { if (alarm_state == true) { alarm.setAlarmTime(hours_alarm-2, minutes_alarm, seconds_alarm); alarm.enableAlarm(alarm.MATCH_HHMMSS); alarm.attachInterrupt(alarmMatch); } else { alarm.disableAlarm(); led = false; } } Para saber la hora de nuestro Arduino, abviamente con nuestro Arduino conectado, tendremos que abrir el puerto serie. Para ello, haremos clic en la lupa que se ve en la siguiente imagen: Una vez sepamos la hora de nuestro Arduino, podremos escribirla correctamente en nuestra Alarma. Ahora ya funciona perfectamente: Tenemos que considerar que al ser un servicio conectado a Internet, hay cierta latencia y los valores no se actualizan inmediatamente. Si queremos comprobar que nuestra alarma funciona, es mejor que la pongas con un margen de unos 2 o 3 minutos. Problema frecuente Puede que nuestro Arduino nos aparezca offline aunque nos permita subir el código. 1. Elimina tu Arduino completamente de Devices y vuélvelo a instalar. 2. Como IoT Cloud es un servicio que vamos a utilizar en su versión gratuita, puede presentar latencias y problemas de conexión si hay mucha gente utilizándolo. En mi experiencia personal, he tenido más problemas tratando de conectarme por las mañanas que por las tardes. 3. Para realizar pruebas, te aconsejo que te crees dos cuentas en Arduino IoT Cloud, utilizando dos cuentas de email diferentes, para poder alternar tus proyectos entre ellas. Puede ocurrir que tu Arduino te aparezca offline en una de tus cuentas y online en la otra. ¿Qué tenemos que entregar? Graba un video similar al .gif que aparece en el apartado anterior, que se vea la alarma apagada y que cuando marca la hora se encienda el LED. Para enviarlo puedes mandar el video en formato gif o subirlo a Youtube o a Drive, configurarlo como oculto solo para aquellos que tengan el enlace, y compartir el enlace en esta tarea. FUENTES: Alarma con Arduino 33 IoT: https://docs.arduino.cc/tutorials/nano-33-iot/iot-cloud Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Proyecto Final En esta última parte del curso, me gustaría que idearas un proyecto en el que combines parte de los sensores que hemos utilizado con la plataforma IoT Cloud, para poder implementar lo que hemos visto en este curso dentro de tus clases. Para ello, lo primero que vas a tener que hacer es pensar en una aplicación de los sensores y actuadores que hemos utilizado, y con pensar en una aplicación me refiero a que vas a tener que pensar en una situación en la que estos sensores y actuadores podrían ayudar a resolver un problema o a llamar la atención sobre una determinada cuestión. Una pregunta con la que comenzar podría ser, ¿podría un vestible solucionar o hacernos reflexionar sobre qué problema/situación? Algunos consejos No te compliques la vida intentando integrar varios sensores y actuadores. Es mejor utilizar un solo sensor y un único actuador . Una vez funcione, podremos plantearnos añadir más elementos. El actuador que escojas para tu proyecto si es físico tiene que ser el LED pero también puede ser virtual, como el LED que nos ofrece Arduino IoT Cloud y que ya utilizamos en una de las prácticas anteriores . ¿Qué tengo que presentar? MEMORIA: Extensión: no más de 5 páginas (sin contar la portada) Página 0: portada con nombre completo, título del proyecto Página 1: Motivación: por qué este proyecto; Elección de sensores y actuadores Páginas 2-3: Funcionamiento: qué harán los sensores, adaptación del código que hemos visto a nuestro proyecto. Será necesaria una transcripción del código que utilices. Páginas 4-5: Conclusiones, dificultades encontradas y referencias o fuentes de inspiración DOCUMENTACIÓN: Será necesario un video o gif de menos de 1 minuto en el que se vea el funcionamiento. Un pequeño ejemplo En el .gif que puedes ver a continuación, he usado el código de uno de nuestros sketchs, el que utilizábamos con el acelerómetro, para enviar el cambio en el eje x a IoT Cloud y poder almacenarlo en la nube. Ha sido necesario realizar algunas adaptaciones, como crear la variable x en IoT Cloud (ya hemos visto en las prácticas anteriores cómo se hacía) y eliminarla del sketch, para que no aparezca como duplicada. A partir de este pequeño ejemplo, si quisiera, podría encender un LED virtual si ese eje alcanzará una posición determinada. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU Créditos Curso creado en Octubre de 2022 por: Marta Pérez Campos Cualquier observación o detección de error en soporte.catedu.es Los contenidos se distribuyen bajo licencia Creative Commons tipo BY-NC-SA excepto en los párrafos que se indique lo contrario. Financiado por el Ministerio de Educación y Formación Profesional y por la Unión Europea - NextGenerationEU