BRK IoT Set Manual

Machine Translated by Google
Conjunto de Internet de las cosas
Kit experimental de Brick'R'knowledge
Kit de experimentos de Brick'R'knowledge
7 segmento
Adaptadores de sensor 3x
EUR/USD
1,0558
Ladrillo IoT
www.brickrknowledge.de
imprimir
Instrucciones del juego Brick'R'knowledge Internet of Things Rev.
1.0 Fecha: 20170324
ALLNET® y Brick'R'knowledge® son marcas registradas de ALLNET® GmbH Computersysteme.
Sistemas informáticos ALLNET® GmbH
Brick'R'conocimiento
Maistrasse 2
D82110 Germinación
© Copyright 2017 ALLNET GmbH Sistemas informáticos. Todos los derechos reservados.
Toda la información contenida en estas instrucciones ha sido compilada con el mayor cuidado y según nuestro leal saber y entender. Sin embargo,
los errores no se pueden descartar por completo. Siempre estamos agradecidos por informar cualquier error. Envíelos a info@brickrknowledge.de.
BRK_IoT_Set_HB_de_Rev. 1.0
Tabla de contenido
1. Instrucciones de seguridad _______________________________________________________________________________________ 5
2. ¿Qué significa realmente "Internet de las cosas"? ________________________________________________________________ 6
3. Conceptos básicos del sistema de conocimiento Brick'R'__________________________________________________________________________ 7
3.1 El ladrillo masivo ________________________________________________________________________________________________ 7
3.2 La fuente de alimentación _________________________________________________________________________________________ 7 3.3 Los conectores
________________________________________________________________________________________________ 8
3.4 Ladrillos de conexión especiales para nivel inferior ____________________________________________________________________________ 8
4. El hardware de un vistazo ________________________________________________________________________________ 9
5. El ladrillo IoT y el IDE de Arduino ____________________________________________________________________________ 13
5.1 El corazón del conjunto de Internet de las cosas 5.1.1 ____________________________________________________________________________ 13
____________________________________________________________________________________
Especificación del IoT Brick 5.1.2 Los pines G PIO del 13
IoT Brick ________________________________________________________________________________ 14
5.1.3 Resistencias pullup _________________________________________________________________________________________ 14 5.2 El entorno de desarrollo
Arduino ___________________________________________________________________________ 15
5.2.1 Instalar bibliotecas ____________________________________________________________________________________ dieciséis
5.2.1.1 Instalar bibliotecas de Arduino ____________________________________________________________________________ 17
5.2.1.1.1 Biblioteca "NTPClient" ________________________________________________________________________________ 17
5.2.1.1.2 Biblioteca "Tiempo" ____________________________________________________________________________________ 17
5.2.1.1.3 Biblioteca "Json Streaming Parser" ____________________________________________________________________ 18
5.2.1.1.4 Biblioteca "Biblioteca de sensores DHT" ________________________________________________________________________ 18 5.2.1.1.5 Biblioteca
"Sensor unificado de Adafruit" ____________________________________________________________________ 18
5.2.1.2 Instalar bibliotecas externas ____________________________________________________________________________ 18
5.2.1.2.1 Biblioteca "esp8266oledssd1306master" _______________________________________________________________ 19 5.2.1.2.2 Biblioteca "MCP3421"
________________________________________________________________________________ 19
5.2.1.2.3 Biblioteca "BrickESP8266" ____________________________________________________________________________ 19
5.2.2 Controlador de puerto COM virtual ____________________________________________________________________________________ 20
5.2.3 Monitor de serie ____________________________________________________________________________________________ 20
5.3 Primeros pasos ________________________________________________________________________________________________________________ 21
5.3.1 Establecer una conexión 5.3.2 _______________________________________________________________________________________ 21
Compilar y cargar el código del programa 5.3.3 Modo de ____________________________________________________________________ 22
programación __________________________________________________________________________________ 22 6. Ejemplos de ejercicios
_________________________________________________________________________________________ 6.1 "Hello World" (LED parpadeante) 23
___________________________________________________________________________________________ 23 6.2 Botón y LED 6.3 I2 CBus
________________________________________________________________________________________________ 24
___________________________________________________________________________________________________________ 25
6.3.1 La pantalla de 7 segmentos ______________________________________________________________________________________ 26 6.3.2 La pantalla de 7
__________________________________________________________
segmentos como I2 CBrick : estructura y direcciones 6.3.3 La pantalla de 7 segmentos
como contador 6.3.4 La pantalla de 7 segmentos con tecla antirrebote 27
________________________________________________________________________________________________
____________________________________________________________________
30 6.4 Pantalla OLED : conceptos básicos 29
______________________________________________________________________________________ 32 6.4.1 Pantalla OLED : mostrar texto
________________________________________________________________________________ 33 6.5 Entradas analógicas
___________________________________________________________________________________________ 35 6.5.1 Conversión A/D: conceptos básicos
_________________________________________________________________________________ 35 6.5.2 Los convertidores A/D en el ladrillo IoT
____________________________________________________________________________ 37
6.5.2.1 El convertidor A/D de 10 bits ____________________________________________________________________________________ 37
6.5.2.2 El convertidor A/D de 18 bits ____________________________________________________________________________________ 37
6.5.2.3 El divisor de voltaje ____________________________________________________________________________________ 37 6.5.2.4 Consejo práctico:
________________________________________________________________________________
Factor de corrección 6.5.2.5 Codificación binaria
____________________________________________________________________________________ 38 38
6.5.3 Convertidor A/D de 10 bits ___________________________________________________________________________________________ 39
6.5.4 Convertidor A/D de 18 bits ___________________________________________________________________________________________ 41
6.6 Ejemplos de IoT ____________________________________________________________________________________________________ 43
6.6.1 Configurar el IoT Brick como un cliente WLAN ____________________________________________________________________________ 44
6.6.2 Tiempo desde Internet ___________________________________________________________________________________________ 46
6.6.3 Medir la temperatura y la humedad ______________________________________________________________________ 48
6.6.4 Tasa de dólar desde Internet ________________________________________________________________________________________________ 50
6.6.5 Mi primer sitio web ___________________________________________________________________________________________ 52
6.6.6 Cambio a través del sitio web ___________________________________________________________________________________________ 55
7. Comunidad de ladrillos ________________________________________________________________________________________ 60 8. Descripción
general de los juegos de ladrillos ____________________________________________________________________________________ 63
4
prefacio
El sistema experimental Brick'R'knowledge fue presentado por primera vez en la
exposición HAM Radio el 28 de junio de 2014 por RolfDieter Klein (indicativo de
radioaficionado: DM7RDK). Lo especial de nuestros conjuntos electrónicos es que
los componentes individuales están conectados a través de un sistema de conectores
en el que las piezas que se ensamblan son de construcción idéntica (hermafroditas).
De esta manera, incluso se pueden implementar circuitos complicados. ¡También es
posible conectar los bloques de construcción individuales en diferentes ángulos!
¡Hay dos contactos para volver a tierra (0 voltios)!
Esto permite construir circuitos compactos en los que el retorno a tierra garantiza un
suministro de tensión estable a los bloques de construcción. Otra característica
especial es que tales circuitos se pueden explicar y documentar muy fácilmente.
Diviértete con el conjunto de Internet de las cosas
Rolf Dieter Klein
Bibliografía:
• El libro de prácticas ESP8266, Erik Bartmann, Elektor Verlag GmbH, ISBN 9783895763212
• http://www.esp8266.com
• https://en.wikipedia.org/wiki/ESP8266
• Términos de red explicados de forma sencilla: http://www.elektronikkompendium.de
• Introducción a la tecnología de redes, Patrick Schnabel, ISBN: 9783833416811 (3833416815)
• Conceptos básicos de HTML: http://www.selfhtml.org/
Descargas:
• Descargue el entorno de desarrollo de Arduino: https://
www.arduino.cc/en/Main/Software#
• Código de ejemplo y bibliotecas para los ejercicios de este manual:
http://www.brickrknowledge.de/downloads
1. Instrucciones de seguridad
¡Atención, NUNCA conecte los componentes del conjunto electrónico directamente a la red eléctrica (230 V), de lo contrario existe el
riesgo de lesiones fatales!
Recomendamos la fuente de alimentación de 9 V suministrada (o la batería de 9 V opcional) para la fuente de alimentación. La tensión
de alimentación aquí es de 9 voltios, lo que no es peligroso para la salud, con un flujo de corriente máximo de 1 amperio. Asegúrese
también de que los cables sueltos que se encuentran por ahí no entren en contacto con las regletas de enchufes (distribuidores de
ambiente normales) o caigan dentro de ellas, de lo contrario existe el riesgo de una descarga eléctrica dañina o una descarga eléctrica.
Nunca mire directamente a un diodo emisor de luz (LED), ya que existe el riesgo de dañar la retina (deslumbramiento). Es esencial
asegurarse de que la fuente de alimentación suministrada esté desconectada de todos los componentes después de la configuración
experimental, de lo contrario, ¡existe riesgo de incendio eléctrico!
¡No trague los componentes u otras partes del conjunto electrónico; de lo contrario, consulte a un médico de inmediato!
instrucciones de seguridad 5
2. ¿Qué significa realmente "Internet de las cosas"?
Si lo busca en Wikipedia, encontrará, entre otras cosas, la siguiente definición muy general:
"El Internet de las cosas se refiere a la vinculación de objetos físicos claramente identificables (cosas) con una representación
virtual en una estructura similar a Internet. Ya no solo consiste en participantes humanos, sino también en cosas. El término se
remonta a Kevin Ashton, que utilizó por primera vez "Internet de las cosas" en 1999".
(Fuente: https://de.wikipedia.org/wiki/Internet_der_Dinge)
Ajá, pensarán algunos lectores, pero ¿qué significa eso específicamente para mí como un contemporáneo más o menos experto
en TI?
El término "Internet de las cosas" (abreviado: IoT) describe la conexión en red de dispositivos electrónicos (los llamados
dispositivos inteligentes), a veces también llamados gadgets, hasta la conexión en red de plantas de producción completas (palabra
clave: Industria 4.0). Por regla general, se utiliza como medio de comunicación el protocolo TCP/IP estandarizado, que se utiliza
tanto para redes de área local (LAN) como para redes de área amplia internacional (WAN). Cada participante o cada cosa necesita
una dirección IP global única para su identificación. Debido a la creciente escasez de direcciones en el Protocolo de Internet
Versión 4 (IPv4), la organización IETF estandarizó el Protocolo de Internet Versión 6 (IPv6) en 1998. Esto aumenta el espacio de
direcciones de IPv4 de 232 (≈ 4300 millones) direcciones a 2128 (≈ 340 sextillones) direcciones para IPv6. Para mantener el
principio de una conexión punto a punto en el Internet de las Cosas, es absolutamente necesario ampliar el espacio de direcciones,
aunque todavía no se ha establecido como se esperaba.
En el futuro, ya no habrá solo computadoras en red global que las personas usen para comunicarse entre sí, sino dispositivos
más o menos inteligentes con una gran cantidad de sensores y actuadores que intercambiarán datos directamente entre sí. Esto
conduce a una cantidad sin precedentes de datos y variedad de datos a los que se puede acceder desde cualquier lugar en tiempo
real. A pesar de las fascinantes posibilidades de un mundo en red, uno siempre debe ser consciente del riesgo potencial para la
seguridad.
Algunos ejemplos del Internet de las Cosas:
• Microcontroladores y computadoras con servidores web integrados • Los
llamados wearables, con sensores incorporados en la ropa
• Automatización de edificios (domótica)
• Monitoreo de temperatura en la sala de servidores
• Gestión de la energía, medición inteligente
• Video vigilancia
... y por último, pero no menos importante, el Brick'R'knowledge Internet of Things Set con el que ahora puedes acceder a tus
Bricks a través de Internet.
Primero obtendrá una descripción general de los conceptos básicos del sistema de experimentación Brick'R'knowledge.
Después de eso, se presentarán todos los ladrillos y sensores incluidos en este conjunto. Una característica especial de este
conjunto es la combinación de software y hardware. es decir. necesitamos software para escribir programas que den vida al
hardware. Para ello utilizaremos el entorno de desarrollo Arduino, que se puede descargar de forma gratuita. Una vez realizados
todos los preparativos, utilizamos numerosos ejemplos prácticos para involucrarnos cada vez más en el mundo del Internet de las
cosas.
Por ejemplo, con el IoT Brick central, aprenderá a crear su primer sitio web y a controlar los pines de E/S con su teléfono inteligente.
El conjunto también incluye un sensor de temperatura y humedad cuyos valores puedes visualizar. ¡El primer paso para tu propio
proyecto de domótica! Pero también puedes consultar y visualizar datos como el tipo de cambio del dólar desde Internet.
¡ Un bus I2C para conectar una pantalla de 7 segmentos o un convertidor A/D de 18 bits también está "en el ladrillo"!
¡El Internet de las Cosas te está
esperando para que lo descubras!
6 ¿Qué significa realmente "Internet de las cosas"?
3. Conceptos básicos del sistema Brick'R'knowledge
3.1 El ladrillo masivo
El ladrillo masivo es un componente especial del sistema Brick'R'knowledge. Ahorra conexiones adicionales utilizando otros ladrillos o
líneas. Aquí es donde se revela el secreto de nuestro conector de cuatro pines. Los dos contactos del medio están reservados para la
transmisión de señales, como sugiere la impresión.
Los contactos exteriores se utilizan para cerrar el circuito, es decir, para devolver el flujo de corriente a la fuente de tensión. El ladrillo
masivo se da cuenta de esto. Este ladrillo se llama ladrillo de masa porque en electrónica el término "masa" no describe el peso de un
objeto, sino el potencial de referencia al que se refieren todos los demás potenciales. En todos los conjuntos Brick'R'knowledge, el ladrillo
de tierra establece exactamente esta conexión a 0 V.
En nuestro circuito, eso es 9 voltios contra 0 voltios: solo dices "nueve voltios". En electrónica, los circuitos se crean de tal manera que
después de que todos los componentes se han incorporado a los circuitos más o menos complejos en términos de su funcionalidad, se
conectan a "tierra". Los diagramas de circuito solo deben leerse de esta manera.
En la práctica, nuestro bloque de tierra (derecha) conecta los dos contactos del medio con los dos exteriores.
Pero no te preocupes, no provocaremos un cortocircuito con esto, porque la corriente fluye a través de los componentes de nuestro
circuito de ladrillos a través de los contactos intermedios. La flecha roja en la figura simboliza el polo positivo y las flechas marrones
muestran el retorno de tierra al polo negativo de la fuente de alimentación.
9V 1A

1k
+ LED
rojo
Fig. 1: La conexión a tierra
3.2 La fuente de alimentación
El conjunto IoT recibe alimentación a través de la fuente de alimentación enchufable
de 9 V incluida (ALLBRICK0221). Proporciona una tensión continua estabilizada
de 9 V y una corriente máxima de 1 A.
En caso de sobrecarga, la fuente de alimentación se desconecta, es decir, está protegida
contra cortocircuitos. Un LED indica tan pronto como el ladrillo proporciona energía.
También está disponible como opción un bloque de alimentación a través de una
batería de bloque de 9 V (ALLBRICK0001).
Fig. 2: Adaptador de fuente de alimentación
Si luego junta los bloques en los ejemplos de ejercicios, asegúrese de colocar siempre el bloque de suministro en su circuito
como el último bloque después de haberlo revisado nuevamente. ¡Al final del experimento, la fuente de alimentación debe
desconectarse de la red eléctrica!
Conceptos básicos del sistema Brick'R'knowledge 7
3.3 Los conectores
Al enchufar los ladrillos, asegúrese de que los contactos se toquen correctamente, de lo contrario, existe el riesgo de
interrupciones o incluso cortocircuitos.
Enchufado correctamente mal enchufado
Fig. 3: Los conectores
En la imagen de la izquierda se puede ver una conexión enchufada correctamente. La conexión consta de pequeños pines que
se atascan mecánicamente y crean una conexión eléctrica. Para asegurar el aislamiento entre los contactos y evitar un
cortocircuito, hay barras de plástico entre ellos que no conducen la electricidad.
Un ejemplo de una conexión defectuosa se puede ver en la imagen de la derecha. Las barras aislantes se encuentran aquí
con los contactos, de modo que no puede fluir corriente. El circuito permanece "abierto" o inestable y el circuito no funciona.
Precaución: Es importante verificar siempre que las clavijas de contacto estén correctamente asentadas. Si estos se desvían
demasiado entre sí, puede producirse un cortocircuito. Entonces la corriente no fluye a través de nuestros componentes con el
efecto deseado, sino que busca el camino más corto de regreso a la fuente de voltaje.
Un cortocircuito conduce al máximo flujo de corriente, ya que la única resistencia que tiene que vencer la corriente eléctrica es
la resistencia interna de la fuente de tensión. Esta resistencia es obviamente muy pequeña, por lo que la corriente de cortocircuito
puede provocar un sobrecalentamiento si dura más. ¡Existe riesgo de incendio!
Importante: ¡Compruebe siempre la posición correcta de los contactos!
3.4 Ladrillos de conexión especiales para nivel inferior
El IoT Brick también tiene un pin de señal (GPIO12) en el nivel inferior del conector.
Para llegar a este contacto, existen opcionalmente ladrillos especiales disponibles como
"Línea abajo arriba" (ALLBRICK0385) y "Línea recta de 6 vías" (ALLBRICK0383).
Tienes que tener especial cuidado al enchufarlos juntos. Una nariz protectora evita que
los ladrillos se enchufan desde arriba, para evitar cortocircuitos durante el proceso de
enchufado.
8 Conceptos básicos del sistema Brick'R'knowledge
4. El hardware de un vistazo
El alcance de la entrega del Internet of Things Set incluye los siguientes ladrillos, sensores y accesorios, que se presentan brevemente en este capítulo.
Ilustración Cantidad Artículo no. / ID de ladrillo Breve descripción
+
1 N.º de artículo: 118627
Identificación del ladrillo: ALLBRICK0221
Adaptador de fuente de
alimentación de 9 V El adaptador de fuente de alimentación
de 9 V suministra una corriente máxima de 1 A para los
ladrillos. Está estabilizado y protegido contra cortocircuitos. Un
LED indica cuando está en funcionamiento. El polo positivo se
saca y el polo negativo se conecta a tierra. Inserte este bloque
1A 9V al final después de haber revisado el circuito nuevamente.
IoT Brick ESP8266 El
corazón del conjunto IoT. Módulo ESP8266 con interfaz WLAN,
+9V
tensión de alimentación: +9 V.
7 GPIO, un convertidor A/D de 10 bits, un convertidor A/D de
GPIO5 GPIO14
18 bits, interfaz I2 C, interfaz SPI
(SCL) (SCLK)
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
Para más detalles ver cap. 5.1 en la página 13.
GPIO12
(MISO)
Ladrillo IoT
ADDC (10:1)
GPIO3 I2C de
(Rx) 18 bits , 20 V máx.
GPIO1 10 bit
(TX) GPIO0 RESET int,
máx
10V
micro USB
1 N.º de artículo:
139779 ID de ladrillo: ALLBRICK0659
Pantalla OLED para IoT Brick Pantalla de
luz orgánica monocromática. Estrictamente hablando, los
diodos emisores de luz de 128 x 64 están dispuestos en una
matriz y pueden controlarse individualmente mediante comandos
a través del I2 Cbus. Esto permite mostrar texto de varias
líneas, pero también gráficos monocromáticos simples.
Dirección I2C predeterminada: 78(16)
1 N.º de artículo:
113713 ID de ladrillo: ALLBRICK0086
2 Pantalla de 7 segmentos C
I Display de 7 segmentos compuesto por 7 barras luminosas y un
PCF8574 T +9V
Dirección:40,44,48,4C
LED de 7 segmentos I²C punto. Detrás hay un diodo emisor de luz. Los LED se controlan
mediante dos dispositivos 8574T (16 líneas de salida a los LED).
SCL
SCL
La dirección I2 C se puede configurar con pequeños interruptores
ASD
ASD en la parte posterior .
+9V En un bus 2C pueden funcionar como máximo
cuatro módulos de este tipo .
yo
El hardware de un vistazo 9
Potenciómetro de 10 kΩ El
potenciómetro es una resistencia ajustable manualmente.
Aquí, un tercer contacto (deslizador) recorre la longitud
de la resistencia y, por lo tanto, cambia el nivel del valor
de la resistencia eléctrica en su conexión. Se puede
configurar en el rango de 0 a 10 kΩ. Si el limpiaparabrisas,
también conocido como contacto medio, o uno de los
otros contactos está conectado directamente a la fuente
10kΩ de alimentación, se producirá un cortocircuito. ¡Esto debe
evitarse a toda costa!
El potenciómetro tiene una potencia máxima de
aproximadamente 1/8 W.
Doble LED a tierra (rojo/amarillo)
El módulo aloja dos LED (rojo/amarillo), que están
LED conectados internamente a tierra.
Las líneas de señal están interconectadas por separado.
Ambos LED están protegidos contra un flujo de corriente
excesivo por una resistencia en serie de 2,2 kΩ. Están
diseñados para corriente de 2 mA a voltaje de 5 V.
LED
Las dos resistencias están conectadas internamente a
tierra para que el dispositivo pueda conectarse
directamente.
Línea recta La línea
recta conecta dos conexiones opuestas.
3 Nº de artículo: 113632 Línea de esquina
ID de ladrillo: ALLBRICK0005 El ladrillo de esquina se usa para conectar dos lados
contiguos.
Cruce en T de línea El cruce
en T se utiliza para hacer ramales. El Ladrillo
también se puede usar en lugar de un Ladrillo de
Esquina.
10 El hardware de un vistazo
1 N.º de artículo: 113675 Línea cruzada dos veces Con este módulo,
Identificación del ladrillo: ALLBRICK0048 las líneas medias pueden reenviarse por separado y
cruzarse al mismo tiempo.
1 N.º de artículo: 113630 Línea de ladrillos de tierra Con
Identificación del ladrillo: ALLBRICK0003 el ladrillo de tierra, puede aplicar tierra fácilmente a
cualquier punto del circuito.Es necesario cerrar el(los)
circuito(s). El bloque de tierra conecta los dos contactos
medios del conector con las dos líneas de tierra exteriores.
1 N.º de artículo: 138408 Adaptador de sensor externo triple tensión de
Identificación del ladrillo: ALLBRICK0649 alimentación: +9 V.
9V
Adaptador de sensor externo triple
1 GND1 5V
3
2 TIERRA 1 2 5V
5V TIERRA 1 2 3
9V
B24_1
1 N.º de artículo: Sensor de temperatura y humedad Sensor de temperatura/
+5V
139778 ID de ladrillo: ALLBRICK0658 humedad integrado, tipo de sensor: DHT11, temp.: 0..50°C
TIERRA
E/S (±2°C), rel.
ALLNET
Humedad: 20..95% (±5%), alimentación: 35,5V. Resistencia
pullup incorporada.
1 Cable USB Cable
de conexión USB (conector tipo A a conector micro USB tipo B)
entre la computadora de desarrollo y el IoT Brick.
El hardware de un vistazo 11
Ladrillos recomendados opcionales
N.º de artículo: 122448 Line Downside Up Un
Identificación del ladrillo: ALLBRICK0385 componente especial para obtener acceso al pin
GPIO12 del nivel de conector inferior del IoT Brick.
Además de los contactos en el nivel superior, también
tiene cuatro contactos independientes en la parte inferior
del tablero. Luego, estos se conducen al nivel superior en
Abajo
los lados, donde se pueden usar ladrillos normales para
HASTA
acceder a las señales.
Opcional
N.º de artículo: 122446 Línea recta de 6 vías La línea
Identificación del ladrillo: ALLBRICK0383 recta de 6 vías prolonga los cuatro contactos en la parte
superior (incluida la tierra en los contactos exteriores) y
las cuatro líneas de señal en el nivel inferior, que son
independientes entre sí.
Opcional
N.º de artículo: 125674 Terminal tipo 2 de 5 pines Puede
Identificación del ladrillo: ALLBRICK0407 usarse para conectar líneas o componentes al circuito.
Use un destornillador pequeño para presionar la ranura
en la parte superior. A continuación, el contacto se abre
y el cable se puede insertar desde el lateral. Cuando sueltas
el destornillador, la línea está atascada. El contacto medio
está conectado a tierra.
Opcional
N.º de artículo: 137824 Pulsador doble
Identificación del ladrillo: ALLBRICK0642 Este bloque contiene 2 contactos NO unipolares. Esto
significa que las entradas de puertas o flipflops se pueden
conectar convenientemente. Además, las rutas de la señal
están conectadas por separado desde la conexión superior
a la inferior. Conecte el suministro a la conexión superior
y/o inferior y ahorre numerosos ladrillos de línea en muchas
situaciones.
Opcional
12 El hardware de un vistazo
5. El ladrillo IoT y el IDE de Arduino
5.1 Conjunto El corazón del Internet de las cosas
El corazón del Brick'R'knowledge Internet of Things Set es el IoT Brick. Su componente central es el módulo ESP12F de AITHINKER.
Consta de un microcontrolador ESP8266 con una interfaz WLAN integrada, una memoria flash de 4 MB y una antena WLAN interna.
Pantalla OLED (128 x 64) Se puede usar en LED de alimentación (3,3 V aceptable)
necesita ser adjuntado
+9V
GPIO12 : este pin está en el nivel del conector inferior (debajo de
GPIO13). No es accesible con los ladrillos incluidos con el
GPIO5 GPIO14 conjunto de Internet de las cosas. Si es necesario, utilice el ladrillo
(SCL) (SCLK)
GPIO4 GPIO13 especial "Line Downside Up" disponible como accesorio
(SDA) (MOSI)
Carolina del Norte
N.º de artículo: 122448, ID de ladrillo: ALLBRICK0385.
GPIO12
(MISO)
SDA SCL 5V TIERRA
Botón de programación también se puede utilizar como Botón de reinicio : el programa se
Se puede consultar GPIO0 reinicia, es decir, se reinicia
Ladrillo IoT
ADDC (10:1)
GPIO3 18 bits
(Rx) I2C, máx. 20 V
GPIO1 10 bits
(TX) GPIO0 RESET int, máx 10V
micro USB
LED de programación (GPIO0)
Fig. 4: El corazón del conjunto de Internet de las cosas
5.1.1 Especificación del ladrillo IoT
Elemento especificación
Microcontrolador MCU de 32 bits de potencia ultrabaja Tensilica L106 de 80 MHz
Memoria flash 4 MB para programas
Interfaz WLAN Protocolo IEEE 802.11 b/g/n, IPv4, dirección IP: se asigna a través de DHCP, pila TCP/IP integrada, banda ISM (2,4
GHz), admite modos de seguridad WPA/WPA2, antena integrada 7 GPIO, función estándar: entrada/salida
GPIO digital, funciones alternativas: I2 C y bus SPI Nivel de salida GPIO: +5 V; Nivel de entrada GPIO: +5 V (¡las
entradas no son tolerantes a 9 V!)
Entradas analógicas ADC 10 bits: convertidor A/D de 10 bits interno (tipo: convertidor SAR), frecuencia de muestreo: 200 S/s máx., rango de
tensión de entrada: 10 V máx. ADC 18 bits: convertidor A/D de 18 bits MCP3421 conectado a través de I2 C (tipo:
convertidor deltasigma), frecuencia de muestreo: 3,75 S/s máx., rango de voltaje de entrada: 20 V máx. 2 botones (botón
de programación GPIO0 y reinicio): son necesarios para el modo de programación (después de iniciar el ESP8266 el botón
botón GPIO0 se puede utilizar como una entrada digital normal)
cuidado Alimentación de 9 V (LED de alimentación con tensión
conexiones integrada de 3,3 V) 1 conector Brick para alimentación de 9
V 4 conectores Brick para un total de 7 GPIO 1 conector
Brick para 2 entradas analógicas Toma Micro USB (tipo B)
como interfaz de programación
2
pantalla yo
La pantalla monocromática COLED (128 x 64 píxeles) se puede enchufar a través de una regleta de enchufes de 4 pines (incluida en el conjunto)
El ladrillo IoT y el IDE de Arduino 13
5.1.2 Los pines GPIO del IoT Brick
Para que un microcontrolador pueda intercambiar datos, se requieren entradas y salidas analógicas y digitales. Las entradas/salidas
digitales generalmente se denominan GPIO. GPIO es la abreviatura de entrada/salida de propósito general y significa que dicha
conexión, dependiendo de la configuración anterior, se puede usar como entrada o como salida. En programación, este cambio de
dirección se conoce como pinMode . El nivel de voltaje de los GPIO en el IoT Brick corresponde a 5 V para nivel alto y 0 V para nivel
bajo. Alternativamente, algunos pines GPIO también pueden asumir funciones especiales, p. B. comunicación de datos a través de bus
I²C o SPI. Para direccionar el pin GPIO deseado en su programa, necesita un índice, que puede tomar de la siguiente tabla:
Alternativamente Resistencia pullup (ver Capítulo índice para

función estándar descripción función 5.1.3)
programación 0
GPIO0
Botón de programación (entrada) bajo: 40kΩ, alto: 4kΩ bajo:
GPIO1 E/S digital 1 E/ TxD 40kΩ, alto: 4kΩ bajo: 40kΩ, 1
GPIO3 S digital 3 E/S RxD alto: 4kΩ 3
GPIO4 digital 4 E/S I 2C SDA bajo: 40kΩ, alto: 4kΩ 4
GPIO5 digital 5 E/S I 2C SCL bajo: 40kΩ, alto: 4kΩ 5
GPIO12** digital 12 E/S SPI MISO bajo: 40kΩ, alto: 4kΩ 12
GPIO13 digital 13 E/S SPI MOSI bajo: 40kΩ, alto: 4kΩ 13
GPIO14 digital 14 Entrada SPI SCLK bajo: 40kΩ, alto: 4kΩ 14
ADC0 (10 bits)
analógica de 10 bits (interna) Entrada 0
ADC1 (18 bits)
analógica de 18 bits (a través de I2C ) (a través de I2C)
Los GPIO 2, 6, 7, 8, 9, 10, 11, 15 y 16 no los proporciona el módulo ESP12F.
*
ver el próximo capítulo. **Pasador en el nivel de enchufe inferior solo accesible con un ladrillo especial opcional (n.º de artículo: 122448, ID de ladrillo: ALLBRICK0385)
Atención: nunca aplique 9 V directamente a los GPIO (por ejemplo, a través de un botón). Aunque se requieren 9 V para
suministrar el ladrillo IoT y otros ladrillos activos, los GPIO solo están diseñados para niveles de 5 V. ¡Los voltajes superiores
a 5 V en los GPIO pueden dañar irreversiblemente sus ladrillos!
5.1.3 Resistencias pullup
En los circuitos digitales es importante que las entradas siempre tengan un nivel definido. Se usa un pequeño truco
para esto, al conectar las llamadas resistencias pullup o pulldown, de modo que la entrada no "cuelgue en el aire",
sino que se lleve a un nivel alto (5 V) o nivel bajo (0 V). En nuestro IoT Brick, se utilizan resistencias pullup con
ajuste de resistencia automático. Con un nivel bajo, el valor es de 40 kΩ (fluye menos corriente, con un nivel alto es
de 4 kΩ (para que el nivel alto se detecte de forma fiable). Esto significa que el nivel de entrada en los GPIO siempre
está claramente definido, por lo que que puede determinar el nivel lógico siempre puede evaluar de manera confiable
un pin configurado con pinMode(GPIOx, INPUT) . En nuestro caso, los comandos pinMode(GPIOx, INPUT_PULLUP)
o pinMode(GPIOx, INPUT_PULLDOWN) no tienen efecto en los pines GPIO, ya que las resistencias pullup siempre
están activas Después de encender el suministro, los GPIO configurados como entrada se establecen inmediatamente
en nivel alto.
+5v
Ladrillo IoT
Alto:
GPIOx
levantar
Bajo:
+3,3 V
GPIO1
GPIO14 bidireccional
convertidor de nivel
Fig. 5: Resistencias pullup
14 El ladrillo IoT y el IDE de Arduino
5.2 El entorno de desarrollo de Arduino
Para programar el IoT Brick, utilizamos el entorno de desarrollo Arduino, también llamado Arduino IDE (IDE significa entorno de
desarrollo integrado). Es posible que muchos ya conozcan el software de programación gratuito del mundo Arduino. Hay numerosos
proyectos basados en Arduino y una gran comunidad en Internet. En nuestros ejemplos de práctica, incluiremos numerosas
bibliotecas de código abierto para facilitarnos la programación de componentes de hardware individuales. Los instaladores están
disponibles para Windows, Linux, MAC OS X y una aplicación de Windows. La descripción y las capturas de pantalla de este manual
se refieren a la versión de Windows.
• Descargue el instalador para el IDE de Arduino más reciente desde https://www.arduino.cc .
• Inicie la instalación del IDE de Arduino haciendo doble clic en el archivo EXE descargado.
Para que el módulo de microcontrolador basado en ESP8266 se pueda programar con la ayuda de este software, ahora se debe
instalar el núcleo correspondiente que incluye algunas bibliotecas necesarias, las llamadas bibliotecas. Esto es necesario porque el
IDE de Arduino no es compatible con el ESP8266 de forma predeterminada.
• Inicie el IDE de Arduino, p. B. a través del menú de inicio en Windows (según el sistema operativo). • Abra el menú "Archivo
Preferencias" e ingrese lo siguiente en "URL adicionales del administrador de tableros".
URL: http://arduino.esp8266.com/stable/package_esp8266com_index.json
Fig. 6: Entrada para URL de administrador de tablero adicionales
• Confirme con Aceptar.
• Abra el "Administrador de tableros..." en el menú "Herramientas – Tablero:...".
Fig. 7: Gerente de la Junta
• Introduzca esp8266 en la ventana de búsqueda. Solo se debe mostrar la entrada "esp8266 by ESP8266 Community"
ser mostrado.
Fig. 8: Instalación ESP8266 a través del administrador de la placa
• Haga clic en la entrada y luego en "Instalar". La instalación puede tardar unos minutos.
• Terminar la instalación con "Cerrar"
• Ahora vuelve al menú "Herramientas – Tablero:...". – "Gerente de la Junta...".
• Seleccione la entrada "Módulo ESP8266 genérico". Una vez seleccionado, el menú debajo de "Placa:..." cambiará para mostrar
numerosas configuraciones. Si es necesario, cámbielos para que coincidan con la captura de pantalla (rectángulo rojo).
Fig. 9: Seleccione ESP8266 en el administrador de la placa
• Ahora continúe con el siguiente capítulo "Instalación de Bibliotecas"...
5.2.1 Instalar bibliotecas
Para simplificar la programación, utilizamos las llamadas bibliotecas en nuestros programas de ejemplo. Estas colecciones de
códigos contienen, p. B. tablas extensas, con las que z. B. Definir conjuntos de caracteres o codificar el control de pantallas de 7
segmentos. La mayoría de las bibliotecas se suministran con el IDE de Arduino, pero aún deben instalarse explícitamente. Otras
bibliotecas deben descargarse primero de Internet y generalmente se incluyen como un archivo ZIP. Si ahora instala todas las
bibliotecas enumeradas aquí, estará bien preparado y no tendrá que volver a instalar nada para los ejercicios individuales. Por
cierto, encontrará las bibliotecas que ha instalado en el siguiente directorio de su computadora por defecto: C:
\Users\my_name\Documents\Arduino\libraries (reemplace my_name con su nombre de usuario).
También puede encontrar instrucciones para instalar bibliotecas adicionales de Arduino en:
https://www.arduino.cc/en/Guide/Bibliotecas
dieciséis El ladrillo IoT y el IDE de Arduino
5.2.1.1 Instalar bibliotecas de Arduino
• Abra el administrador de bibliotecas en el menú "Boceto – Incluir biblioteca – Administrar bibliotecas...".
Fig. 10: Administrador de biblioteca
• Ahora instale las bibliotecas requeridas usando los siguientes capítulos. Limitar la selección
términos de búsqueda adecuados (consulte las siguientes capturas de pantalla). Si se ofrece una selección de versión, generalmente
se puede instalar la última versión. Haga clic en la entrada y luego en "Instalar".
5.2.1.1.1 Biblioteca "NTPClient"
Se requiere que la biblioteca obtenga la hora y la fecha de Internet a través del Network Time Protocol (NTP).
Fig. 11: Instalación de la biblioteca "NTPClientLib"
• Seleccione la biblioteca con la última versión y haga clic en "Instalar".
• El archivo de encabezado se incluye con la instrucción #include <NTPClientLib.h> .
5.2.1.1.2 Biblioteca "Tiempo"
Se requiere que la biblioteca obtenga la hora y la fecha de Internet a través del Network Time Protocol (NTP).
Fig. 12: Instalación de la biblioteca "Time"
• Los archivos de encabezado se incluyen con las instrucciones #include <Time.h> y #include <TimeLib.h> .
5.2.1.1.3 Biblioteca "Json Streaming Parser"
Se requiere que la biblioteca consulte el tipo de cambio actual del dólar desde Internet.
Fig. 13: Instalación de la biblioteca "Json Streaming Parser"
• El archivo de encabezado se incluye con la instrucción #include <JsonListener.h> .
5.2.1.1.4 Biblioteca "Biblioteca de sensores DHT"
La biblioteca es necesaria para leer la temperatura y la humedad del sensor DHT11.
Fig. 14: Instalación de la biblioteca "Biblioteca de sensores DHT"
• Los archivos de encabezado se incluyen con las instrucciones #include <DHT.h> y #include <DHT_U.h> .
5.2.1.1.5 Biblioteca "Sensor unificado de Adafruit"
La biblioteca es necesaria para leer la temperatura y la humedad del sensor DHT11.
Fig. 15: Instalación de la biblioteca "Adafruit Unifi ed Sensor"
• El archivo de encabezado se incluye con la instrucción #include <Adafruit_Sensor.h> .
5.2.1.2 Instalar bibliotecas externas
El procedimiento es el mismo para cada biblioteca:
• Primero debe descargar la biblioteca requerida de Internet. la respectiva descarga
Encontrará páginas en los siguientes capítulos.
• Luego abra el menú "Sketch – Incluir biblioteca – Agregar biblioteca .ZIP...".
• Allí seleccionas el archivo ZIP descargado.
5.2.1.2.1 Biblioteca "esp8266oledssd1306master"
Para simplificar el control de la pantalla OLED, utilizamos la biblioteca "esp8266oled ssd1306master". Esto se
puede descargar desde la página de GitHub como un archivo ZIP.
• Vaya a: https://github.com/squix78/esp8266oledssd1306. Allí en "Clonar o descargar" seleccione la opción
"Descargar ZIP" y guarde el archivo ZIP en su computadora:
Fig. 16: Biblioteca de instalación "esp8266oledssd1306master"
• Instale la biblioteca usando el menú "Sketch – Incluir biblioteca – Agregar biblioteca .ZIP…". • El archivo de
encabezado se incluye con la instrucción #include <SSD1306Wire.h> .
5.2.1.2.2 Biblioteca "MCP3421"
Para simplificar la comunicación con el convertidor A/D de 18 bits MCP3421, utilizamos la biblioteca "MCP3421".
Esto se puede descargar como un archivo ZIP.
• Siga el enlace: http://interface.khm.de/index.php/lablog/connectamcp342118bitanalogtodigitalconverter
toanarduinoboard/. Al final de este sitio web encontrará el enlace a la biblioteca que está buscando en
"Descarga de la biblioteca".
• Descargue y guarde el archivo MCP3421.zip
tu computadora.
• Instale la biblioteca usando el menú "Sketch – Incluir biblioteca – Agregar biblioteca .ZIP…".
• El archivo de encabezado se incluye con la instrucción #include <MCP3421.h> .
5.2.1.2.3 Biblioteca "BrickESP8266"
Se requiere que la biblioteca, entre otras cosas, consulte el tipo de cambio actual del dólar desde Internet.
Esto se puede descargar como un archivo ZIP.
• Siga el enlace: http://www.brickrknowledge.de/downloads.
• Descarga el archivo BrickESP8266.zip y guárdalo en tu computadora.
• Instale la biblioteca usando el menú "Sketch – Incluir biblioteca – Agregar biblioteca .ZIP…". • El archivo de
encabezado se incluye con la instrucción #include <CurrencylayerClient.h>
Si falta una biblioteca, esto se indica mediante un mensaje de error correspondiente durante la compilación:
Fig. 17: Error de compilación
Si aún no ha instalado el controlador para el puente USB a UART, continúe con el Cap. 5.2.2 continuación.
5.2.2 Controlador de puerto COM virtual
Para que su computadora de desarrollo pueda comunicarse con el IoT Brick, la interfaz de su PC a través de la cual se
establecerá la conexión con el IoT Brick debe seleccionarse en el IDE de Arduino.
Para ello, puede seleccionar un puerto serie (también llamado puerto COM) en el IDE de Arduino.
Tradicionalmente, estas son interfaces RS232 que, sin embargo, difícilmente se pueden encontrar en las computadoras
modernas. En su lugar, usamos un puerto USB libre en su computadora, que engañamos al IDE de Arduino como un puerto
serie. Para dejar esto claro para el sistema operativo, necesitamos instalar un controlador de puerto COM virtual (VCP). Este
es un requisito previo para la comunicación entre el IDE de Arduino y la interfaz USB del IoT Brick.
• Descargue el controlador más reciente para su sistema operativo (Windows, MAC OS X, Linux) de Silicon Labs
Descargar sitio web:
https://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx
Fig. 18: Captura de pantalla de la página de descarga con un enlace para las versiones actuales de Windows
• Descomprima el archivo empaquetado en su computadora
• Inicie la instalación con un doble clic. Según la versión de Windows, debe iniciar el instalador adecuado:
CP210xVCPInstaller_x86.exe para una versión de Windows de 32 bits o CP210xVCPInstaller_x64.exe para una versión
de 64 bits.
• En el Administrador de dispositivos de Windows, en "Puertos (COM y LPT)", debe haber una entrada similar a la
marcada con una flecha roja. La cantidad de puertos COM y el índice dependen de la configuración de su computadora.
Fig. 19: Puerto COM virtual en el administrador de dispositivos
5.2.3 Monitor de serie
Algunos programas de muestra utilizan el llamado monitor en serie para mostrar valores y mensajes directamente en la
computadora de desarrollo. Para abrir el monitor serie, simplemente haga clic en el icono de la lupa en la esquina superior
derecha del IDE de Arduino. La velocidad en baudios en la ventana del monitor (abajo a la derecha) y en el esquema deben
coincidir (ver Fig. 20).
Fig. 20: Datos de salida en monitor serie
5.3 Primeros pasos
¡Ahora se está poniendo emocionante! Después de haber instalado el entorno de desarrollo de Arduino, incluidas las
bibliotecas y el controlador del puerto COM virtual, ahora es el momento de iniciar.
5.3.1 Establecer conexión
Primero conecte el IoT Brick a la fuente de alimentación de 9 V incluida en la conexión superior provista (consulte la
Fig. 21).
Precaución: nunca conecte la fuente de alimentación de 9 V a los otros contactos del IoT Brick
conecte, ¡esto podría destruir el módulo!
Conecte su computadora de desarrollo y el IoT Brick (puerto micro USB) con el cable USB suministrado.
¡Peligro!
+

Conecte únicamente la fuente
de alimentación de 9 V al
contacto superior del IoT Brick.
¡De lo contrario, el Ladrillo
9V
1A
puede ser destruido!
El LED rojo indica
disponibilidad operativa.
+9V
GPIO5 GPIO14
(SCL) (SCLK)
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
GPIO12
(MISO)
SDA SCL 5V TIERRA
Ladrillo IoT
ADC (10:1)
GPIO3 18 bits
(Rx) I2C, máx. 20
GPIO1 V 10 bits
micro USB
Fig. 21: Conexión básica del IoT Brick
La computadora ahora debería tener un nuevo puerto COM virtual, a través del cual Arduino IDE carga los programas
en el IoT Brick. Una forma bastante sencilla de averiguar el índice del puerto COM es a través del propio entorno de
desarrollo de Arduino.
• Primero desconecte el cable USB del IoT Brick.
• Inicie el software Arduino y verifique qué puerto(s) COM en "Herramientas Puerto: ...".
ser mostrado.
• Ahora vuelva a conectar el cable USB al IoT Brick. Ahora debería mostrarse otra interfaz COM en "Herramientas
– Puerto: ...". Ahora selecciona esto. Si esto no es posible, desinstale el puerto COM en el administrador de
dispositivos y vuelva a instalar el controlador "CP210x USB to UART Bridge". Véase también el cap. 5.2.2 en la
página 20.
Fig. 22: Izquierda: cable USB no enchufado, derecha: cable USB enchufado (puerto COM virtual seleccionado)
En el menú "Herramientas" tiene que seleccionar o comprobar otros parámetros. Se deben seleccionar los ajustes que se muestran en la
siguiente captura de pantalla. En "Puerto:" debe seleccionar la interfaz COM que se asignó previamente al puerto COM virtual.
Fig. 23: Configuración para IoT Brick
5.3.2 Compilar y cargar el código del programa
Con un clic en el botón con la marca de verificación, el código del programa, llamado Sketch en el mundo Arduino, se verifica en busca de
errores de sintaxis y se compila. Los errores de sintaxis son errores tipográficos en su boceto o violaciones de las reglas del lenguaje de
programación. Al compilar, el código de su programa se traduce en código de máquina que nuestro microcontrolador puede ejecutar. Esto lo
hace automáticamente un compilador (traductor) integrado en el IDE de Arduino.
Una vez que el código de su programa se haya compilado con éxito, puede cargar el programa en el IoT Brick haciendo clic en el botón de
flecha. El LED rojo en el IoT Brick en la parte inferior izquierda junto al puerto USB se enciende mientras el programa se carga en la memoria
flash. El comienzo y el final del proceso de carga se señalan cada uno con un breve parpadeo. Una vez completada la carga, el LED se apaga
de nuevo.
Fig. 24: Comprobar, compilar y cargar boceto
En el próximo capítulo descubrirá cómo puede iniciar el modo de programación manualmente si es necesario.
5.3.3 Modo de programación
Procedimiento si desea activar el modo programación manualmente. Esto solo es necesario si falla la comunicación entre Arduino IDE e IoT
Brick.
1. Presione y mantenga presionado el botón de programación (GPIO0) (el LED rojo debajo de la izquierda se ilumina intensamente)
2. Presione simultáneamente el botón de reinicio
3. Suelte el botón de reinicio nuevamente
4. Luego suelte el botón de programación (el LED rojo
debajo a la izquierda se enciende débilmente)
6. Ejemplos de ejercicios
6.1 "Hola mundo" (LED parpadeante)
Abra el boceto en el IDE de Arduino: Example_6.1.ino
Como suele suceder en el mundo de la programación, comienza con un ejemplo de "Hola mundo". En nuestro caso, dejamos que
dos LEDs parpadeen alternativamente.
Un programa, llamado boceto en el mundo de Arduino, siempre consta de al menos dos partes.
La rutina de configuración void setup()
Primero viene la sección void setup() {…}. Todos los comandos dentro de estos corchetes se ejecutan exactamente una vez cuando se
inicia el programa. En nuestro ejemplo, la dirección de los pines GPIO se define aquí, es decir, entrada (modo: entrada) o como en nuestro
caso: dos salidas (modo: salida).
El bucle del programa void loop()
El programa real está contenido entre llaves de void loop() {...} y se repite constantemente. Los comandos se ejecutan uno tras otro en un
bucle sin fin hasta que el programa, p. B. se cancela presionando el botón de reinicio.
En nuestro primer ejemplo de programación (Example_6.1.ino) , el bloque LED doble está conectado a los GPIO 13 y 14 del bloque IoT.
+
configuración vacía ()
}
{ pinMode (14, SALIDA);
pinMode(13, SALIDA);
// Se emite el pin 14
// Se emite el pin 13
9V
1A
bucle vacío ()
{ digitalWrite (14, ALTO); // LED en el pin 14 a digitalWrite (13,
+9V
LED
BAJO); // LED encendido pin 13 apagado
GPIO5
(SCL)
GPIO14
(SCLK)
retraso (1000); // esperar 1000ms
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
LED
GPIO12
(MISO) escritura digital (14, BAJO); // LED encendido pin 14 apagado
digitalWrite(13, HIGH); // LED en el pin 13 encendido
Ladrillo IoT retraso (1000); // esperar 1000ms

}
ADDC (10:1)
GPIO3 18 bits
(Rx) I2C, máximo
GPIO1 20 V 10 bits
(TX) REINICIO GPIO0 interno, máximo 10V
micro USB
Conexión USB a la computadora de desarrollo
Fig. 25: Ejemplo de ejercicio: "Hello World" (LED intermitente)
GPIO 13 y 14 se definen como salida en la rutina de configuración con pinMode(GPIOx, OUTPUT) .
Por lo tanto, estos pines pueden emitir un alto nivel para hacer que los dos LED parpadeen alternativamente.
En el bucle, el pin se establece alto con digitalWrite(GPIOx, HIGH) . Esto significa que se emiten 5 V en el GPIO respectivo y el LED se
ilumina. El pin se establece en 0 V con el comando digitalWrite (GPIOx, LOW) : el LED se apaga.
Con el comando delay(...) , el flujo del programa se detiene por el número correspondiente de milisegundos.
En este ejemplo 1000 milisegundos, que corresponde a un segundo.
ejemplos de práctica 23
Una vez que haya cargado el ejemplo de código en su IoT Brick (consulte el capítulo 5.3.2 en la página 22), los dos LED parpadean
alternativamente. Juega un poco con el código. Cambie el orden en que los LED se encienden y apagan, y el tiempo entre ellos.
6.2 Botones y LED
Abra el boceto en el IDE de Arduino: Example_6.2.ino
En este ejemplo queremos que los LEDs se enciendan dependiendo de un botón. Además de su botón de reinicio, el IoT Brick tiene otro
botón que está conectado al GPIO0. Entonces usamos el GPIO0 como entrada y leemos el estado del botón. Para evitar la presencia de
un nivel indefinido en esta entrada mientras no se presione el botón, se instaló internamente una resistencia pullup, que lleva la entrada a
un nivel alto (consulte también el capítulo 5.1.3 en la página 14). Tan pronto como se presiona el botón, hay 0 V en la entrada. De esta
manera, siempre se puede determinar claramente si el botón se presiona o no.
No se confunda que el LED de programación en la parte inferior izquierda también se enciende mientras mantenga presionado el botón. El
LED y el botón están permanentemente conectados y no tienen nada que ver con su código de programa.
+
configuración vacía ()
{ pinMode (0, ENTRADA); // El pin 0 es la entrada del botón
pinMode(14, SALIDA); // Se emite el pin 14
9V
1A SALIDA); // pin 13 es salida pinMode(13,
}
+9V
LED
bucle vacío () {
si (lectura digital (0) == BAJO) {
GPIO5
(SCL)
GPIO14
(SCLK)
// cuando se presiona el boton
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
GPIO12
(MISO)
LED
escritura digital (14, ALTO); // LED en el pin 14 encendido
escritura digital (13, BAJO); // LED encendido pin 13 apagado
botón
Ladrillo IoT
} // si NO se presiona el botón else{
ADC (10:1)
GPIO3
(Rx)
I2C de
18 bits , 20 V máx. apagado digitalWrite(14,LOW); // LED encendido pin 14
GPIO1 10 bits
(TX) GPIO0 RESET interno , máximo 10V
digitalWrite(13,HIGH); // LED en el pin 13 en
micro USB }
Conexión USB a la computadora de desarrollo retraso (100); // esperar 100ms

}
Fig. 26: Ejemplo de ejercicio: botón y LED)
Mientras no se presione el botón, el LED amarillo en GPIO13 se enciende. Tan pronto como se presiona el botón, se enciende el LED rojo
en GPIO14.
El comando delay(100) al final del ciclo hace que el programa espere 100 milisegundos en ese punto. El microcontrolador puede "pausar"
durante este tiempo.
¡Y ahora es tu turno otra vez! Modifique un poco el código para entenderlo mejor. Por ejemplo, deje que el LED se encienda en secuencia
tan pronto como presione el botón.
Atención: No utilice ningún botón externo que esté conectado directamente a 9 V, ya que los GPIO solo están diseñados para
niveles de 5 V. Recomendamos usar el botón incorporado GPIO0. ¡Los voltajes superiores a 5 V en los GPIO pueden causar
daños irreversibles al IoT Brick!
24 ejemplos de práctica
6.3 Autobús I2C
El bus I2C es una interfaz serial que funciona con dos líneas. La línea de reloj SCL (Serial Clock) y la línea de datos SDA (Serial
Data). Las líneas funcionan bidireccionalmente. Cuando se trata de participantes del bus, se hace una distinción entre maestro
y esclavo. En nuestro caso, el IoT Brick es el maestro y los demás
Los ladrillos son esclavos. Los participantes del autobús se dirigen a través de direcciones I2C, 128 son posibles por autobús.
Los participantes individuales del autobús también pueden ocupar varias direcciones. Algunos participantes del bus tienen
pequeños interruptores DIP en la parte posterior para que las áreas de direcciones se puedan cambiar si se utilizan varios
participantes del bus en el mismo bus.
En principio, el autobús se puede operar a diferentes velocidades:
Moda velocidad
Modo predeterminado (Sm) 0,1Mbps
Modo Rápido (Fm) 0,4Mbps
Modo de alta velocidad (modo HS) 1.0Mbps
Modo ultrarrápido (UFm) 5.0Mbps
Muchos microcontroladores solo dominan los dos primeros modos (por ejemplo, el controlador del Arduino Nano) y algunos
también el tercer modo. Lo mismo se aplica a los componentes periféricos. Por supuesto, los modos tienen que encajar juntos.
El maestro, es decir, generalmente el microcontrolador, configura el reloj en la línea SCL. Los datos reales se transmiten a
través de la línea SDA.
V+
Dispositivo 1 Dispositivo 2 dispositivo m
SCL
ASD
Fig. 27: Estructura del bus I2 C
Se pueden conectar un máximo de 128 dispositivos a un bus I2C, siempre que cada dispositivo ocupe solo una dirección, de
lo contrario, menos. Los dispositivos están conectados entre sí a través de dos líneas de bus.
Las dos resistencias pullup (en el rango de kΩ) para la tensión de alimentación ya están instaladas en el bloque IoT.
ASD
SCL
datos validos datos validos
cambios de datos
Fig. 28: Datos válidos en el bus I2 C
El reloj indica cuando hay datos válidos presentes. En la Fig. 28 puede ver que este es siempre el caso con el nivel alto de la
línea SCL. El receptor ahora puede muestrear y evaluar los datos. El maestro ajusta el reloj, luego crea datos por sí mismo o
los espera del dispositivo correspondiente.
MSB de datos LSB de datos Reconocimiento

