Archivo de la categoría: Arduino

Montaje Prácticas

Para el curso vamos a usar un entorno de trabajo fijo con diversas entradas y salidas analógicas y digitales, que una vez montado se usará en diferentes prácticas.

Para hacer el montaje se usará una protoboard por separado y no la protoboard que viene con el kit de Arduino. Este montaje no se desmontará durante todo el curso.

Esquemas fritzing disponibles en: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019/tree/master/Esquemas%20Montajes%20Pr%C3%A1cticas%20Fritzing

Montaje Arduino UNO

Elementos:

  • PIN 2: Botón A. Resistencia pullup interna
  • PIN 3: Botón B. Resistencia pulldown externa
  • PIN 4: LED 1
  • PIN 5: LED 2 (PWM)
  • PIN 6: LED 3 (PWM)
  • PIN 7: LED 4
  • PIN 8: Buzzer
  • PIN 9: Servo
  • PIN 11: Sonda DHT11
  • PIN A0: Potenciómetro (Usar potenciómetro grande)
  • PIN A1: LDR
  • I2C (Pines SDA – A4 y SCL – A5): Pantalla LCD I2C

Montaje Wemos D1 Mini

Pines Wemos D1 Mini: https://steve.fi/Hardware/d1-pins/

Elementos:

Botones/Pulsadores

Botón A con resistencia pull-up interna.

Botón B con resistencia de pull-down externa de 10 Kohms

NOTA: Muy buen tutorial para entender las resistencias de pullup y pulldown http://www.instructables.com/id/Understanding-the-Pull-up-Resistor-With-Arduino/ 

LEDs

Un LED al ser un diodo tiene una caída de tensión que depende del tipo y del color del LED. Para usar un LED es imprescindible poner una resistencia adecuada a cada led. Según la ley de ohm: V = I * R, si el voltaje es de 5 V y queremos que al LED sólo le lleguen entre 5 mA (0.005 A) y 20 mA (0.02 A), entonces usar una resistencia entre 250 y 1000 ohms.

Circuito LED: https://es.wikipedia.org/wiki/Circuito_de_LED 

La fórmula a usar para calcular el valor correcto de la resistencia del circuito es:

Donde:

  • Voltaje de la fuente de alimentación, es el voltaje aplicado al circuito (5 voltios en el caso de Arduino)
  • Caída de voltaje del LED, es el voltaje necesario para el funcionamiento del LED, generalmente está entre 1.7 y 3.3 voltios, depende del color del diodo y de la composición de metales.
  • Rango de corriente del LED, es determinado por el fabricante, usualmente está en el rango de unos pocos miliamperios. A más corriente más iluminación. Para Arduino el valor máximo será de 20 mA.

Buzzer

Zumbador, buzzer en inglés, es un transductor electroacústico que produce un sonido o zumbido continuo o intermitente

El zumbador usado es: https://www.arduino.cc/documents/datasheets/PIEZO-PKM22EPPH4001-BO.pdf

Para usar el buzzer usaremos la función Tone() de Arduino. Tone() genera una onda cuadrada de una frecuencia específica y con un 50% de duty cycle en el pin especificado. La duración del tono puede ser especificado o en caso contrario continúa hasta llamar a la función noTone().

Para más información: Función tone(): https://www.arduino.cc/en/Reference/Tone

Servomotor

Servomotor (o también llamado servo) es similar a un motor de corriente continua pero con la capacidad de posicionarse en una posición determinada y permanecer fija en esta. Normalmente el ángulo es de 0 a 180 grados y se alimentan a 5 voltios mínimo.

Para controlar un servo, se usa el PWM. La mayoría de los servos trabaja en una frecuencia de 50 Hz (20ms). Cuando se manda un pulso, la anchura de este determina la posición angular del servo. La anchura varía según el servomotor pero normalmente es entre 0,5ms a 2,5ms.

En Arduino se utiliza la librería <Servo.h> para controlar los servos y generar las señales adecuadas para manejarlos. Dispone entre otras de las siguientes funciones:

Potenciómetro

Un potenciómetro es una resistencia cuyo valor de resistencia es variable. De esta manera, indirectamente, se puede controlar la intensidad de corriente que fluye por un circuito si se conecta en paralelo, o la diferencia de potencial al conectarlo en serie.

LDR

Se trata de un sensor que actúa como una resistencia variable en función de la luz que capta. A mayor intensidad de luz, menor resistencia: el sensor ofrece una resistencia de 1M ohm en la oscuridad, alrededor de 10k ohm en exposición de luz ambiente, hasta menos de 1k ohm expuesto a la luz del sol.

El LDR actúa como una resistencia variable. Para conocer la cantidad de luz que el sensor capta en cierto ambiente, necesitamos medir la tensión de salida del mismo. Para ello utilizaremos un divisor de tensión, colocando el punto de lectura para Vout entre ambas resistencias. De esta forma:

Donde Vout es el voltaje leído por el PIN analógico del Arduino y será convertido a un valor digital, Vin es el voltaje de entrada (5v), R2 será el valor de la resistencia fija colocada (10k ohm generalmente) y R1 es el valor resistivo del sensor LDR. A medida que el valor del sensor LDR varía, obtendremos una fracción mayor o menor del voltaje de entrada Vin.

El LDR que usamos: Photoresistor [VT90N2 LDR]

Sensor DHT11

Sensor de humedad y temperatura DHT11. Es lo suficientemente exacta para la mayoría de los proyectos que necesitan hacer un seguimiento de las lecturas de humedad y temperatura. Es unas de las sondas más populares.

Parámetros del producto:

  • Humedad relativa:
    • Resolución: 16 bits
    • Repetibilidad: ±1% H.R.
    • Precisión: 25 ° C ± 5% hr
    • Histéresis: < ± 0.3% RH
    • Estabilidad a largo plazo: < ± 0.5% hr / año
  • Temperatura:
    • Resolución: 16 bits
    • Repetibilidad: ±0. 2 ° C
    • Precisión: 25 ° C ± 2° c
  • Características eléctricas
    • Fuente de alimentación: DC 3.5 ~5.5V
    • Corriente: medición 0.3mA
    • Espera 60μA
    • Periodo de muestreo: más de 2 segundos
  • Descripción pines:
    • VDD alimentación 3,5~5.5V DC
    • serie de datos, un solo bus
    • NC, pin vacío
    • GND tierra, la energía negativa

Datasheet y protocolo sonda DHT11: https://akizukidenshi.com/download/ds/aosong/DHT11.pdf

Librerías:

Pantalla LCD I2C

Pantalla LCD I2C. La pantalla tiene una retroiluminación de LED y puede mostrar dos filas con hasta 16 caracteres en cada fila.

El controlador de LCD I2C es un dispositivo que nos permite controlar una pantalla a través del bus I2C, usando únicamente dos cables.

Librería LiquidCrystal_I2C del gestor de librerías: https://github.com/marcoschwartz/LiquidCrystal_I2C

La dirección I2C por defecto del módulo puede ser 0x3F o en otros casos 0x27. Es muy importante identificar correctamente la dirección I2C de nuestro módulo, pues de otra forma nuestro programa no funcionará correctamente. Para identificar la dirección específica de nuestro módulo podemos utilizar un pequeño sketch de prueba llamado: I2C Scanner, el cual nos permite identificar la dirección I2C del dispositivo conectado al Arduino.

Más información: https://www.naylampmechatronics.com/blog/35_Tutorial–LCD-con-I2C-controla-un-LCD-con-so.html

Wemos D1 Mini

Wemos son una serie de placas de prototipado con chip ESP8266 integrado para conexión WiFi. Hay varios modelos y la página web oficial es https://www.wemos.cc/

Vamos a usar la Wemos D1 Mini: https://wiki.wemos.cc/products:d1:d1_mini 

Shields Wemos D1 Mini