(Parte más significante) (bit menos significativo) ACK
SDA
total
ASD de
Canal
ASD de
recipiente
SCL de
Maestro
12 789
STOP, START de
Dirección esclava + (R/W) Byte de datos (8 bits) nuevo o siguiente byte de datos
Fig. 29: Transferencia de datos en el bus I2 C
En la Fig. 29 puede ver el curso temporal de una transferencia de datos con las siguientes señales (de abajo hacia arriba): la señal
de reloj SCL (especificada por el maestro), la línea de datos desde el punto de vista del receptor (receptor) no es controlado
activamente porque es de baja actividad, los bits de datos son enviados por el transmisor (baja actividad) y en la parte superior de
la señal SDA en la vista general. La sincronización es importante. Un receptor (ya sea maestro o esclavo) envía una señal de
reconocimiento (ACK = reconocimiento) al final de cada paquete de datos tirando de la línea SDA a nivel bajo. Dado que esto
corresponde a un OR cableado, es suficiente si un esclavo envía la señal ACK.
MSB LSB R/W RECONOCIMIENTO MSB LSB ACK
ASD
SCL
12 789 12 789
COMENZAR Dirección de esclavo (7 bits) + bit de lectura/escritura (R/W) Byte de datos (8 bits) PARADA
Fig. 30: Ciclo de transmisión en el bus I2 C
En la Fig. 30 se puede ver todo el ciclo de transmisión. Primero, se envía un paquete con la dirección.
La dirección consta de 7 bits, complementados con un bit adicional llamado R/W (Lectura/Escritura). Todos los participantes del
autobús comparan la dirección transmitida con la suya. Si coinciden, el esclavo en cuestión reconoce con una señal ACK ajustando
brevemente la línea SDA a bajo. Dependiendo del bit R/W, el esclavo direccionado sabe si debe iniciar un ciclo de envío o recepción.
Entonces puede comenzar la transferencia de datos real. Al final, se inicia un ciclo de parada. Para hacer esto, el reloj se establece
en alto y luego se libera la línea SDA. Las líneas SDA y SCL ahora son altas, lo que significa que el bus I2C es de uso gratuito.
Teóricamente, otro maestro (si hay varios en el bus) ahora puede iniciar un nuevo ciclo.
Para nosotros, el bus I2C es fácil de usar porque la biblioteca Arduino proporciona varios comandos para usar ladrillos con una
interfaz I2C, como p. B. para controlar el bloque de visualización de 7 segmentos a través del bloque IoT.
6.3.1 La pantalla de 7 segmentos
En los primeros días de la tecnología informática, la gente pensaba en cómo se podían representar los dígitos. En ese momento,
las más sencillas eran 10 lámparas, que se etiquetaban del 0 al 9. Más tarde, las lámparas se usaron para iluminar pequeñas
placas de vidrio con los orificios correspondientes. Al mismo tiempo, aparecieron los llamados tubos Nixi, los dígitos estaban hechos
de alambre, y cuando se aplicaba un voltaje más alto en una atmósfera de gas inerte, los dígitos comenzaban a brillar. Luego se
les ocurrió la idea de dividir los números en segmentos. Todos los dígitos entre 0 y 9 se pueden representar con siete segmentos.
Las primeras pantallas todavía usaban filamentos, pero con la llegada de los LED se volvió más simple.
Detrás de cada segmento hay un LED que ilumina la barra. Los segmentos individuales a menudo se denominan a a g. Además,
hay un solo LED para el punto decimal (dp).
F b
GRAMO
mi C
doble penetración
es decir
Fig. 31: La pantalla de 7 segmentos
Los dígitos del 0 al 9 se pueden representar de esta forma de forma sencilla. Con la pantalla OLED (consulte el capítulo 6.4
en la página 32) conoceremos más adelante una forma de pantalla más elegante, que también se puede utilizar para mostrar
gráficos simples.
Nuestro ladrillo de pantalla de 7 segmentos alberga dos pantallas de 7 segmentos que están
PCF8574 T +9V
conectadas a través del bus I2C. La pantalla de la izquierda también se conoce como el Dirección:40,44,48,4C
LED de 7 segmentos I²C
carácter MSB (del bit más significativo) en el código del programa y la pantalla de la derecha SCL
SCL
como el carácter LSB (del bit menos significativo); consulte también el cap. 6.5.2.5 en la
página 38. Las dos pantallas de 7 segmentos se controlan cada una a través de un módulo ASD
ASD
de extensión de E/S del tipo 8574T. Este módulo maneja la decodificación de direcciones en
el bus I2C y la decodificación del byte de datos (aquí: número) para controlar los siete +9V
segmentos, incluida la etapa del controlador LED.
6.3.2 Pantalla de 7 segmentos como bloque I2C : estructura y direcciones
Abra el boceto en el IDE de Arduino: Example_6.3.2.ino. Debe incluir el siguiente archivo de encabezado: Wire.h. Si
aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
Ahora implementamos un circuito simple con la pantalla de 7 segmentos. La dirección I2C del bloque se puede configurar
con dos pequeños interruptores en la parte posterior (direcciones posibles en hexadecimal: 40(16), 44(16), 48(16), 4C(16)).
Esto significa que se pueden usar un máximo de cuatro de estos ladrillos en un bus I2C.
Atención: la dirección 40(16) (ver Fig. 32) suele estar predeterminada. Es posible que se deba verificar la configuración
(consulte también Sketch Example_6.3.2.ino ) y ajustarla. Los interruptores se encuentran en la parte posterior de la placa
y son accesibles desde el exterior a través de un orificio en la parte inferior. Con un poco de habilidad, puede usar los
pequeños interruptores deslizantes, p. B. ajustar con un palillo.
Posición del interruptor DIP para configurar la dirección I2 C:
40 (16): 44(16) : 48(16): 4C(16):