Fritzing parts: https://github.com/mcauser/Fritzing-Part-WeMos-D1-mini-Shields

Relay Shield

Web: https://wiki.wemos.cc/products:d1_mini_shields:relay_shield

Por defecto usa el pin D1, pero es configurable.

Wemos RGB LED Shield

Web: https://wiki.wemos.cc/products:d1_mini_shields:rgb_led_shield

Por defecto usa el pin D4, pero es configurable.

NOTA: La shield led RGB de un pin va al pin D2: https://wiki.wemos.cc/products:d1_mini_shields:ws2812b_rgb_shield

Wemos mini Oled Shield

Web: https://wiki.wemos.cc/products:d1_mini_shields:oled_shield

Pantalla I2C – Pines SDA – D2 y SCL – A1

Librería Pantalla: https://github.com/mcauser/Adafruit_SSD1306/tree/esp8266-64×48

Librería Botones: https://github.com/wemos/LOLIN_OLED_I2C_Button_Library (En la versión disponible para prácticas no dispone de los botones)

Características

  • Screen Size: 64×48 pixels (0.66” Across)
  • Operating Voltage: 3.3V
  • Driver IC: SSD1306 (I2C Address: 0x3C or 0x3D)
  • 2x I2C Button (customizable I2C Address, default:0x31)

Ejercicio01 – Testeo del Circuito Arduino

Para comprobar que todo funciona ejecutar el programa de testeo. Para ello coger el código de https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019/blob/master/Ejercicio01-Comprueba_Entorno_Arduino/Ejercicio01-Comprueba_Entorno_Arduino.ino.

Todo el código que haga cada alumno lo guardará en su repositorio de github llamado: “Curso Programacion Arduino 2019”. Cada ejercicio se guardará en un directorio con el nombre EjercicioXX y dentro el código.

Pasos a seguir:

Ejecutar todos los test del Ejercicio01 y comprobar que funciona todo correctamente.

En caso que algo no funcione a lo largo del curso, usar este sketch para comprobar que la parte hardware funciona correctamente.

Tests:

  • 1 – Muestra Texto Pantalla
  • 2 – Prueba Botones (comprobar pulsaciones correctas)
  • 3 – Prueba LEDs (Iluminación LEDs)
  • 4 – Prueba PWM LEDs (No todos los LEDs son PWM)
  • 5 – Prueba Potenciómetro (comprobar que va de 0 a 1023)
  • 6 – Prueba LDR (ver valores máximo y mínimo. Anotarlos)
  • 7 – Sonda temperatura (comprueba valores) DHT11
  • 8 – Test Servo (comprobar el movimiento completo)
  • 9 – Test Buzzer (comprobar sonido)

IMPORTANTE: después de ejecutar los test o mientras se ejecutan, leer el código, entenderlo y preguntar todo aquello que no se entienda.

NOTA:  Las funciones de testeo de cada componente se pueden usar como plantilla para los ejercicios propuestos a lo largo del curso.

Ejercicio02 – Testeo del Circuito Wemos D1 Mini

Pasos a seguir:

Ejecutar todos los test del Ejercicio02 y comprobar que funciona todo correctamente.

Código: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino_2019/blob/master/Ejercicio02-Comprueba_Entorno_ESP8266/Ejercicio02-Comprueba_Entorno_ESP8266.ino

En caso que algo no funcione a lo largo del curso, usar este sketch para comprobar que la parte hardware funciona correctamente.

Tests:

  • 1 – Muestra IP Arduino
  • 2 – Test Cliente Web (comprobar respuesta del servidor)
  • 3 – Test Servidor Web (comprobar servidor embebido en Arduino)
  • 4 – Prueba Pulsador (comprobar pulsaciones correctas)
  • 5 – Prueba Relé Shield
  • 6 – Prueba Neopixel Shield
  • 7 – Prueba Pantalla Oled Shield
Anuncios

Entradas y Salidas en Arduino

Arduino dispone de una serie de entradas y salidas digitales y analógicas programables que es la base de manejo de Arduino. Es fundamental conocerlas para empezar a programar Arduino.