SO
12 12
1 12 12 12 12
0
(Por defecto
Actitud)
Fig. 32: Ajuste de dirección I2 C Ladrillo de 7 segmentos
Nota: Todos los participantes en el autobús I2C deben tener una dirección diferente
utilizar. De lo contrario, se producirán fallos de funcionamiento.
Hemos preparado una pequeña biblioteca para el entorno de desarrollo de Arduino en la que se codifican todos los segmentos. Esto se
hace con la ayuda de la llamada tabla de caracteres. Los dígitos e incluso todas las letras de la A a la Z se asignan con un byte a la
combinación de los segmentos en una tabla. Para simplificar las cosas, ya hemos preparado algunos subprogramas.
La función display_seg1x() muestra un solo segmento. Para ello, se transfiere la dirección I2C del módulo de controlador
correspondiente. La función get_7seg() convierte el código ASCII en el índice de la tabla con las asignaciones de segmentos. Si es
necesario, los segmentos también se pueden controlar directamente con display_seg1x bin() . Hay dos módulos de controlador de
este tipo para los dos dígitos, que se direccionan con una dirección ascendente a una distancia de 2. De forma predeterminada, el
boceto usa la dirección I2C para el dígito de orden inferior (también llamado "carácter LSB" en el boceto) : 40 (16), y para el dígito de
orden superior 42 (16) (también llamado "carácter MSB" en el croquis).
La mejor manera de hacer esto es estudiar nuestro ejemplo de programa más de cerca y simplemente experimentar con él.
+

1A 9V
PCF8574 T +9V
Dirección:40,44,48,4C +9V
SCL
SCL
GPIO5 GPIO14
(SCL) (SCLK)
ASD GPIO4 GPIO13

ASD (SDA) (MOSI)
Carolina del Norte
GPIO12
+9V (MISO)
Recomendación: no conecte la pantalla OLED
en este ejemplo para evitar fallas en el bus I2
C debido a una programación incorrecta.
Ladrillo IoT
ADC (10:1)
GPIO3 18 bits
(Rx) I2C, máximo
GPIO1 20 V 10 bits
micro USB
Fig. 33: Ejemplo de ejercicio: visualización de la dirección I2 C del bloque de 7 segmentos
extracto del programa
bucle vacío () {
// Pantalla de 7 segmentos con módulo de controlador 8574T
// Imprimir todas las direcciones potenciales para identificación
// Puede ver qué dirección está configurada seg1x(i2cseg7x2amsb1,'4'); //
pantalla _ dirección propia seg1x(i2cseg7x2alsb1,'0'); // salida
pantalla _ seg1x(i2cseg7x2bmsb1,'4'); // siempre son PARES
pantalla _ seg1x(i2cseg7x2blsb1,'4'); // dos comandos para un BRICK
pantalla _ seg1x(i2cseg7x2cmsb1,'4'); seg1x(i2cseg7x2clsb1,'8'); // de 0x40 a 0x4C
pantalla _ seg1x(i2cseg7x2dmsb1,'4'); seg1x(i2cseg7x2dlsb1,'C');
pantalla _
pantalla _
pantalla _
}
¿Lo que está sucediendo?
El programa de ejemplo (ver Sketch Example_6.3.2.ino) muestra la dirección I2C encontrada en la pantalla enviando la dirección como un
byte de datos a la dirección correspondiente. Esto se repite con todas las direcciones significativas (40(16), 44(16), 48(16), 4C(16)) . Tan
pronto como se envía la dirección correcta, el Brick se siente identificado y muestra la dirección adecuada. De esta manera, puede averiguar
fácilmente el valor y anotarlo.
6.3.3 Pantalla de 7 segmentos como contador
Abra el boceto en el IDE de Arduino: Example_6.3.3.ino. Debe incluir el siguiente archivo de encabezado: Wire.h. Si aún no ha
instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
En el ejemplo queremos implementar un contador simple. Puede usar el mismo circuito que en la Fig. 33. El conteo se guarda en la variable
contador . El programa aumenta el valor en uno cada 500 ms. Sin embargo, el valor máximo que se puede mostrar en una pantalla de 7
segmentos de dos dígitos es 99. Por esta razón, el valor de contador superior a 99 se consulta en una consulta si. Tan pronto como este sea
el caso, la pantalla se restablecerá a 00. Entonces, el contador variable cuenta de 0 a 99 y luego comienza nuevamente en 0.
bucle vacío() { // En el bucle
búfer de carbón[10]; // Usar búfer de caracteres de tamaño definido
contador int estático = 0; // Poner la variable contador a 0
sprintf(búfer,"%02d",contador++); // Convertir entero a caracter
si (contador >99) contador = 0; // El contador debe funcionar entre 0..99
// Muestra el contador como dos dígitos, por lo tanto, el búfer 0 y 1 muestran la pantalla
_ seg1x(i2cseg7x2alsb1,búfer[1]); // Carácter LSB en la dirección 0x40 seg1x(i2cseg7x2amsb1,buffer[0]); //
_ Carácter MSB en la dirección 0x42
retraso (500); // contar aproximadamente cada 500 ms.
} // fin del ciclo
De forma predeterminada, el boceto usa la dirección I2C para el dígito de orden inferior (también denominado "carácter
LSB" en el boceto): 40(16), y para el dígito de orden superior 42(16) (también denominado "carácter MSB" en el croquis).
Cabe señalar que el bucle tarda un poco más de 500 ms porque, en sentido estricto, al retardo que provoca el comando delay(500) hay que
sumar los tiempos de ejecución de los otros comandos , si quieres trabajar con más precisión, tienes que usar un temporizador y consultarlo.
6.3.4 Pantalla de 7 segmentos con eliminación de rebote de teclas
Abra el boceto en el IDE de Arduino: Example_6.3.4.ino. Debe incluir el siguiente archivo de encabezado: Wire.h. Si
aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
Los botones e interruptores tienen la desventaja de que cuando se accionan, el contacto mecánico (a menudo se trata de
un resorte) provoca múltiples cierres y aperturas. Este efecto disruptivo también se denomina "rebote" en la tecnología
digital. Este problema se puede resolver a nivel de hardware con un simple flipflop RS (puede leer más sobre esto en el
conjunto lógico de conocimientos de Brick'R'). En este ejercicio, conocerá la eliminación de rebotes de teclas a través del
software como alternativa. La idea básica es utilizar los llamados retrasos para crear un tiempo de espera en el software
que dure al menos tanto como un ciclo de rebote.
Para la demostración, usamos de nuevo nuestro contador, que ya conoces del ejercicio 6.3.3.
+
Variantes opcionales:
9V
1A
Experimente con el ladrillo de doble botón disponible
opcionalmente y programe un contador ascendente/
descendente, por ejemplo. Conecte el Brick exactamente
como se muestra en la imagen. Asegúrese de que no haya
un voltaje >5 V en los GPIO, de lo contrario, el IoT Brick
puede dañarse irreversiblemente.
PCF8574 T +9V
Dirección:40,44,48,4C +9V
SCL
SCL
GPIO5 GPIO14
Opcional
(SCL) (SCLK)
ASD GPIO4 GPIO13

ASD (SDA) (MOSI)
Carolina del Norte
GPIO12
+9V (MISO)
GPIO14
Recomendación: no conecte la pantalla Ladrillo IoT
OLED en este ejemplo para evitar fallas
en el bus I2 C debido a una ADC (10:1)
GPIO3 18 bits
programación incorrecta. (Rx) I2C, máximo
GPIO1 20 V 10 bits
micro USB
Opcional
Botón (GPIO0) Experimente con el bloque "5 pines tipo 2 terminal" disponible
opcionalmente para poder evaluar los contactos de conmutación
externos (p. ej., un contacto de alarma). Asegúrese de que no
haya un voltaje >5 V en los GPIO, de lo contrario, el IoT Brick
puede dañarse irreversiblemente.
Fig. 34: Contador con llave antirrebote
Atención: No utilice ningún botón externo que esté conectado directamente a 9 V, ya que los GPIO solo están
diseñados para niveles de 5 V. Recomendamos usar el botón incorporado GPIO0. ¡Los voltajes superiores a 5 V
en los GPIO pueden causar daños irreversibles al IoT Brick!
Pruebe diferentes valores en el comando de retardo para determinar el tiempo de espera más corto posible pero aún
confiable. También experimente con los ladrillos que están disponibles como opción, como los ladrillos de "doble botón" y
"terminal de 5 pines tipo 2" que se muestran en la Fig. 34. Asegúrese de que los GPIO configurados como entradas solo
estén conectados a tierra. Siempre que el botón o interruptor esté abierto, hay un nivel alto en el pin porque las resistencias
pullup están instaladas internamente (consulte el capítulo 5.1.3 en la página 14).
presiona el botón
Interrogar
cerrado
tiempo de espera
Fig. 35: Eliminación de rebotes de teclas mediante software
Algoritmo para el rebote
El botón se comporta como activo bajo, es decir, al presionarlo se aplica un nivel bajo a la entrada (en el ejemplo GPIO0). Se consulta la
señal para la primera transición de alto a bajo (si se consulta), luego se espera hasta que sube (es decir, se supone que se suelta el botón);
se sale del bucle while. A partir de ahora, el tiempo de retardo (aquí 40 ms) comienza a emitir finalmente la nueva lectura válida del medidor.
Ahora espera la siguiente pulsación de tecla, es decir, la transición de mayor a menor. Tenga en cuenta que la duración del retraso depende
del tipo de botón utilizado. El valor óptimo puede tener que determinarse experimentalmente para evitar que se evalúen pulsos de rebote.
bucle vacío() { // bucle
búfer de carbón[10]; // Usar búfer de caracteres de tamaño definido
contador int estático = 0; // Poner la variable contador a 0
sprintf(búfer,"%02d",contador); // Convertir entero a caracter
// Consulta el botón, puede rebotar si
(digitalRead(0)==LOW) { // Verifica si hay alto>bajo // Luego espera la transición
bajoalto // También podrías hacerlo después del retraso, pero es no crítico
while (digitalRead(0)==LOW) { // espera hasta
que el botón se suelta o rebota. } contador++; // incrementa el retardo
del contador (40); // luego espere para que la consulta no se vuelva a
intentar demasiado rápido
} // fin de la instrucción if Alto>Bajo
si (contador > 99) contador = 0; // El contador debe funcionar entre 0..99
// Muestra el contador como dos dígitos, por lo tanto, el búfer 0 y 1 seg1x(i2cseg7x2alsb1,buffer[1]); //
pantalla de _ Carácter LSB en la dirección 0x40 seg1x(i2cseg7x2amsb1,buffer[0]); // Carácter MSB en la dirección
visualización _ 0x42
} // fin del ciclo
¿Lo que está sucediendo?
Con cada pulsación del botón, la salida en la pantalla debería aumentar exactamente en "1", es decir, 00, 01, 02 ... 99.
La pantalla vuelve a saltar a 00.
No se confunda que el LED de programación en la parte inferior izquierda también se enciende mientras mantiene presionado
el botón GPIO0. El LED y el botón están permanentemente conectados y no tienen nada que ver con su código de programa
hacer.
6.4 Fundamentos de la pantalla OLED
Las pantallas de 7 segmentos normalmente solo se usan para dígitos y, en una medida muy limitada, también
para letras. Con pantallas de 14 y 16 segmentos, las letras también se pueden mostrar de forma útil. Luego
estaban las primeras pantallas de cuadrícula, con una matriz de 5 x 7 puntos podías mostrar las fuentes mucho
mejor, pero los primeros símbolos gráficos también eran posibles con esto. Inicialmente, las pantallas se
basaban en LED, luego aparecieron en el mercado LCD (pantallas de cristal líquido) y, más recientemente,
OLED (diodos orgánicos emisores de luz). Nuevamente, estos son más similares a los LED porque pueden
encenderse solos. Nuestro conjunto contiene una pantalla OLED monocromática con 128 x 64 píxeles, con la
que no solo se pueden mostrar caracteres individuales, sino también texto de varias líneas y gráficos simples.
Para poder mostrar caracteres en la pantalla de esta manera, necesita un generador de caracteres o una tabla,
similar a la de la pantalla de 7 segmentos. El código numérico se traduce al estado activado o desactivado de los segm
El generador de caracteres o la tabla de juegos de caracteres requiere mucha más memoria. El valor depende
del número de píxeles por carácter. El más pequeño con aproximadamente 5 x 7 píxeles requiere alrededor de
5 bytes por carácter. Si desea mostrar todo el conjunto ASCII (128 caracteres, incluidos los espacios), necesita
128 x 5 bytes = 640 bytes.
Conecte la pantalla OLED suministrada al IoT Brick con el conector de 4 pines, como se muestra en el gráfico.
+9V
GPIO5 GPIO14
(SCL) (SCLK)
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
GPIO12
(MISO)
SDA SCL 5V TIERRA
Ladrillo IoT
ADDC (10:1)
GPIO3 18 bits
GPIO1 10 bits
micro USB
Fig. 36: Pantalla OLED en IoT Brick
Abra el boceto en el IDE de Arduino: Example_6.4.ino. Debe incluir los siguientes archivos de encabezado:
#include <SSD1306Wire.h> e #include "images.h". El archivo images.h debe estar en el directorio del proyecto
de este boceto. Si aún no ha instalado la biblioteca SSD1306Wire.h , vaya al cap. 5.2.1 en la página 16 y
compensarlo.
Para simplificar el control de la pantalla OLED, aquí usamos una biblioteca preparada. Si aún no los ha
instalado, vaya al Cap. 5 en la página 13 y haga esto ahora.
La biblioteca para controlar nuestra pantalla OLED se incluye con #include "SSD1306Wire.h" y con pantalla
SSD1306Wire (0x3c, 4, 5); inicializado es decir. para obtener la dirección correcta para la función display() ,
debe cambiar la dirección I2C del hardware de nuestra pantalla OLED (predeterminada: 0x78) un bit a la
derecha. El programador escribe para esto: (0x78>>1) el resultado es "0x3c". Los parámetros asignados a los
valores 4 y 5 especifican los GPIO para el bus I2C.
Para obtener una primera impresión, puede cargar este boceto en su IoT Brick. Muestra todo lo que es posible,
desde diferentes tamaños de fuente hasta gráficos y la barra de progreso que se ejecuta.
Echa un vistazo a este y los otros ejemplos. No se confunda, también hay mucho código en los ejemplos que es
irrelevante para nosotros. Verá que en el siguiente ejemplo OLED es básicamente muy fácil mostrar texto en la
pantalla.
Puede encontrar más ejemplos de la pantalla OLED en el IDE de Arduino en:
"Archivo – Ejemplos – Controlador Oled ESP8266 para pantalla SSD1306 – …"
Para que estos ejemplos de código funcionen correctamente con IoT Brick, debe verificar las siguientes líneas de
código:
• La asignación de los pines I2C para el OLED debe ser: SSD1306Wire display(0x3c, 4, 5);
o: pantalla SSD1306 (0x3c, 4, 5); dependiendo de la instrucción #include al comienzo del boceto.
• Comente la línea con el comando display.fl ipScreenVerticalmente(); – Deben colocarse dos
barras diagonales // al frente, de lo contrario, la pantalla está al revés.
6.4.1 Pantalla OLED texto de pantalla
Abra el boceto en el IDE de Arduino: Example_6.4.1.ino. Debe incluir el siguiente archivo de encabezado:
SSD1306Wire.h. Si aún no ha instalado la biblioteca adecuada, vaya al cap. 5.2.1 en la página 16 y compensarlo.
En este ejemplo simple, queremos generar un texto en la pantalla OLED utilizando la biblioteca OLED
SSD1306Wire.h .
Puede configurar los siguientes parámetros:
• Coordenadas
A partir de las coordenadas (x, y) definidas aquí, puede utilizar el comando...
display.drawString(x, y, "Texto de ejemplo"); determinar el punto de referencia del texto y su contenido.
• Alineación
A partir del punto de referencia previamente definido, puede utilizar el comando...
display.setTextAlignment(TEXT_ALIGN_x); determine si el texto debe estar alineado a la izquierda
(TEXT_ALIGN_LEFT), centrado (TEXT_ALIGN_CENTER) o a la derecha (TEXT_ALIGN_RIGHT).
• Tamaño
del texto Los tres tamaños de fuente estándar compatibles de forma nativa con esta biblioteca son 10, 16 y
24 píxeles. Simplemente establece el tamaño con el comando display.setFont(ArialMT_Plain_X); Celebracion.
Piense en la pantalla como un sistema de coordenadas con el origen 0,0 en la parte superior izquierda.
0 63 127x
20
40
y
Fig. 37: El sistema de coordenadas de la matriz OLED
bucle vacío () {
mostrar.claro(); // Limpiar el contenido de la pantalla
display.setTextAlignment(TEXT display.setFont(ArialMT _ ALINEAR _ IZQUIERDA); // Alinear texto a la izquierda

16); display.drawString(0, 0, "BRICK"); _ Llanura _ // Tamaño de fuente 16 píxeles
// posición 0,0 texto: "LADRILLO"
display.setTextAlignment(TEXT display.setFont(ArialMT _ ALINEAR _ CENTRO); // Alinear el texto centrado

16); display.drawString(63, 20, "OLED"); _ Llanura _ // Tamaño de fuente 16 píxeles
// posición 63.20 texto: "OLED"
display.setTextAlignment(TEXT display.setFont(ArialMT _ ALINEAR _ DERECHO); // Alinear texto a la derecha

display.drawString(127, 40, "TEST"); _ Llanura _ dieciséis); // Tamaño de fuente 16 píxeles
// posición 127.40 texto: "PRUEBA"
pantalla.pantalla(); // Salida para mostrar
retraso (1000);
}
Si desea utilizar un tamaño diferente o incluso una fuente, el creador de la biblioteca OLED ofrece un editor de fuentes en línea en : http://oleddisplay.squix.ch/#/home .
Después de haber especificado el texto con posición, alineación, tamaño y contenido, puede mostrarlo con el comando display.display(); pantalla en el OLED.
¡Y ahora diviértete! Escriba diferentes textos, en diferentes tamaños, en las posiciones deseadas.
6.5 Entradas analógicas
6.5.1 Conversión A/D: conceptos básicos
La conversión A/D significa conversión de analógico a digital. El objetivo es medir valores analógicos, como un voltaje
desconocido, y convertirlos en un valor digital. La computadora puede entonces procesar más este valor. Una computadora
normal no puede hacer nada con valores analógicos.
Se llevan a cabo dos pasos importantes, una cuantificación de la amplitud z. B. el voltaje y una cuantificación del tiempo en un
perfil variable en el tiempo del valor analógico.
¿Que quieres decir con eso?
La cuantización en amplitud es fácil de entender. Supongamos que un voltaje analógico puede tener cualquier valor entre 0 y
5V. Así que 2,3 V o 2,31 V o 2,315 V... etc. Entonces surge la pregunta, ¿qué tan preciso quiero medir y qué tan bien, es decir,
en cuántos pasos quiero resolver mi señal? Finalmente, los valores numéricos tienen que estar preparados para su
procesamiento en un sistema de computación digital.
Ejemplo:
Queremos representar digitalmente un rango de voltaje de 0 a 5 V en 6 pasos. ¿Qué valor digital se dará entonces para 2,1 V?
En el siguiente diagrama, puede leer la tarea desde los puntos rojos.
El valor 2.1 está más cerca de 2 que de 3, por lo que se elegirá el valor digital 2. Con un valor de 2,5, puede asignar 3 como
valor digital si redondea comercialmente el número 2,5.
tensión 6
0
12345678 9 veces
Fig. 38: Muestreo de señales analógicas
En la figura de arriba hemos registrado el curso de una señal de voltaje en el tiempo (en el eje x vemos el tiempo en segundos
y en el eje y el voltaje en voltios).
Al convertir la señal en una secuencia digital de números, se solicitará una lectura (líneas verticales) una vez por segundo y
luego se redondeará a un dígito. Esto da como resultado la siguiente serie de mediciones:
hora 0s 1s 2 segundos 3 segundos 4s 5 segundos 6s 7s 8s 9s

Voltaje 2V 2v 3v 5v 4v 4v 1v 1v 2v 4v
Hay dos efectos interesantes: 1. Perdemos información
en la amplitud, ya que se supone que la unidad de voltaje detectable más pequeña es 1 V en nuestro ejemplo. Este efecto también se denomina error
de cuantificación, que en nuestro caso puede suponer una desviación de hasta 0,5 V del valor real en sentido positivo o negativo. Con una mayor
resolución de la conversión, también obtendríamos más información sobre la señal original.
2. También perdemos información relacionada con el tiempo. Vemos una caída de tensión de hasta 1 V en el rango de 1 a 2 segundos, que no es
visible en la serie de medidas. Los expertos en la materia notarán ahora que se ha violado el llamado teorema de muestreo de Nyquist
Shannon. Esto establece que la tasa de muestreo para una señal periódica debe ser al menos dos veces más alta que su componente de
frecuencia máxima (también llamado sobremuestreo). Este criterio se viola en el caso de sobreimpulsos y subimpulsos más cortos.
Si ahora conecta los puntos rojos, obtiene la señal "visible" para la computadora, que se muestreó en una cuadrícula de tiempo de 1 segundo. La curva
original ya no se puede reconstruir con precisión. Sin embargo, cuanto más se aumenta el número de puntos de muestreo, mejor se puede reconstruir la
señal (ver teorema de muestreo).
tensión 6
0
12345678 9 veces
Fig. 39: Reconstrucción de la señal muestreada
La resolución de la amplitud está determinada por el número de pasos discretos que se asignan a un valor numérico. En nuestro ejemplo diferenciamos
entre 6 niveles de tensión. A modo de comparación: un convertidor A/D de 10 bits ya proporciona 1024 niveles, que normalmente están codificados en
binario (consulte también el capítulo 6.5.2.5 en la página 38). En el IoT Brick tenemos la opción entre un convertidor A/D de 10 bits y uno de 18 bits (por
cierto llamado "convertidor digital analógico", abreviado: ADC).
Conversión A/D de 10 bits y 18 bits en comparación
Convertidor A/D de 10 Convertidor A/D de 18
Número de etapas (resolución) bits 210 = 1024 bits 218 = 262144
Rango de medición y valor digital 0… 9.99V 0… 0… 19.999924V 0…

correspondiente (decimal) 1023(10) 262143(10)
El nivel de tensión más pequeño (los llamados
10V / 1024 = 0,0098V (= 9,8mV) 20V / 262144 = 0,000076V (= 76μV)
"Bit menos significativo" (LSB))
error de cuantización ±4.9mV ±38μV
frecuencia de muestreo máx. 200 muestras/segundo (= 200 S/s) 3,75 muestras/segundo (= 3,75 S/s)
tipo de convertidor convertidor SAR Convertidor Delta Sigma (Convertidor ∆∑)
Existen diferentes métodos de conversión para convertir señales analógicas en valores digitales codificados en binario que irían más allá
del alcance de este manual. Como palabras clave para su propia investigación, nos gustaría mencionar aquí solo los métodos más
importantes:
• Convertidor integrador (método de conteo)
Más lento que los métodos de pesaje, insensible a las interferencias, bajos requisitos de hardware, implementación: única,
Convertidor de pendiente doble y cuádruple, ejemplo de aplicación: multímetro
• Convertidor de retroalimentación (método de pesaje)
Buen compromiso entre velocidad y complejidad del hardware, implementación: convertidor deltasigma
(convertidor ∆∑), ejemplo de aplicación: convertidor A/D de 1 bit en tecnología de audio convertidor SAR (registro de
aproximación sucesiva), ejemplo de aplicación: tecnología de medición con muy alta resolución.
• Convertidores paralelos (convertidores flash y de canalización)
Realización muy rápida, muy costosa: convertidor flash y pipeline, ejemplo de aplicación: tecnología de radar.
6.5.2 Los convertidores A/D en el IoT Brick
6.5.2.1 El convertidor A/D de 10 bits
El ESP8266 ofrece un convertidor A/D integrado (A/D = analógico a digital) con una resolución de 10 bits, lo que corresponde a una
resolución del valor de voltaje de 210 = 1024 pasos. El rango de voltaje de entrada del convertidor en sí es de 0 V a 1 V. Para hacerlo más
práctico, se conectó un divisor de voltaje de 10 a 1 (10: 1) a la entrada del bloque "ADC 10 bit" para para conseguir una tensión de 0 V para
poder medir 10 V directamente. Puede usar esto para construir un voltímetro simple que puede usar para medir voltajes de CC de 0V a 10V.
6.5.2.2 El convertidor A/D de 18 bits
Para otros experimentos, también se instaló un convertidor A/D MCP3421 muy preciso en el IoT Brick, que tiene una resolución muy alta de
18 bits (218 = 262 144 pasos). Este dispositivo convertidor está conectado a través del bus I2C y ofrece un rango de voltaje de entrada de 0
V a 2 V con un convertidor de voltaje de 10 a 1 aguas arriba. Esto da como resultado un rango de voltaje de entrada práctico de 0 V a 20 V,
es decir, se puede aplicar un voltaje de entrada de 20 V como máximo a la entrada del bloque "ADC 18 bit".
6.5.2.3 El divisor de tensión
Un divisor de voltaje con una relación de división de 10 a 1 está integrado en el IoT Brick en ambas entradas del convertidor de voltaje "ADC
10 bit" y "ADC 18 bit":
Ladrillo IoT
R1
Asegúrese de que nunca haya más de 10 metros
10 V en la entrada "ADC 10 bit" y nunca
más de 20 V en la entrada "ADC 18 bit". Umeas
¡De lo contrario, el convertidor A/D R2 UADC
puede dañarse! 1,1 millones
Fig. 40: Divisor de tensión (10 1)
La relación divisoria se calcula de la siguiente manera:
6.5.2.4 Consejo práctico: factor de corrección
Tenga en cuenta que puede haber imprecisiones en el resultado de la medición debido a las tolerancias de los preescaladores de
resistencia internos en las entradas "ADC 10 bit" y "ADC 18 bit". Esta desviación se puede ajustar mediante un factor de corrección.
Para determinar el factor de corrección, puede utilizar, p. B. use un multímetro preciso y verifique el voltaje Umeas . ¡Luego, calcula
el factor de corrección a partir de la relación entre el voltaje medido con el multímetro y el voltaje que se muestra en el IoT Brick sin
corrección! En el programa de muestra, hemos preparado el código apropiado que puede usar si es necesario (elimine las dos barras
(comentario) solo después de haber realizado la medición sin corrección). En aras de la claridad, el factor de corrección se define
como una constante al comienzo del programa (consulte el siguiente extracto del programa para el convertidor A/D de 10 bits).
Factor de corrección = Umeas, multímetro / Ladrillo UDisplay
Extracto del programa para el factor de corrección (ver Ejemplo_6.5.3.ino)
//El procedimiento se aplica por igual a ADC de 10 y 18 bits
...
//defina el factor de corrección para ADC de 10 bits aquí corrección de
flotación constante _ 10 bits = 1046;
...
// Calcular el factor de corrección (determinado con la medición del multímetro) 10 bits;
Umeas _ 10 bits = UMed _ 10 bits * Corrección _
...
Dado que cada resistencia tiene diferentes tolerancias de fabricación, el factor de corrección para los dos
convertidores A/D también debe determinarse por separado.
6.5.2.5 Codificación binaria
Un convertidor A/D convierte un valor medido analógico en la entrada en un valor codificado en binario en la salida.
También se habla de una palabra binaria cuyo ancho, es decir, el número de caracteres binarios individuales, se
da en bits (la unidad, dicho sea de paso, se escribe en minúsculas: 1 bit). En nuestro caso, dependiendo de la
resolución del convertidor A/D, estamos tratando con una palabra binaria de 10 o 18 bits. El bit menos significativo
a menudo se denomina "bit menos significativo" (LSB) y el bit más significativo como "bit más significativo" (MSB).
Parte más significante Bit menos significativo
(Bit más significativo (MSB)) (bit menos significativo (LSB))
número Número palabra binaria número binario

número decimal número hexadecimal
de bits de estados codificables (Número de estados codificables 1)
217... valor... 20
(0) 1 = 20 00 0000 0000 0000 0000 0 0
1 bit 2 = 21 00 0000 0000 0000 0001 1 1
2 bits 4 = 22 00 0000 0000 0000 0011 3 3
3 bits 8 = 23 00 0000 0000 0000 0111 7 7
4 bits 16 = 24 00 0000 0000 0000 1111 15 F
……
8 bits 256 = 28 00 0000 0000 1111 1111 255 FF
10 bits 1024 = 210 00 0000 0011 1111 1111 1023 3FF
12 bits 4096 = 212 00 0000 1111 1111 1111 4095 FFF
14 bits 16 384 = 214 00 0011 1111 1111 1111 16,383 3FFF
16 bits 65 536 = 216 00 1111 1111 1111 1111 65,535 FFFF
18 bits 262 144 = 218 11 1111 1111 1111 1111 262,143 3FFFF
6.5.3 Convertidor A/D de 10 bits
Abra el boceto en el IDE de Arduino: Example_6.5.3.ino. Debe incluir los siguientes archivos de encabezado:
SSD1306Wire.h. Si aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
En este ejemplo, medimos un voltaje a través de una resistencia variable (potenciómetro, a menudo llamado simplemente poti). El
valor de resistencia del potenciómetro varía entre 0 Ω y 10 kΩ dependiendo de la posición. El voltaje que cae a través del
potenciómetro se comporta linealmente con el valor de la resistencia. Cuando el potenciómetro está completamente en el sentido de
las agujas del reloj, el valor de resistencia es de aproximadamente 10 kΩ entre tierra y el contacto deslizante, que está conectado a
la entrada analógica (ADC de 10 bits) del IoT Brick. Entonces, ahora está presente el voltaje de suministro completo, que debería ser
de alrededor de 9 V. Si ahora giramos el potenciómetro en sentido antihorario hasta el tope, entonces hay 0 V (tierra) en la entrada
del convertidor A/D. Cuando el potenciómetro está en la posición media, está presente aproximadamente la mitad de la tensión de
alimentación, es decir, aproximadamente 4,5 V.
+

1A 9V
+9V
ADC
GPIO5
(SCL)
de 10 bGPIO14
its: (SCLK)
0.00V
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
GPIO12
(MISO)
Umeas
Ladrillo IoT
ADDC (10:1)
GPIO3 18 bits
GPIO1 10 bits
micro USB
Fig. 41: Convertidor A/D de 10 bits del circuito Brick
El voltaje medido Umeas se emite en la pantalla OLED y se actualiza cada segundo.
Además, el valor bruto digital y el valor de voltaje calculado a partir de él se muestran en el monitor serie de su computadora.
Para abrir el monitor serie, simplemente haga clic en el icono de la lupa en la parte superior derecha del IDE de Arduino
(consulte el Capítulo 5.2.3 en la página 20).
Puede usar la siguiente fórmula para convertir el valor digital del convertidor A/D en el valor de voltaje analógico (vea
también el programa de ejemplo Example_6.5.3.ino).
Umeas = (entrada analógica / 1024) * 10 V
Sustituir 1023 por analogIN le da el valor máximo del rango de voltaje de entrada. En nuestro caso, esto es 9.99 V.
Extracto del programa véase la página siguiente.
bucle vacío (vacío) {
// Lee el voltaje como valor bruto: 0 = 0V a 1023 = 1V1LSB analogIN = analogRead(adc
_ esp8266);
// Convierte a voltios con analogIN/resolución (*1 voltio), *10 debido al divisor 10:1 en el ADC
UMeas = ((float)analogIN/1024)*10.0; // convierte el
valor de voltaje en cadena para salida OLED str = String(UMess, 2); // 2 decimales
Cadena UMeas _
mostrar.claro(); //Eliminar OLED
display.setTextAlignment(TEXT _ ALINEAR _ IZQUIERDA);
_ Llanura
display.setFont(ArialMT display.drawString(0, 0, _ 24);
"ADC 10 bit:"); display.setTextAlignment(TEXT RIGHT);
_ ALINEAR
display.setFont(ArialMT 24); display.drawString(120,
32, Umeas
_
_ Llanura _
_ calle + "V");
pantalla.pantalla(); retraso // Salida a OLED
(1000);
}
Con el comando analogIN = analogRead(adc_esp8266); leemos el valor digital bruto del convertidor A/D interno del ESP8266. El rango de
valores del convertidor de 10 bits es de 0 a 1023 (decimal).
En nuestro ejemplo, el valor 0 corresponde al voltaje 0 V y el valor bruto 1023 al valor máximo del rango de voltaje de entrada.
Por razones sintácticas, primero tenemos que convertir la variable entera analogIN, que devuelve el valor bruto del convertidor A/D, en la
variable flotante UMess para convertirla en el valor de voltaje correcto. Al final, necesitamos la variable de cadena UMess_str para la salida.
6.5.4 Convertidor A/D de 18 bits
SSD1306Wire.h y MCP3421.h. Si aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y
compensarlo.
En este ejemplo, queremos controlar el convertidor A/D de 18 bits MCP3421 de Microchip, que es mucho más preciso. B. se
puede utilizar para la medición precisa de la temperatura con termopares o sensores de temperatura de resistencia (RTD) y
comparar los valores medidos del convertidor interno de 10 bits con los del convertidor de 18 bits controlado a través del bus
I2C.
El circuito de ladrillos para este ejercicio difiere del ejercicio anterior solo en el ladrillo en el centro inferior. El mismo voltaje
Umeas ahora está presente en ambas entradas analógicas , que se puede variar a través del potenciómetro. Esto facilita la
comparación directa de los dos convertidores A/D. La resolución del convertidor A/D de 18 bits, que es 256 veces mejor que la
del convertidor A/D de 10 bits, se puede ver claramente en el resultado de la medición.
+