En Arduino UNO la disposición de los pines de entrada y salida son:

En el Wemos D1 Mini la disposición de los pines de entrada y salida son:

En todas las placas los pines son multifunción o multipropósito, es decir en función de la configuración tienen una funcionalidad u otra.

Pines Digitales

Una señal digital es un tipo de señal generada por algún tipo de fenómeno electromagnético en que cada signo que codifica el contenido de la misma puede ser analizado en término de algunas magnitudes que representan valores discretos, en lugar de valores dentro de un cierto rango. Por ejemplo, el interruptor de la luz sólo puede tomar dos valores o estados: abierto o cerrado, o la misma lámpara: encendida o apagada.

En arduino y todas las placas compatibles los pines digitales se describen y tienen la propiedades siguientes:  http://arduino.cc/en/Tutorial/DigitalPins

En arduino y placas compatibles para tratar las entradas y salidas digitales usamos las siguientes funciones:

En la imagen siguiente se muestra el estado por defecto de una I/O digital en un microcontrolador de Arduino. Se ha simplificado con interruptores la compleja electrónica que hay dentro. Por defecto los digital I/O pins están configurados como inputs en un estado de alta impedancia (equivalente a una resistencia de 100 Mohms en frente del pin), es decir, SW3 a ON y no hace falta llamar a la función pinMode() aunque es recomendable para aclarar el código.

  • PinMode(x, INPUT) –> SW3 = ON (resto a OFF). Los valores leídos serán aleatorios si el pin de Arduino está al aire. El pin está en un estado de alta impedancia (resistencia de 100 Mohms).
  • PinMode(x,INPUT_PULLUP) –> SW3 = ON & SW4 = ON (resto a OFF). Los valores leídos sin nada conectado al pin es HIGH. La Resistencia R1 tiene un valor dependiendo del microcontrolador, pero tiene un valor entre 20kOhm y 150kOhm.
  • PinMode(x, OUTPUT) & digitalWrite(x,HIGH) –> SW2 = ON & SW1 = +5V (resto a OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una resistencia adecuada a la salida el pin para no superar los 40mA (source) máximos admitidos
  • PinMode(x, OUTPUT) & digitalWrite(x,LOW) –> SW2 = ON & SW1 = GND (resto a OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una adecuada para no superar los 40mA (sink) máximos admitidos

Pines Analógicos

Una señal eléctrica analógica es aquella en la que los valores de la tensión o voltaje varían constantemente y pueden tomar cualquier valor. En el caso de la corriente alterna, la señal analógica incrementa su valor con signo eléctrico positivo (+) durante medio ciclo y disminuye a continuación con signo eléctrico negativo (–) en el medio ciclo siguiente.

La señal digital obtenida de una analógica tiene dos propiedades fundamentales:

En arduino los pines analógicos se definen y tienen las propiedades siguientes: http://arduino.cc/en/Tutorial/AnalogInputPins

En arduino para tratar las entradas y salidas analógicas usamos las siguientes funciones:

Entradas analógicas:

Las Salidas PWM (Pulse Width Modulation) permiten generar salidas analógicas desde pines digitales. Arduino Uno no posee salidas analógicas puras, sin embargo el Arduino Due sí tiene salidas analógicas puras mediante dos DAC. El arduino due, posee dos salidas analógicas puras mediante dos conversores digital a analógico. Estos pines pueden usarse para crear salidas de audio usando la librería correspondiente.

Diferentes valores de una señal PWM:

Para el Wemos D1 Mini, solo hay un pin de entrada analógica y de pines con capacidad PWM como indica esta imagen:

Presentación Curso Programación Arduino

 

Objetivos

Este curso nace como una demanda o complemento a los cursos de iniciación de arduino en www.aprendiendoarduino.com. En los cursos de iniciación no se profundiza en la programación sino en el conocimiento completo de la plataforma Arduino.

Este curso está orientado a cualquier persona que tenga unos conocimientos básicos de Arduino pero sin experiencia en programación. Aprenderemos las técnicas básicas de programación de microcontroladores (Arduino y ESP8266), así como el control de versiones git y el uso de github.

Es un curso cuyo contenido es un 70% práctico donde los alumnos dedicarán buena parte del tiempo a practicar la programación y resolver diversos retos de programación en un microcontrolador. Se prestará especial atención a aprender el manejo de librerías, la programación orientada a objetos y el uso de las comunicaciones.

El objetivo de este curso es que el alumno aprenda los principales conceptos de la programación de Arduino en particular, y por extensión los principios y técnicas de programación general que podrían aplicarse a casi cualquier lenguaje de programación.

Dado que las comunicaciones, la conexión a Internet y los dispositivos conectados es otro aspecto importante actualmente y los conceptos de computación y comunicaciones van unidos de la mano cuando hablamos de las TIC (Tecnologías de la Información y de la Comunicación), vamos a tratar también en este curso las comunicaciones y la programación de los dispositivos conectados.

Se programará usando la plataforma Arduino, pero se verán de una forma superficial otros lenguajes de programación como Processing, Python, PHP, javascript y lenguajes de marcas como HTML y XML.

Este curso está diseñado para personas que conocen Arduino y el mundo de los microcontroladores y la electrónica pero no tienen conocimientos o solo básicos de programación.

Requisitos

El único requisito para realizar este curso es conocer la plataforma de hardware libre Arduino y tener conocimientos básicos de electrónica.

Es recomendable un conocimiento medio de Inglés puesto que gran parte de la documentación está en Inglés.

Metodología

El curso se compone de una combinación de teoría y práctica para aprender programación con Arduino, con una duración de 30 horas. En este curso se dará más importancia a la parte práctica donde los alumnos tendrán que resolver los retos de programación planteados.

Los recursos utilizados para la realización de este curso son:

Además están disponibles otros recursos para ampliar información:

Para interactuar en el curso se puede hacer mediante:

Para realizar las prácticas de este curso se incluye un Arduino Starter Kit (https://www.arduino.cc/en/Main/ArduinoStarterKit) que contiene un Arduino Uno, una serie de sensores y actuadores y diversos elementos electrónicos necesarios para realizar las prácticas y proyectos.

Todo el material entregado es en préstamo y debe cuidarse al máximo, a la hora del montaje de las prácticas se seguirán las instrucciones para evitar dañar los componentes.

La documentación está disponible on line con el objetivo de mantenerla actualizada y no como un documento físico que se queda obsoleto al día siguiente. Además la documentación irá creciendo durante el curso y después de finalizar el curso seguirá estando disponible para todos.

El repositorio de código del curso y mucho más código está disponible en github en http://github.com/jecrespo y está aumentando continuamente con nuevos ejemplos y prácticas.

Toda la documentación y código es liberado con licencia Creative Commons.

Reconocimiento – NoComercial – CompartirIgual (by-nc-sa): No se permite un uso comercial de la obra original ni de las posibles obras derivadas, la distribución de las cuales se debe hacer con una licencia igual a la que regula la obra original.

Aprendiendo Arduino by Enrique Crespo is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.

Organización del curso

Duración total de 30 horas. El curso se realiza del 2 al 13 de septiembre de 2019 de Lunes a Viernes en horario de 17.30 a 20.30. Se hará un descanso de 10 minutos aproximadamente a mitad de la sesión antes de empezar con la parte práctica.

Capítulos del curso:

  • Introducción Programación Arduino
  • Programación Básica Arduino
  • Librerías Arduino
  • Programación Avanzada Arduino
  • Programación Comunicaciones Arduino

Detalle del temario: https://www.aprendiendoarduino.com/cursos/programacion-arduino-2019/

Cada día de curso de compone de 3 partes diferenciadas:

Los contenidos teóricos y prácticos se irán combinando cada día.

Herramientas Utilizadas en el Curso

En este curso utilizaremos diversas herramientas de programación:

Acerca de Enrique Crespo

El autor del curso es Enrique Crespo. Llevo trabajando con Arduino desde el año 2011 y en el año 2014 empecé mi andadura como profesor de Arduino y otros temas relacionados. Desde entonces he impartido muchos cursos presenciales de Arduino, talleres y conferencias en diversos lugares. También colaboro en el makerspace de la Universidad de la Rioja UR-maker.

Todos los cursos, talleres y conferencias que he impartido puedes verlos en http://www.aprendiendoarduino.com/, donde publico toda la documentación y código.

Twitter @jecrespo: https://twitter.com/jecrespom

Linkedin: https://www.linkedin.com/in/enriquecrespo/ 

Contacto

Para cualquier consulta durante el curso y en cualquier otro momento mediante email: aprendiendoarduino@gmail.com

Twitter @jecrespo: https://twitter.com/jecrespom 

Y más información sobre el curso y el autor: http://www.aprendiendoarduino.com/acerca-de/ 

Presentaciones

¿Qué experiencia/conocimientos tienes con Arduino?

¿Qué experiencia/conocimientos tienes de programación?

¿Qué lenguajes de programación conoces?

¿Qué experiencia/conocimientos tienes de comunicaciones?

Saber Más Programación Arduino 2019

Github Alumnos:

Repositorios del curso Alumnos

Slack: https://aprendiendoarduino.slack.com, enlace de invitación: link invitación


Día 1: “Presentación del Curso”

Capítulos Vistos Día 1:

Día 2: “Repositorios Github”

Saber más:

Resumen git:

  • Sourcetree herramienta gráfica para usar git. Demo entorno consola.
  • Cuenta de Attlasian y Bitbucket solo para registrar Sourcetree
  • Repositorios en Sourcetree: Local y Remote
  • Clonar un Repositorio: hacer una copia y poder sincronizarlo. No puedo hacer cambios. “git clone
  • Crear un repositorio: preparar una carpeta donde hacer control de versiones. “git init
  • Añadir Archivos al Área de trabajo (Stash): Son los cambios que voy a guardar. “git add” (git status para ver los cambios realizados)
  • Registrar Cambio en el Historial (Commit): guardar una foto del estado del código en el historial. “git commit
  • Comandos git básicos: https://www.hostinger.es/tutoriales/comandos-de-git
  • Para seguir, tener el repositorio de blink con al menos 2 commits.
  • Modificar el archivo blink.ino para que parpadee un led colocado en el pin 4 y hacer un commit
  • Añadir un fichero README.md en el directorio raiz del repositorio, escribiendo la información de nuestro primer repositorio. Hacer commit.
  • Editor MarkDown Online: https://stackedit.io/

Capítulos Vistos Día 2:

Día 3: “Programación Básica Arduino”

Saber más:

prioridad_tabla

Resumen de Github:

  • Para sincronizar en Github un repositorio local a un repositorio remoto desde SourceTree. Es necesario git pull –allow-unrelated-histories origin en caso que en el remoto haya commits.

Capítulos Vistos Día 3:

Día 4: “Programación Arduino”

Saber más:

Cambiar pin en un shield:

Resumen:

Capítulos Vistos Día 4:

Día 5: “Estructuras de Programación”

Saber más:

Resumen:

Resultado de imagen de wemos d1 mini pullup resistors

Capítulos Vistos Día 5:

Día 6: “Operadores y Estructuras”

Saber más:

Resumen:

Capítulos Vistos Día 6:

Día 7: “Estructuras Propias de Arduino”

Saber más:

Capítulos Vistos Día 7:

Día 8: “Funciones y Librerías”

Saber más:

Capítulos Vistos Día 8:

Día 9: “Programación Avanzada”

Saber más:

Capítulos Vistos Día 9:

Día 10: “Comunicaciones y Servicios Avanzados”

Saber más:

Capítulos Vistos Día 10:

Propuestas de Proyecto Final de Curso 2019

Criterios de Evaluación Proyectos Arduino

Cada apartado se puntúa 0 o 1, siendo un total de 12 puntos el máximo a obtener. Se considera apto obtener un 5.

    • Documentación
    • Código
    • Complejidad Proyecto
    • Análisis Previo
    • Diagrama de Flujo
    • Esquemático, Materiales y Coste
    • Pasos y Desarrollo del Proyecto
    • Uso del control de versiones
    • Funcionalidad
    • Pruebas Realizadas
    • Mejoras
    • Herramientas Adicionales (3D, Comunicaciones, etc…)

Cuentas Utilizadas por los Alumnos.

Rodolfo – Brazo Robótico Didáctico

Project: https://create.arduino.cc/projecthub/rodolfoticcosme/brazo-robot-didactico-con-3-grados-fd7c40?ref=user&ref_id=1152623&offset=0 

Repositorio: https://github.com/rodolfoticcosme/Proyecto-Arduino-Robot

App Inventor: http://ai2.appinventor.mit.edu/?galleryId=6509315643539456 

Marcos García – Control vía WiFi de una pequeña instalación domótica

Project: https://create.arduino.cc/projecthub/fonzacity

Project en Hackster.io: https://www.hackster.io/fonzacity/home-automation-with-esp8266-1fd2af

Wiki: https://github.com/fonzacity/proyecto-curso-arduino/wiki 

Repositorio: https://github.com/fonzacity/proyecto-curso-arduino

Luis – Control del sistema de refrigeración en bastidor de PC

Project: https://create.arduino.cc/projecthub/zubicantabria/control-del-sistema-de-refrigeracion-en-bastidor-de-pc-63a355?f=1

Repositorio: https://github.com/zubicantabria/ControlRefrigerarPC

Marcos Cochi – Bus Arriving Project

Project: https://create.arduino.cc/projecthub/mcochi/bus-arriving-project-7230fe?ref=user&ref_id=1153680&offset=0

Repositorio: https://github.com/mcochi/BusArrivingProject

Iván – Sensores Humedad MQTT

Project: https://create.arduino.cc/projecthub/thinkcurso/sensorhumedad-mqtt-c6e07a

Repositorio: https://github.com/thinkcurso/sensors-MQTT

Vídeo de Presentación: https://youtu.be/lmC6PZDFOe4 

Ernesto – Monitorización Oficina con Thingspeak

Project: https://create.arduino.cc/projecthub/Ernesto_Rodriguez/inmotica-pequeno-control-de-una-oficina-d2a128

Repositorio: https://github.com/Ernestorodriguezc/curso-arduino-proyectos/blob/master/DHTtesterDEPURADO_2Sensores/DHTtesterDEPURADO_2Sensores.ino

Canal compartido de Thingspeak: 82338. Link: https://thingspeak.com/channels/823382

Arturo – Robot Básico BT

Project: https://create.arduino.cc/projecthub/bacterio3000/robot-basico-bt-0182eb?ref=user&ref_id=1152625&offset=0

Repositorio: https://github.com/bacterio3000/PruebaCurso

Para bluetooth usa: https://www.keuwl.com/apps/bluetoothelectronics/

Código en ArduinoBlocks: http://www.arduinoblocks.com/web/project/68631

Noelia – Control de Relay con Arduino desde APP

Project: https://create.arduino.cc/projecthub/nolmos/control-de-relay-con-arduino-desde-app-c63b2c

Repositorio: https://github.com/noelia-olmos/Proyecto_Arduino_App_Bluetooht 

APP Inventor: http://ai2.appinventor.mit.edu/?galleryId=6286670243168256

Enrique – Robot MiniSumo

Project: https://create.arduino.cc/projecthub/jecrespo/construccion-y-programacion-de-robot-minisumo-25c4b7

Repositorio: https://github.com/jecrespo/Robot-MiniSumo

Enrique – Conference Clock

Project: https://create.arduino.cc/projecthub/jecrespo/arduino-conference-clock-1b9354

Repositorio: https://github.com/jecrespo/conference_clock