1A 9V
+9V
18 bits: 0,0000
GPIO5 V
GPIO14
(SCL) (SCLK)
10 bits:
GPIO4
(SDA)
0.00V
GPIO13
(MOSI)
Carolina del Norte
GPIO12
(MISO)
Umeas
Ladrillo IoT
ADDC (10:1)
GPIO3 18 bits
GPIO1 10 bit
máx
10V
micro USB
Fig. 42: Convertidor A/D de 18 bits del circuito Brick
Desde el principio, esperaríamos valores de voltaje idénticos para este circuito. Pero aquí también se aplica el dicho "el que
mide, mide mierda". Como ya se mencionó en el capítulo anterior, entre otros
las tolerancias de los componentes juegan un papel. El efecto principal es la tolerancia estándar de las resistencias del 10 %
de los dos divisores de tensión de 10 a 1 en las entradas del convertidor A/D (consulte el capítulo "6.5.2.3 El divisor de tensión"
en la página 37).
Extracto del programa véase la página siguiente.
configuración vacía (vacío)
{
...
// Init MCP3421: dirección I2C, modo de 18 bits, sin ganancia MCP.init(0x68,3,0);
...
} bucle vacío (vacío) {
...
// Lee el voltaje como valores dobles de MCP3421, rango de entrada: 0 a 2.048V 18bit=MCP.getDouble(); 18 bits = entrada
entrada analógica _ analógica
Umeas _ _ 18 bits * 10,0; // *10 debido al divisor 10:1
// ¡Comente la siguiente línea para determinar el factor de corrección usando // una medición de multímetro!
18bit*Corrección
Umeas _ 18 bits = UMed _ _ 18 bits; // factor de corrección
// convierte el valor de voltaje en cadena para salida OLED de 18 bits, 4);
Cadena UMeas _ 18 bits _ str = String(UMess _
...
pantalla.pantalla(); retraso // Salida de ambos valores de voltaje en OLED
(1000);
}
Usamos la biblioteca MCP3421.h para simplificar la programación del MCP3421.
El convertidor A/D se inicia inicialmente con MCP.init(0x68,3,0); inicializado Con la función MCP.get Double() , el valor del voltaje ya se
devuelve como un valor doble, es decir, como un número de coma flotante.
Dado que el MCP3421 cubre un rango de voltaje de entrada de 0 a 2,048 V, el valor aún debe multiplicarse por un factor de 10. A continuación
realizamos – como en el Cap. 6.5.2.4 en la página 38: un factor de corrección que se define como una constante por el flotante al comienzo
del boceto . Para la salida en una pantalla OLED o un monitor en serie, tenemos que convertir los números de coma flotante UMess_10bit y
UMess_18bit en las cadenas correspondientes. Los valores se actualizan aproximadamente cada segundo.
6.6 Ejemplos de IoT
Controle su IoT Brick a través de su teléfono inteligente o cualquier otro dispositivo habilitado para WLAN y
descubra las posibilidades. Programa un pequeño sitio web y crea tu propio centro de control.
Usted aprende…
… cómo sincronizar hora y fecha con internet (ver ejemplo 6.6.2)
… cómo leer la temperatura y la humedad de un sensor (ver ejemplo 6.6.3)
...cómo consultar el tipo de cambio actual del dólar desde Internet (ver ejemplo 6.6.4)
En el siguiente paso (ejemplo 6.6.5) programará un pequeño sitio web como base para su propio centro de
medición de IP. Por cierto, puede conectar fácilmente numerosos sensores utilizando el bloque adaptador de
sensor universal (ALLBRICK0649). Como gran final, aprenderá en el Ejemplo 6.6.6 cómo puede encender y
apagar los LED a través de Internet. Esta es una funcionalidad básica como B. se requiere en numerosas
aplicaciones de automatización de edificios.
La sencilla integración en red del ladrillo IoT abre una multitud de nuevas posibilidades.
192.168.1.123 yo
dispositivos con
A
PAG
es decir Conectividad WiFi
mis
derecho
s
i mi
derecho
decir
es w
9V decir
es
y
norte
WiFi: Nombre 57dBm 1 GND1 5V 3
a
metro
IP CONECTADA: 2
192.168.1.123 GW: TIERRA 1 2 5V si
192.168.1.254 RED: C
255.255.255.0 H
5V TIERRA 1 2 3
9V p.ej
SDA SCL 5V TIERRA
y
GRAMO
mi
w
Ladrillo IoT mi
i
s
ADC (10:1)
mi
GPIO3 18 bits norte
(Rx) I2C, máx. 20
GPIO1 V 10 bits
punto de acceso
micro USB
sensores
Brick IoT con punto de acceso / enrutador
módulo WiFi integrado Internet
Fig. 43: El Brick IoT en la red
La gran ventaja del módulo ESP12F integrado en el IoT Brick en comparación con Arduinos es la capacidad
de red gracias al módulo WLAN integrado. El microcontrolador ESP8266 se puede integrar en una red WLAN
existente con solo unas pocas líneas de código. La dirección IP siempre se asigna de forma dinámica.
Este puede ser el enrutador de su red local o su teléfono inteligente como punto de acceso.
Todos los ejemplos de IoT requieren una conexión a Internet. Esto también se indica en los siguientes capítulos
con el símbolo WLAN. En los ejemplos 6.6.5 y 6.6.6 puede acceder al servidor web integrado en el IoT Brick a
través de su red. Teóricamente también a través de Internet, siempre que puedas configurar tu red para ello.
Las palabras clave aquí son reenvío de puertos y firewall. Los enrutadores disponibles comercialmente
generalmente ofrecen la opción de reenviar el acceso correspondiente desde Internet a un puerto interno detrás
del cual se oculta el IoT Brick con su dirección IP local (el llamado reenvío de puerto). El requisito básico es que
su cortafuegos permita dicho acceso "desde el exterior". Puede encontrar más información sobre la configuración
correspondiente de su enrutador en la documentación de su enrutador o en Internet.
6.6.1 Configurar el IoT Brick como un cliente WLAN
Abra el boceto en el IDE de Arduino: Example_6.6.1.ino. Debe incluir los siguientes archivos de encabezado: ESP8266WiFi.h y
SSD1306Wire.h. Si aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
Para poder comunicarse con su IoT Brick a través de WLAN, primero debe integrarlo en su red local. Para hacer esto, necesita el nombre WLAN
(también conocido como SSID) de su punto de acceso o enrutador y la contraseña asociada. Como no tenemos forma de ingresar caracteres en
el bloque, tenemos que almacenar los datos de acceso en nuestro boceto.
Busque las líneas con un fondo verde en el siguiente extracto del programa al comienzo del archivo de boceto. Reemplace my_wlan_name (se
mantienen las comillas) con el nombre (SSID) de su WLAN y en lugar de my_wlan_password ingrese la contraseña asociada.
//ingrese su propio nombre WLAN (SSID) aquí: const char* ssid = "mein
_ _ nombre"; //
acceso inalámbrico a Internet
ingrese su propia contraseña WiFi aquí: const char* contraseña
= "mi _ acceso inalámbrico a Internet
_ contraseña";
...
configuración vacía () {
...
}
En la función void loop() puedes ver cómo las siguientes cadenas se ensamblan y preparan para mostrarse línea por línea con el comando
display.drawString(x, y, "String") . Las funciones enumeradas a continuación se utilizan para determinar los valores de los parámetros individuales.
• funciones wlan_oled (nombre de WLAN e intensidad de campo), WiFi.SSID() y WiFi.RSSI(). • state (estado de la conexión), función WiFi.state
• ip_oled (dirección IP del IoT Brick), función WiFi.localIP()[x] • gw_oled (puerta de
enlace IP), función WiFi.gatewayIP()[x] • mask_oled (máscara de subred), función
WiFi.subnetMask()[ X]
La salida finalmente se realiza con el comando display.display(); Al mismo tiempo, la información
sobre la conexión de red también se emite en el monitor serie de su computadora. Para abrir el monitor serie, simplemente haga clic en el icono
de la lupa en la parte superior derecha del IDE de Arduino (consulte el Capítulo 5.2.3 en la página 20).
+

9V
1A
Nombre WLAN (SSID) e intensidad de campo (RSSI) en dBm
+9V
Estado de conexión
WLAN: Nombre 57 dBm
GPIO5 GPIO14 CONECTADO (SCL)
(SCLK)
IP: 192.168.1.123 GPIO4 GPIO13 Dirección IP local del IoT Brick (asignada a
(SDA) GW: 192.168.1.254 (MOSI)
NETO: 255.255.255.0 Carolina del Norte
través de DHCP)
GPIO12
(MISO)
Dirección IP de la puerta de enlace
máscara de subred
Ladrillo IoT
(Todos los valores mostrados en la figura son ejemplos)
ADDC (10:1)
GPIO3 18 bits
GPIO1 10 bit
máx
10V
micro USB
Fig. 44: Configuración del cliente WLAN del circuito de ladrillos
¡La configuración WLAN del IoT Brick también se puede mostrar en los
siguientes ejercicios presionando el botón GPIO0 (ver Fig. 44)!
6.6.2 Tiempo desde Internet
ESP8266WiFi.h, SSD1306Wire.h, TimeLib.h y NtpClientLib.h. Si aún no ha instalado las bibliotecas correspondientes,
vaya al cap. 5.2.1 en la página 16 y compensarlo.
Para este ejemplo, primero debe ingresar su nombre WLAN (SSID) y la contraseña asociada en el programa de ejemplo. Proceder como en el
cap. 6.6.1 descrito anteriormente.
Hay los llamados servidores de tiempo en Internet a los que se puede acceder a través de NTP (Protocolo de tiempo de red) para determinar la
hora y la fecha actuales. Cualquiera puede usar un conjunto de servidores de tiempo de forma gratuita a través del dominio pool.ntp.org . Para
simplificar el procesamiento de la información transferida desde el servidor de tiempo, en este ejercicio utilizamos funciones predefinidas en las
bibliotecas TimeLib.h y NtpClientLib.h. Usamos nuestra pantalla OLED nuevamente para la pantalla.
...
...
//Si WiFi está conectado, conéctese al servidor de hora NTP si (estado de conexión WLAN)
{ NTP.begin("pool.ntp.org",
_ 63 segundos 1_,
NtTP.setInterval(63); }
rue); //conectarse al servidor de tiempo NTP //actualizar la sincronización cada
NTP.onNTPSyncEvent([](NTPSyncEvent _ t evento) {
ntpEvento = evento;
syncEventTriggered = verdadero; }); //Conexión con el servidor horario establecida
...
}
bucle vacío () {
...
Cadena de tiempo = NTP.getTimeStr(); //Lee la hora como una cadena en la variable time String date = NTP.getDateStr(); //lee la
fecha como una cadena en la visualización de fecha variable.clear(); display.setTextAlignment(TEXT display.setFont(ArialMT 24);
display.drawString(15, 5, time); //Preparar para generar la hora display.drawString(5, 35, date); //Preparar para generar la fecha / /
Pantalla de actualización OLED.display(); _ ALINEAR _ IZQUIERDA);
_ Llanura _
...
}
Tan pronto como se establezca la conexión WLAN, la función NTP.begin("pool.ntp.org", 1, true); se establece la conexión con el servidor NTP.
Esto puede tardar unos pocos segundos. El primer parámetro pasa la URL al grupo de servidores de tiempo, el segundo parámetro la desviación
de nuestra zona horaria con respecto al "Universal Time Coordinated" (UTC) de +1 hora y el valor verdadero en el tercer parámetro indica que
en nuestra zona horaria entre verano e invierno se cambia el horario. NTP.set Interval(63) se utiliza para definir el intervalo en segundos en el
que se actualizará la sincronización con el servidor NTP, y syncEvent Triggered = true informa de una sincronización correcta con el servidor
NTP.
En void loop() , la hora se lee como una cadena con la función NTP.getTimeStr() y la fecha se lee con NTP.get DateStr() y se
prepara para la salida. La salida real a la pantalla OLED se realiza con el comando display.display();. La línea display.clear();
también es importante en este ejemplo . para que la pantalla se elimine en cada ejecución del bucle y no solo se sobrescriba.
Paralelamente a la visualización en la pantalla OLED, la salida también se muestra en el monitor en serie de su computadora.
Para abrir el monitor serie, simplemente haga clic en el icono de la lupa en la parte superior derecha del IDE de Arduino
(consulte el Capítulo 5.2.3 en la página 20). Además de la hora y la fecha, se muestra información adicional, como el horario de
verano e invierno, así como el tiempo transcurrido desde la primera sincronización (uptime) y la hora de la primera sincronización.
+

9V
1A
+9V
23:55:00
GPIO5
(SCL)
GPIO14
(SCLK)
31/12/2016
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
GPIO12
(MISO)
Ladrillo IoT
WiFi: Nombre 57dBm ADC (10:1)
IP CONECTADA: GPIO3 I2C de
192.168.1.123 GW: (Rx) 18 bits , 20 V máx.
GPIO1 10 bits
192.168.1.254 RED: (TX) REINICIO GPIO0 interno, máximo 10V
255.255.255.0
micro USB
Fig. 45: Circuito Brick Tiempo desde Internet
SUGERENCIA: ¡El estado de conexión del IoT Brick se puede mostrar en cualquier momento presionando el botón GPIO0
(consulte también la Fig. 44)!
6.6.3 Medir la temperatura y la humedad
Abra el boceto en el IDE de Arduino: Example_6.6.3.ino. Debe incluir los siguientes archivos de
encabezado: ESP8266WiFi.h, SSD1306Wire.h, TimeLib.h, NtpClientLib.h y DHT.h.
Si aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
Para este ejemplo, primero debe ingresar su nombre WLAN (SSID) y la contraseña asociada en el programa de ejemplo. Proceder como
en el cap. 6.6.1 descrito anteriormente.
Para medir la temperatura y la humedad, utilizamos el sensor combinado DHT11 ampliamente difundido, para el cual ya existe una
biblioteca (DHT.h) y ejemplos. Además, hay B. del mundo Arduino muchos sensores diferentes como:
• Sensores de temperatura • Sensor de gases
• Barrera de luz infrarroja • Sensor de pasillo
• Detector de movimiento (sensor IR) • • Sensor de choque
Sensor de luz (LDR) • Botón táctil
Puede conectar fácilmente numerosos sensores disponibles comercialmente utilizando el bloque adaptador de sensor universal (ALL
BRICK0649). Ya existen ejemplos y bibliotecas para muchos sensores, por lo que estos también pueden integrarse fácilmente en sus
propios proyectos en el lado del software.
Primero junte los ladrillos como se muestra en la Fig. 46. Asegúrese de conectar correctamente el sensor DHT11 suministrado.
Enchufe el sensor en la tira de enchufe inferior de 5 clavijas del bloque adaptador del sensor en el extremo izquierdo, exactamente
como se muestra en la Fig. 46. La etiqueta "5V" del sensor debe tocar el enchufe con la etiqueta "5V" en el extremo izquierdo.
De lo contrario, existe el riesgo de que el sensor y/o el IoT Brick sufran daños irreversibles.
+

9V
1A
+5V TIERRA E/
S
ALLNET
B24_1
GPIO14 5V TIERRA 1 2 3
+9V 9V
Adaptador sensor externo triple ch
18:00:00
GPIO5 GPIO14
1 GND1 5V
3 3
24/12/2016
(SCL)
GPIO4
(SCLK)
GPIO13
2
22.00°C
TIERRA1 TIERRA1 25V 25V
(SDA) (MOSI)
19% Carolina del Norte
5V TIERRA 1 2 3
GPIO12
(MISO)
9V
Los datos del sensor digital se enrutan a
Ladrillo IoT través del pin de datos 1 del bloque
adaptador del sensor a GPIO14 del bloque IoT.
(Rx)
192.168.1.123 GW: 18 bits , 20 V máx.
GPIO1 10 bits
255.255.255.0
micro USB
Fig. 46: Circuito Brick Medir temperatura y humedad
#define DHT _ TIPO DHT11 // Definir tipo de sensor: DHT11

const int DHT _ PIN=14; //Línea de datos del sensor a GPIO14 del IoT Brick
gráfico[20]; //Definir variable de cadena para temperatura
charhumí[20]; //Definir una variable de cadena para la humedad
DHT DHT(DHT _ CLAVIJA, DHT _ ESCRIBE); //Definir variable de tipo DHT
...
...
dht.begin(); //Inicializar sensor
}
bucle vacío () {
...
si (contador% 1000 == 0){ //sondear el sensor aproximadamente una vez por segundo float t =
dht.readTemperature(); //Lea la temperatura (Celsius) f oat h = dht.readHumidity(); //Leer humedad
sprintDouble(temp,t,2); // temperatura convertir a cadena con 2 decimales sprintDouble(humi,h,0); //Convertir humedad a cadena
sin decimales strcat(temp," °C"); strcat(humi," %");
//Agregar °C a la cadena
//Añadir % caracteres a la cadena
} pantalla.drawString(5, 30, temp); //Preparar salida de visualización de temperatura.drawString(5, 45, humi); //Preparar
salida de humedad display.display();
//Actualizar OLED
...
}
Al comienzo del boceto, se define el tipo de sensor DHT11 y a qué pin GPIO (aquí GPIO14) se conecta la línea de datos de nuestro sensor con
interfaz digital. Siguen varias declaraciones de variables. Una variable especial es la del tipo DHT. con la ayuda de la cual el sensor se inicializa
en void setup() .
Pero ahora a la medida real en la sección void loop(). Con las dos llamadas de función de la biblioteca de sensores dht.readTemperature() y
dht.readHumidity() , la temperatura o la humedad se leen del sensor y se almacenan en las dos variables de punto flotante t o h . Con la función
auxiliar sprintDouble() , los números de punto flotante se convierten en cadenas con el número deseado de lugares decimales y luego se agrega
la unidad respectiva con la operación de cadena strcat() .
Además de los valores de temperatura y humedad, la pantalla también incluye la hora y la fecha, como ya se mostró en el ejercicio 6.6.2. La
salida real de todos los valores en la pantalla OLED se realiza como de costumbre con el comando display.display();.
Al mismo tiempo, la salida también se muestra en el monitor serial de su computadora. Para abrir el monitor serie, simplemente haga clic en el
icono de la lupa en la parte superior derecha del IDE de Arduino (consulte el Capítulo 5.2.3 en la página 20). En este ejemplo, la temperatura y la
humedad se han agregado a la salida del ejemplo 6.6.2.
Al adaptar la ranura y el croquis en consecuencia, se pueden conectar numerosos sensores disponibles en el mercado con el "Bloque
adaptador de sensor triple".
LED verde: 5V correcto. ¡El ladrillo genera un voltaje estabilizado
de 5 V para alimentar los sensores, por lo que es necesaria una
conexión al suministro de 9 V!
9V
Regleta de enchufes de 3 pines con un pin de datos
1 GND1 5V 3
Regleta de enchufes de 4 pines con dos pines de datos
2
TIERRA 1 2 5V
Regleta de enchufes de 5 pines para sensores con hasta tres pines de datos.
5V TIERRA 1 2 3
9V
Fig. 47: Opciones de conexión para el bloque adaptador de sensor triple
Asegúrese de conectar sus sensores correctamente al adaptador de sensor. Consulte la documentación del sensor en cuestión
si no está seguro. De lo contrario, existe el riesgo de que el sensor y/o el IoT Brick sufran daños irreversibles.
6.6.4 Tasa de dólar desde Internet
Abra el boceto en el IDE de Arduino: Example_6.6.4.ino. Debe incluir los siguientes archivos
de encabezado: ESP8266WiFi.h, SSD1306Wire.h, TimeLib.h, NtpClientLib.h y CurrencylayerClient.h.
Si aún no ha instalado las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y
compensarlo.
Para este ejemplo, primero debe ingresar su nombre WLAN (SSID) y la contraseña asociada en el programa de ejemplo. Proceder como en
el cap. 6.6.1 descrito anteriormente.
Para consultar el tipo de cambio del dólar (EURUSD) desde Internet, necesita una biblioteca especial "Brick ESP8266", que puede descargar
desde http://www.brickrknowledge.de/downloads . Si en el cap. 5.2.1 ya he instalado todas las bibliotecas, puede continuar de inmediato. De
lo contrario, primero debe instalar la biblioteca como se describe en el Cap. 5.2.1.2.3 en la página 19.
#include <CurrencylayerClient.h>
...
si (contador% 5000 == 0) { //Actualizar el tipo de cambio cada 5 segundos currencylayer.getLastChannelItem();
contadores = 0; }
display.setTextAlignment(TEXT _ ALINEAR _ IZQUIERDA);
_ Llanura _ dieciséis);
display.setFont(ArialMT display.drawString(0,
45, currencylayer.getFieldValue(0)); display.setTextAlignment(TEXT RIGHT);
_ ALINEAR _
display.drawString(127, 45, " EUR/USD"); display .mostrar();
...
En este ejemplo obtenemos el tipo de cambio actual del dólar de Internet para calcular cuántos euros tengo que pagar por un dólar (o
viceversa).
EUR = USD * factor de conversión
Para obtener la tasa de conversión, primero llamamos a la función currencylayer.get LastChannelItem() . El tipo de cambio
actual del dólar se recupera de un servidor predefinido mediante los llamados comandos JSON. Podemos determinar el
intervalo de tiempo para la actualización usando el contador en la instrucción if if(counter%5000==0) . La pantalla tiene el
formato habitual, pero la llamada a currencylayer.getFieldValue(0) sigue siendo importante. Solo en este punto, el tipo de
cambio del dólar está redondeado a 4 decimales y está disponible como una cadena en el esquema.
Además del tipo de cambio actual, la pantalla se complementa con la hora y la fecha, como ya se mostró en el ejercicio 6.6.2.
La salida real de todos los valores en la pantalla OLED se realiza como de costumbre con el comando display.display();.
Al mismo tiempo, la salida también se muestra en el monitor serial de su computadora. Para abrir el monitor serie, simplemente
haga clic en el icono de la lupa en la parte superior derecha del IDE de Arduino (consulte el Capítulo 5.2.3 en la página 20). Se
han agregado algunos mensajes de estado a la salida del ejemplo 6.6.2.
+

9V
1A
+9V
GPIO5 23:59:59 GPIO14

(SCL)
GPIO4
31/12/2016GPIO13
(SCLK)
(SDA) (MOSI)
1,0523 euros/dólar Carolina del Norte
GPIO12
(MISO)
Ladrillo IoT
192.168.1.123 GW: (Rx) 18 bits , 20 V máx.
GPIO1 10 bits
255.255.255.0
micro USB
Fig. 48: Tasa de cambio del dólar del circuito Brick desde Internet
6.6.5 Mi primer sitio web
ESP8266WiFi.h, SSD1306Wire.h, TimeLib.h, NtpClientLib.h, ESP8266WebServer.h y DHT.h. Si aún no ha instalado
las bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
Para este ejemplo, primero debe ingresar su nombre WLAN (SSID) y la contraseña asociada en el programa de ejemplo.
Proceder como en el cap. 6.6.1 descrito anteriormente.
En este ejemplo, construiremos un sitio web simple que nos mostrará la hora, la fecha, la temperatura y la humedad. La
base de todo sitio web es el lenguaje de marcado de hipertexto (en inglés, hypertext markup language), abreviado: HTML.
Puede escribir el código HTML para su primer sitio web utilizando un editor HTML WYSIWYG. Puede utilizar varios
editores de HTML gratuitos, como B. Utilice NVU para Windows, Linux y MAC OS X (consulte: www.nvu.com) o BlueGriffon
(consulte: www.bluegriffon.org) .
El conocimiento básico de HTML es beneficioso para este ejercicio. Puede encontrar conceptos básicos completos de
HTML como parte del proyecto web SELFHTML en www.selfhtml.org.
El circuito de ladrillos y el esquema de este ejercicio se basan en el ejemplo 6.6.3. ¡El estado de conexión del IoT Brick
se puede mostrar en cualquier momento presionando el botón GPIO0 (ver también Fig. 44)!
Primero, junte los ladrillos como se muestra en la Fig. 49, de lo contrario, el boceto no se cargará correctamente.
Asegúrese de garantizar la conexión correcta del sensor DHT11 suministrado.
Enchufe el sensor en la tira de enchufe inferior de 5 clavijas del bloque adaptador del sensor en el extremo
izquierdo, exactamente como se muestra en la Fig. 49. La etiqueta "5V" del sensor debe tocar el enchufe con la
etiqueta "5V" en el extremo izquierdo. De lo contrario, existe el riesgo de que el sensor y/o el IoT Brick sufran
daños irreversibles.

+
9V
1A
+5V TIERRA E/
S
ALLNET
B24_1
5V TIERRA 1 2 3
+9V canal
Adaptador de sensor
9V externo triple
14:00:00
GPIO5 GPIO14
1 GND1 5V 3 3
14/02/2017
(SCL)
GPIO4
(SCLK)
GPIO13
2
24,00°C
(SDA) (MOSI)
TIERRA 1 2 5V ND 1 2 5V
17% Carolina del Norte
5V TIERRA 1 2 3
GPIO12
(MISO)
9V
Ladrillo IoT
ADDC (10:1)
GPIO3 18 bits
GPIO1 10 bits
micro USB
Fig. 49: Circuito de ladrillos "Mi primer sitio web"
...
servidor ESP8266WebServer(80); //Iniciar servidor web en el puerto 80
...
...
//Una vez que un navegador accede directamente al directorio raíz, //ejecuta la función handleRoot
(ver más abajo).
servidor.on("/", handleRoot);
servidor.begin(); Serial.println("Servidor //a partir de ahora el servidor "escucha" las solicitudes HTTP
HTTP iniciado");
}
bucle vacío () {
servidor.manejarCliente(); //Servir las solicitudes HTTP
...
}
//El sitio web se sirve con la función handleRoot() //tan pronto como llega una solicitud de un
navegador void handleRoot() { String content; Cadena hora Cadena fecha Cadena temp
Cadena humi content = "<!DOCTYPE html>"; contenido += "<html>"; contenido += "<cabeza>";
_ web = NTP.getTimeStr(); web =
_ NTP.getDateStr(); web = temporal;
_ web = humi;
_
"°"
//La siguiente línea es importante, por lo que el signo de grado se muestra correctamente
content += "<meta httpequiv=\"ContentType\" content=\"text/html; juego de caracteres=utf8\">"; content += "<title>Mi
primer sitio web de IoT Brick</title>"; contenido += "</cabeza>"; contenido += "<cuerpo>"; contenido += "<h1> ¡Hola
mundo! </h1>"; content += "<p>Este es un sitio web muy simple de su IoT Brick, el
muestra fecha, hora, temperatura y humedad.</p>";
contenido += "<h2>Fecha: "+fecha _ web+"</h2>";
contenido += "<h2>Tiempo: "+tiempo _ web+"</h2>";
contenido += "<h2>Temperatura: "+temp contenido _ web+"</h2>";
+= "<h2>Humedad: "+humi _ web+"</h2>";
content += "<p>Los valores se pueden actualizar en cualquier momento recargando el sitio web
</p>"; contenido += "</
body>"; contenido += "</html>";
servidor.send(200, "texto/html", contenido);
Al comienzo del boceto, se inicia el servidor web y se asigna el puerto estándar 80 para solicitudes a través de HTTP (por ejemplo:
http://www.brickrknowledge.com) . Tan pronto como ingrese la dirección IP local de su IoT Brick en su navegador con el prefijo http://
(por ejemplo , http://192.168.1.153), accederá al directorio raíz de su servidor web para que la función handleRoot() se llama. El
contenido del sitio web se describe en esta función en forma de código HTML. Como ya habrá leído en www.selfhtml.org , la
estructura básica de cada sitio web consta de las llamadas etiquetas HTML.
Para cada elemento suele haber una etiqueta de inicio y una etiqueta de finalización (reconocibles por la barra inclinada anterior "/"),
que están incrustadas en los corchetes angulares característicos. Por ejemplo
<p>Párrafo Regular</p>. En la función handle Root(), el contenido de todo nuestro sitio web ahora se
almacena en el contenido de la variable de cadena . Para que todo quede más claro, la asignación de
cadenas del código HTML se dividió en varias líneas en el boceto. Esto incluye todas las líneas del
formulario content += "...";
Otra dificultad es que en la programación de bocetos, el comienzo y el final de una cadena están marcados
con comillas ("). Sin embargo, dado que el código HTML también puede contener comillas, tenemos que usar
una llamada secuencia de escape dentro de la cadena para corregir codificación Use \" para las comillas. La
cadena en sí misma comienza y termina nuevamente con una comilla doble normal.
Por ejemplo, la línea...
content += "<p>\"Este párrafo está entre comillas\"</p>";
… el código HTML (codificado en UTF8):
<p>"Este párrafo está entre comillas"</p>
Sin la barra invertida anterior en los dos lugares marcados en verde, la primera comilla marcada en verde ya
cerraría la cadena, en lugar de la cuarta en la línea.
Finalmente, el sitio web se envía con el comando server.send(200, "text/html", content); entregado. El primer
parámetro define el código de estado HTTP, que se devuelve cuando se ejecuta correctamente. El código 200
significa OK (la solicitud se procesó con éxito). A continuación, se define el tipo de contenido entregado, es
decir, del tipo "Texto", y el tercer parámetro pasa la cadena de contenido con el contenido del sitio web.
6.6.6 Cambio a través del sitio web
ESP8266WiFi.h, SSD1306Wire.h, TimeLib.h, NtpClientLib.h, ESP8266WebServer.h y FS.h. Si aún no ha instalado las
bibliotecas correspondientes, vaya al cap. 5.2.1 en la página 16 y compensarlo.
Para este ejemplo, primero debe ingresar su nombre WLAN (SSID) y la contraseña asociada en el programa de
ejemplo. Proceder como en el cap. 6.6.1 descrito anteriormente.
Al final de los ejemplos de Internet de las cosas, aprenderá cómo activar una acción en el IoT Brick o controlar sus
pines GPIO a través de un sitio web. Como base para programar el sitio web, esta vez necesitamos algo más que
etiquetas HTML elementales. Utilizamos el framework CSS gratuito llamado Bootstrap, con el que puedes crear
diseños web responsivos con relativa facilidad, que luego se muestran de forma optimizada en dispositivos móviles
(como tu smartphone o tablet).
Están disponibles formularios, botones, tablas, navegación y un sistema de cuadrícula para diseños, así como varias
clases de CSS y componentes de Javascript. Puede encontrar más información sobre Bootstrap, p. B. en: https://
www.bootstrapworld.de.
Antes de que realmente pueda comenzar con la programación de Sketch, todavía tiene que hacer un trabajo diligente.
Tenemos que obtener acceso al sistema de archivos SPIFFS (Sistema de archivos ESP8266) del IoT Brick para poder
copiar algunos archivos allí. Proceder de la siguiente:
1. Cargue el cargador de archivos Arduino ESP8266 desde: https://github.com/esp8266/arduinoesp8266fsplugin/
libera hacia abajo. El boceto se probó con la versión 0.2.0 (enlace directo: https://github.com/esp8266/ardui no
esp8266fsplugin/releases/download/0.2.0/ESP8266FS0.2.0.zip) .
2. Descomprima el archivo ZIP en un directorio de su computadora. El archivo que contiene
esp8266fs.jar se extrae al subdirectorio \ESP8266FS0.2.0\ESP8266FS\tool
de forma predeterminada .
3. Verifique si ya existe un directorio de "herramientas" en su computadora en la ruta "Documentos Arduino".
está disponible. Si no, cree una nueva carpeta llamada "herramientas". Allí se instalan varias herramientas que
se pueden operar desde el IDE de Arduino, incluido el cargador de archivos ESP8266 que necesitamos.
4. Cree otra subcarpeta llamada "ESP8266FS" en el directorio "herramientas".
5. En el directorio "ESP8266FS", cree otra subcarpeta llamada "herramienta" (sin la "s" en
finalizará el.
6. Copie el archivo esp8266fs.jar ( ver punto 2) a la ruta que acaba de crear "Documentos –
Arduino herramientas ESP8266FS herramienta".
7. Reinicie el IDE de Arduino
8. La opción "Cargar datos de croquis ESP8266" ahora aparece en el menú "Herramientas".
9. Si tiene un proyecto compatible con el sistema de archivos SPIFFS,
todos los archivos ubicados en el subdirectorio "datos" de la carpeta
del proyecto (ruta predeterminada: "Documentos Arduino") se
convierten a formato binario y se guardan en la memoria SPI Flash
cargada de Módulo ESP8266.
10. Inicie la carga del archivo en el menú "Herramientas" con la opción
"ESP8266 Sketch Data Upload" Si aparece el mensaje "SPIFFS
Create" durante la primera carga, confirme con "Sí".
¡Subir los archivos puede tardar varios minutos!
En este ejemplo, conectaremos el ladrillo LED doble a GPIO14 (LED rojo) y GPIO13 (LED amarillo) como se muestra en la Fig.
50. Luego podemos encender y apagar los LED, teóricamente en cualquier parte del mundo, a través de dos botones en nuestro
sitio web. La pantalla OLED también nos muestra la hora y la fecha, como ya sabemos por los ejercicios anteriores.

+
9V
1A
GPIO14
+9V
LED
18:00:00
GPIO5
(SCL)
GPIO14
(SCLK)
24/12/2016
GPIO4 GPIO13
(SDA) (MOSI)
Carolina del Norte
GPIO12
LED
(MISO)
GPIO13
Ladrillo IoT
ADC (10:1)
GPIO3 I2C de
(Rx) 18 bits , 20 V máx.
GPIO1 10 bits
micro USB
Fig. 50: Circuito Brick "Conmutación a través del sitio web"
Como ya se mencionó, en este ejemplo también usamos tecnologías web avanzadas como el marco Bootstrap, así como varias
clases de CSS (CSS = Hojas de estilo en cascada) y componentes de Javascript (Javascript es un lenguaje de secuencias de
comandos que se usa a menudo en sitios web). Como resultado, el código es mucho más grande que en los ejercicios
anteriores, pero se basa en ellos. Entonces, al discutir el boceto, nos enfocaremos en los elementos esenciales. Si tiene
preguntas sobre el uso de Bootstrap, CSS y Javascript, le pedimos que investigue en Internet o compre un libro especializado
relevante, ya que esto iría más allá del alcance de esta guía de conocimientos de Brick'R'.
PROPINA:
Para todos los que ya tienen un buen conocimiento de HTML, Bootstrap, CSS y Javascript y les gustaría modificar el sitio web
ellos mismos, hemos disfrazado el código HTML de la función handleRoot() "en texto sin formato" como un comentario y lo
copiamos en el boceto. . Puede usar varios editores de HTML gratuitos como NVU para Windows, Linux o MAC OS X (consulte:
www.nvu.com) o BlueGriffon (consulte: www.bluegriffon.org) para editar archivos .
Para que este ejemplo funcione correctamente, debe habilitar Javascript en su navegador. Este suele ser el caso por
defecto.
...
servidor ESP8266WebServer(80); //Iniciar servidor web en el puerto 80
...
...
//Si el navegador accede directamente al directorio raíz, //ejecuta la función handleRoot.
servidor.on("/", handleRoot);
// JS (Javascript) server.on("/
js/jquery", handleJsJquery); servidor.on("/js/bootstrap",
handleJsBootstrap); server.on("/js/bootstrapswitch",
handleJsBootstrapSwitch); // CSS (hojas de estilo en cascada) server.on("/css/bootstrap",
handleCssBootstrap); server.on("/css/bootstrapswitch", handleCssBootstrapSwitch); // Servidor
de imágenes.on("/img/bg.png", handleImgBg); servidor.on("/img/brklogo.png", handleImgLogo);
// Identificadores del servidor web para las funciones de conmutación de GPIO
server.on("/switch13on", handleGpio13On); servidor.on("/interruptor13apagado",
handleGpio13Off); servidor.on("/switch14on", handleGpio14On); servidor.on("/
interruptor14apagado", handleGpio14Off);
servidor.begin();
Serial.println("Servidor HTTP iniciado"); pines de
configuración();
}
...
// Función de manejo para el encendido de GPIO13
anular manejarGpio13On() {
escritura digital (gpio13, don);
server.send(200, "text/html", gpio13Name+" on");
Continúa en la página siguiente...
En la rutina de configuración de nuestro boceto, primero se definen varios identificadores con las numerosas instrucciones server.on() , que
determinan qué funciones se ejecutan tan pronto como se llama a ciertos enlaces en el navegador. Si por ej. Por ejemplo, si IoT Brick recibió
la dirección IP 192.168.1.153 del servidor DHCP, llamando a la dirección http://192.168.1.153/img/brklogo. png da como resultado que se
ejecute la función handleImgLogo() , que a su vez lee el archivo de imagen brk logo.png del sistema de archivos interno (SPIFFS) y lo entrega
al servidor web. Al igual que el archivo de logotipo, cada secuencia de comandos java, css o archivo de imagen almacenado en el sistema
de archivos interno (SPIFFS) necesita un identificador de archivo para que podamos acceder a él. Además, se definen identificadores con los
que reacciona el servidor web cuando llega una solicitud del navegador para activar o desactivar un GPIO. Luego, el servidor web se inicia
con server.begin . Los identificadores en sí solo se definen al final del boceto. En el código de ejemplo anterior, hemos seleccionado la
función handle handleGpio13On() para encender el LED en GPIO13.
Extracto del programa (continuación)
...
bucle vacío () {
servidor.manejarCliente(); //Servir las solicitudes HTTP
//El sitio web se sirve con la función handleRoot() //tan pronto como llega una solicitud de un
navegador void handleRoot() {
Contenido de cadena;
cadena de red (ssid); contenido
+= "<html>";
contenido +=
"<cabeza>"; //...diversas metaetiquetas que no son relevantes para comprender el contenido +=
"<title>Cambiar IoT Brick a través de WLAN "+network+"</title>"; contenido += "<enlace rel=\"hoja de
estilo\" href=\"/css/bootstrap\">"; contenido += "<enlace rel=\"hoja de estilo\" href=\"/css/bootstrap
switch\">"; contenido += "<estilo>cuerpo{imagendefondo:url(/img/bg.png);margen:0;
padding:20px;backgroundsize:100% auto;backgroundrepeat:norepeat; familia de fuentes:\"Helvetica
Neue\",Helvetica,Arial,sansserif; fontsize:14px;lineheight:1.5;color:#333;backgroundcolor:#fff} .col
sm2{margintop:20px}.imgthumbnail{border:0}</style> ";
contenido += "</cabeza>";
contenido += "<cuerpo>";
content += "<div class=\"containerfluid\">"; content += "<div
clase=\"fila\">"; contenido += "<div class=\"colsm2\"><img
class=\"imgthumbnail\"
src=\"/img/brklogo.png\"></div>";
contenido += "</div>"; content
+= "<div clase=\"fila\">"; contenido += "<div
class=\"colsm2\"><input type=\"checkbox\" id=\"switch14\"
datalabeltext=\""+gpio14Name+"\" datalabelwidth=\"120\"></div>";
contenido += "<div class=\"colsm2\"><input type=\"checkbox\" id=\"switch13\"
datalabeltext=\""+gpio13Name+"\" datalabelwidth=\"120\"></div>";
contenido += "</div>";
contenido += "</div>";
contenido += "<script src=\"/js/jquery\"></script>"; contenido += "<script
src=\"/js/bootstrap\"></script>"; contenido += "<script src=\"/js/bootstrap
switch\"></script>"; contenido += "<tipo de script=\"texto/javascript\">"; contenido += "$
('entrada[tipo=\"casilla\"]').bootstrapSwitch({onSwitchChange:
function(){$.ajax({url:'/'+$(this).prop('id')+''+($(this).prop('checked')? 'on':'off ')});}});";
contenido += "var setAdc=función(){$.ajax({url:'/adc'}).done(función(datos)
{data=data||{};if(data.hasOwnProperty('data')){$
('#adc') .text(data.data);}}).fail(function(jqxhr,textStatus,error) {}) .siempre(función()
{setTimeout(setAdc,1000);});}; setAdc();"; contenido += "</script>"; contenido += "</
body>";
contenido += "</html>";
servidor. enviar (200, "texto/html", contenido); // código de estado HTTP 200 = OK }
Como ya se practicó en el ejemplo 6.6.5, el contenido de nuestro sitio web se almacena en la función handle Root() en
la variable de cadena content . Una vez más, debe tenerse en cuenta que en la programación de bocetos, el principio y
el final de una cadena están marcados con comillas (").
Sin embargo, dado que el código HTML también puede contener comillas, tenemos que usar la llamada secuencia de
escape \" para cada comilla que aparece dentro de la cadena para una codificación correcta .
Para una mejor comprensión, escribimos los fragmentos de código citados en el siguiente texto en "texto sin formato".
Con el elemento de estilo <style>body{backgroundimage:url(/img/bg.png);... se integra la imagen de fondo del sitio web
y se definen otros parámetros que influyen en la apariencia del sitio web. En el área del cuerpo, verá elementos div
anidados que se utilizan para estructurar el sitio web. A su vez, diferentes elementos como texto, imágenes o formularios
se pueden combinar en un elemento div y se pueden controlar sus propiedades. Por ejemplo, el logotipo está integrado
con el elemento Div <div class="colsm2"><img class="imgthumbnail" src="/img/brklo go.png"> .
Los botones para encender y apagar los LED se implementan con un elemento de entrada del tipo "casilla de
verificación" , el formateo se realiza utilizando elementos de estilo del marco de arranque. Varios elementos del script
hacia el final del boceto especifican la ruta relativa a los archivos Javascript a los que el sitio web necesita acceder.
Finalmente, el elemento de script <script type="text/javascript"> introduce una sección más larga de código JavaScript
en la que se consulta el evento de presionar un botón con onSwitchChange y se llama a la función de manejo para
encender o apagar el LED.
Con el comando server.send(200, "text/html", content); el sitio web se entrega dinámicamente al navegador.
7. Comunidad de ladrillos
El universo Brick se expande: ya sea en ferias comerciales, en nuestro sitio web, en YouTube o en las redes sociales, encontrará más sugerencias,
experimentos y nuevos Bricks en todas partes, ¡con los que puede dar rienda suelta a su creatividad!
Más proyectos En la
pestaña "Crear" puedes probar, reconstruir y mejorar proyectos y circuitos de otros miembros de la comunidad.
Por supuesto, también puedes mostrarle al mundo tus propios experimentos.
60 comunidad de ladrillos
medios de comunicación social
En la pestaña "Comunidad" encontrará nuestra presencia en las redes sociales y siempre estará actualizado.
En todo el mundo
También en la pestaña "Comunidad" puedes ver dónde ya hay miembros Brick, dónde estamos en este momento o con qué hito ya se han
fotografiado los Bricks. ¡Aquí también puedes enviarnos tu imagen de ladrillo y pronto la encontrarás en el mapa mundial!
comunidad de ladrillos 61
¡Aún más ladrillos!
En la pestaña "Bricks" encontrará
todos los bloques de construcción
disponibles para expandir sus
circuitos y experimentos.
El blog de ladrillos
Cada semana hay una nueva
publicación de blog en
"Comunidad". Aquí encontrará
informes de ferias comerciales,
nuevos experimentos, historias
divertidas e información sobre
nuevos juegos y ladrillos.
62 comunidad de ladrillos
8. Conjuntos de ladrillos de un vistazo
Conjunto básico contiene 19 ladrillos TODOLADRILLO0374
Con los 19 Bricks incluidos, el Conjunto básico ofrece una
rápida introducción al mundo del conocimiento de Brick 'R'
y ya permite una gran cantidad de experimentos. Con la
versión básica, incluso los jóvenes desarrolladores pueden
construir sus propios circuitos y realizar sus primeros
experimentos físicos y técnicos.
El juego avanzado contiene 111 ladrillos. TODOLADRILLO0223
Con 111 piezas, el Advanced Set ofrece todo lo que se
necesita para ilustrar circuitos electrónicos complejos.
Entre los más de 100 circuitos de ejemplo también hay
numerosas aplicaciones que conocemos de la vida
cotidiana.
El conjunto se armó de tal manera que también puede ser
utilizado por oficinas de ingeniería para una visualización
rentable como parte de la creación rápida de prototipos.
Conjuntos de ladrillos de un vistazo 63
Conjunto de codificación Arduino contiene 44 ladrillos TODOLADRILLO0414
El conjunto de codificación Arduino Brick'R'knowledge amplía los
experimentos hacia la electrónica digital con una introducción a la
programación de microcontroladores utilizando el Arduino Nano
como ejemplo. Además de los ladrillos para circuitos analógicos,
el conjunto también contiene ladrillos para aplicaciones digitales,
como una pantalla de 7 segmentos, una pantalla OLED, un
convertidor D/A, un ladrillo I2 C para la expansión de pines del
Arduino Nano, un adaptador Arduino Nano ladrillo y por supuesto
el Arduino Nano. Además de la descripción de los experimentos,
también se proporcionan todos los ejemplos de programación para
que pueda ingresar al mundo de la programación de Arduino.
Juego de luces de 7 colores. contiene 28 ladrillos TODOLADRILLO0398
Con un total de 28 bloques de luz LED en 7 colores
diferentes, se pueden establecer acentos de luz
impresionantes en la arquitectura horizontal y vertical. Los LED
de 1 vatio en los colores rojo, amarillo, azul, naranja, violeta,
verde y blanco cálido son perfectos para figuras luminosas
individuales o como solución de iluminación móvil.
Juego de luces de colores RGB TODOLADRILLO0619
¡Crea tu propio espectáculo de luces! El conjunto de luces de
colores RGB contiene cuatro tiras LED flexibles con un total
de 36 LED que se pueden controlar con un control remoto
infrarrojo. Las tiras LED se pueden pegar, cortar y conectar
como quieras. El mando a distancia por infrarrojos tiene 16
botones de colores diferentes y 4 programas de luz.
64 Conjuntos de ladrillos de un vistazo
Conjunto LED programable contiene 49 ladrillos TODOLADRILLO0483
El set incluye 49 bricks LED RGB direccionables con dos o tres
conectores, así como un brick de control y conexión de alimentación
Arduino, un brick adaptador Arduino y un Arduino Nano. El conjunto hace
posible crear sus propias animaciones LED como animaciones de
imágenes en movimiento o en color y tratar de forma lúdica la programación
de microcontroladores. Las instalaciones de luz innovadoras y las imágenes
intermitentes y pulsantes iluminadas individualmente en diferentes niveles
de color y brillo se pueden implementar maravillosamente con el conjunto
LED programable.
Conjunto LED de alta potencia contiene 50 ladrillos TODOLADRILLO0399
El conjunto de LED radiantes de alta potencia contiene cincuenta
ladrillos de alta potencia de 1 vatio y una fuente de alimentación de 12
voltios y 8 amperios. Los ladrillos se pueden unir fácilmente para crear
soluciones individuales. Por ejemplo, se pueden construir varias
lámparas de mesa a partir de los ladrillos, que luego se pueden expandir.
Debido a la fuerte luminosidad, esto ofrece un ambiente elegante y es
perfecto como luz de noche.
El conjunto de LED de alta potencia permite abordar el diseño de
iluminación de forma lúdica.
juego de bricolaje TODOLADRILLO0397
El conjunto "hágalo usted mismo" permite a los ingenieros y
desarrolladores construir sus propios ladrillos además de los que ya
están disponibles. Los componentes contenidos aquí ofrecen una visión
profunda de la estructura y arquitectura de los componentes electrónicos.
Con un soldador y estaño, los manitas pueden recrear los ladrillos
estándar o crear sus propios ladrillos para aplicaciones especiales
individuales y, por lo tanto, incluso desarrollar sus propios juegos.
Conjuntos de ladrillos de un vistazo sesenta y cinco
Mhz kit de bricolaje TODOLADRILLO0457
Con el MHz DIY Set puedes crear tus propios bloques
de construcción para experimentos y circuitos en el
rango de MHz. El conjunto contiene tres placas de
cuadrícula y de experimentación diferentes, así como
conectores BNC, clavijas PSMP y los conectores
correspondientes. El set también contiene una plantilla
de soldadura para los enchufes SMD y los conectores
hermafroditas, para que puedas adaptar tus propios
desarrollos al Sistema Brick.
Kit de bricolaje Ghz TODOLADRILLO0458
El GHz DIY Set ofrece interesantes posibilidades de desarrollo en
el rango de alta frecuencia hasta frecuencias de gigahercios.
Además de cuatro placas diferentes, el juego DIY GHz también se
puede utilizar con una amplia variedad de componentes, como los
conectores coaxiales SMA y PSMP horizontales y verticales y los
conectores pertenecientes al sistema de ladrillos. El conjunto es
especialmente adecuado para aficionados a la tecnología de medición
y radioaficionados.
conjunto solar contiene 20 ladrillos TODOLADRILLO0484
El Solar Set de Brick'R'knowledge garantiza diversión experimental
para toda la familia y enseña a los niños las energías renovables de
forma lúdica.
• ¿Cómo funciona una celda solar?
• ¿Cómo almacena electricidad una
batería? • ¿Cómo construir una luz nocturna con un detector de movimiento?
El Solar Set proporciona respuestas a estas y otras preguntas. Con
este set eres miembro oficial del movimiento Maker.
66 Conjuntos de ladrillos de un vistazo
El juego de medidas uno contiene 4 ladrillos TODOLADRILLO0637
El conjunto permite determinar fácilmente el voltaje, la corriente y otras variables
medidas con dispositivos de medición estándar en circuitos de conocimiento Brick'R'. El
juego de adaptadores de medición consta de los siguientes bloques: un adaptador de
medición con un conector hembra de 3 x 2 mm, un adaptador de medición con un
extremo cerrado GND de 4 mm en negro con una abrazadera de cable adicional, un
adaptador de medición con un extremo de 4 mm en amarillo y un adaptador de medición
con una línea de 4 mm en rojo.
El conjunto de medidas dos contiene 6 ladrillos TODOLADRILLO0638
El conjunto permite determinar fácilmente el voltaje, la corriente y otras variables
medidas con dispositivos de medición estándar en circuitos de conocimiento Brick'R'. El
juego de adaptadores de medición consta de los siguientes bloques: dos adaptadores
de medición con GND de extremo cerrado de 4 mm en negro, dos adaptadores de
medición con 4 mm en línea en rojo y dos adaptadores de medición con GND de extremo
abierto de 4 mm en negro.
conjunto lógico contiene 93 ladrillos TODOLADRILLO0630
El conjunto lógico es ideal para una introducción rápida a la tecnología de circuitos
digitales. Con la ayuda del folleto adjunto con ejemplos de circuitos que se complementan
entre sí de forma didáctica, los alumnos pueden resolver rápidamente los circuitos
digitales más importantes, como sumadores, registros de desplazamiento y contadores.
Pero los profesores también obtienen una base orientada a la práctica para su enseñanza
diaria con el equipo completamente equipado. Conectar y experimentar con los ladrillos
es divertido y lo alienta a crear sus propias variantes de circuito. El alcance de la entrega
del conjunto lógico abarca desde bloques lógicos simples (AND, OR, NAND, NOR, XOR,
XNOR, NOT) hasta varios bloques flipflop (tipo D, RS y JK), hasta un bloque de reloj
(alternativamente, un botón antirrebote para pulsos individuales) a un bloque contador
BCD con una pantalla integrada de 7 segmentos.
Una amplia selección de LED, botones y ladrillos de cable completan el
conjunto.
Conjuntos de ladrillos de un vistazo 67
Sistemas informáticos ALLNET© GmbH MakerStore y MakerSpace
Maistrasse 2 Calle Gdańsk 22
D82110 D10435 Berlín
Germeringwww.brickrknowledge.com www.makerstore.de
Teléfono: +49 (0)89 894 222 921 Fax: Teléfono: +49 (0)30 473 756 80
+49 (0)89 894 222 33 service@allknow.de
info@brickrknowledge.com
www.brickrknowledge.de

BRK IoT Set Manual

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

BRK IoT Set Manual

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

Ilustración Cantidad Artículo no. / ID de ladrillo Breve descripción

Ilustración Cantidad Artículo no. / ID de ladrillo Breve descripción

Ilustración Cantidad Artículo no. / ID de ladrillo Breve descripción

Alternativamente Resistencia pull­up (ver Capítulo índice para

Ladrillo IoT retraso (1000); // esperar 1000ms

Conexión USB a la computadora de desarrollo retraso (100); // esperar 100ms

MSB de datos LSB de datos Reconocimiento

MSB LSB R/W RECONOCIMIENTO MSB LSB ACK

40 (16): 44(16) : 48(16): 4C(16):

ASD GPIO4 GPIO13

ASD GPIO4 GPIO13

display.setTextAlignment(TEXT display.setFont(ArialMT _ ALINEAR _ IZQUIERDA); // Alinear texto a la izquierda

display.setTextAlignment(TEXT display.setFont(ArialMT _ ALINEAR _ CENTRO); // Alinear el texto centrado

display.setTextAlignment(TEXT display.setFont(ArialMT _ ALINEAR _ DERECHO); // Alinear texto a la derecha

hora 0s 1s 2 segundos 3 segundos 4s 5 segundos 6s 7s 8s 9s

Número de etapas (resolución) bits 210 = 1024 bits 218 = 262144

Rango de medición y valor digital 0… 9.99V 0… 0… 19.999924V 0…

error de cuantización ±4.9mV ±38μV

frecuencia de muestreo máx. 200 muestras/segundo (= 200 S/s) 3,75 muestras/segundo (= 3,75 S/s)

tipo de convertidor convertidor SAR Convertidor Delta Sigma (Convertidor ∆∑)

número Número palabra binaria número binario

display.setTextAlignment(TEXT _ ALINEAR _ IZQUIERDA);

#define DHT _ TIPO DHT11 // Definir tipo de sensor: DHT11

DHT DHT(DHT _ CLAVIJA, DHT _ ESCRIBE); //Definir variable de tipo DHT

display.setTextAlignment(TEXT _ ALINEAR _ IZQUIERDA);

GPIO5 23:59:59 GPIO14

192.168.1.123 GW: (Rx) 18 bits , 20 V máx.

Conjunto básico contiene 19 ladrillos TODO­LADRILLO­0374

Conjunto de codificación Arduino contiene 44 ladrillos TODO­LADRILLO­0414

Juego de luces de 7 colores. contiene 28 ladrillos TODO­LADRILLO­0398

Conjunto LED programable contiene 49 ladrillos TODO­LADRILLO­0483

Conjunto LED de alta potencia contiene 50 ladrillos TODO­LADRILLO­0399

conjunto solar contiene 20 ladrillos TODO­LADRILLO­0484

conjunto lógico contiene 93 ladrillos TODO­LADRILLO­0630

También podría gustarte

Alternativamente Resistencia pullup (ver Capítulo índice para

Conjunto básico contiene 19 ladrillos TODOLADRILLO0374

Conjunto de codificación Arduino contiene 44 ladrillos TODOLADRILLO0414

Juego de luces de 7 colores. contiene 28 ladrillos TODOLADRILLO0398

Conjunto LED programable contiene 49 ladrillos TODOLADRILLO0483

Conjunto LED de alta potencia contiene 50 ladrillos TODOLADRILLO0399

conjunto solar contiene 20 ladrillos TODOLADRILLO0484

conjunto lógico contiene 93 ladrillos TODOLADRILLO0630