Mapa del blog

A continuación os incluimos todas las áreas que intentamos cubrir en nuestro blog con objeto de que os sea más fácil moveros y localizar lo que necesitéis, y si hay algo que buscas y no encuentras, no dudes en pedirlo, con mucho gusto intentaremos dar una solución a vuestras dudas.

Fecha	Temática
junio-13	Cuestiones generales
julio-13	Conceptos básicos de electrónica
agosto-13	Cómo construirte tu propio taller mecatrónico
septiembre-13	Componentes electrónicos 1
octubre-13	Componentes electrónicos 2
noviembre-13	Sensores
diciembre-13	Módulos y Sensores Keyes
enero-14	Actuadores
febrero-14	Motores
marzo-14	Mecánica
abril-14	Pantallas y displays
mayo-14
junio-14	Componentes y módulos para Fritzing
julio-14
agosto-14
septiembre-14	Consejos y herramientas para tu Blog
octubre-14
noviembre-14	Do It Yourself
diciembre-14	Familia de placas Arduino
enero-15	Shields (placas de expansión)
febrero-15	¡Quiero aprender a programar!
marzo-15
abril-15
mayo-15	ArduBlock
junio-15	Protocolos de comunicación
julio-15	Ejemplos de programación
agosto-15	Librerías
septiembre-15	Primeros proyectos
octubre-15	Proyectos electrónicos sencillos
noviembre-15
diciembre-15	Multímetros, qué son y cómo funcionan
enero-16	Hardware Arduino
febrero-16	ATtiny85
marzo-16	Baterías, Pilas y Fuentes de alimentación
abril-16	ESP8266
mayo-16
junio-16
julio-16
agosto-16
septiembre-16
octubre-16
noviembre-16
diciembre-16
enero-17	Ejemplos de programación
febrero-17
marzo-17	ESP32
abril-17
mayo-17

Y ya sabéis, si tenéis alguna sugerencia o duda, no tenéis más que mandarnos un correo a

e intentaremos responder a vuestra pregunta lo antes que podamos.

Logo SoloArduino

Cómo programar el ESP32 con el IDE de Arduino en Windows

Pasos para instalar el soporte de Arduino ESP32 en Windows

(Probado en Windows 10 de 32 y 64 bits )


A continuación os vamos a presentar una breve guía de qué cosas tenéis que hacer para empezar a usar el módulo ESP32 con el IDE de Arduino si estamos usando Windows.


1.- Descargar e instalar la última Arduino IDE de Windows Installer de arduino.cc. En estos momentos va por la versión 1.8.2, pero está continuamente en actualización.

2.- Descargar e instalar el interfase de usuario (GUI) del repositorio de programas GitHub, Git desde git-scm.com.

En el momento en el que preparamos esta entrada, la versión diponible era la 2.12.2

Dejad las opciones que vienen por defecto durante el proceso de instalación, incluida la carpeta propuesta. De modo que básicamente solo tenéis que y dándole al botón “Next” en cada paso que os consulte, 

hasta que sale el botón “Install” en el también haremos clic. 

En este momento tendríamos ya todo el software que necesitaríamos para poder trabajar con Windows, con el IDE de Arduino y poder programar el módulo ESP32. Pero si en este punto abrimos al IDE Arduino y nos vamos a seleccionar el módulo ESP32 dentro del menú herramientas, veremos que no nos sale, y es porque todavía nos falta dar un par de pasitos más. Instalar las librerías del ESP32 y el compilador para que el IDE pueda traducir el lenguaje Arduino a un lenguaje que lo entienda el módulo ESP32 de Espressiff.

Vamos a configurarlo.

3.- Arranque el interfase de usuario del repositorio de programas GitHub que acabamos de instalar,

 siguiendo los siguientes pasos:

Primero: le decimos que vamos a clonar un repositorio ya existente (esto significa que queremos replicar los ficheros que se mantienen siempre actualizados en una carpeta de un servidor GitHub)

Segundo: le indicamos donde están los ficheros que queremos bajarnos. https://github.com/espressif/arduino-esp32.git

El destino en donde queremos copiar esos ficheros en nuestro PC (OJO cuidado con la barras que NO SON las de la tecla del 7, sino las invertidas)

C:\Users\[tu_nombre_de_usuario]\Documentos\Arduino\hardware\espressif\esp32 

Con esto habremos conseguido que todos los ficheros actualizados disponibles en servidor de GitHub y que le hace falta al IDE de Arduino para poder manejar el hardware que le vamos a conectar (nuestro módulo ESP32), los tengan clonados en la carpetas de nuestro PC que consulta el IDE de nuestro Arduino.

Más adelante, y como previsiblemente, estos ficheros disponibles en GitHub se irán actualizando, lo único que tendremos que hacer es irnos al menú Remote del GUI y actualizarlas. Ver imagen a continuación.

Ahora nos vamos a la carpeta

 C:\Users\[tu_nombre_de_usuario]\Documentos\Arduino\hardware\espressif\esp32\tools

 y ejecutamos el fichero get.exe, haciendo doble clic en él.

Cuando termina get.exe, debería habernos creado entre otras cosas, una nueva carpeta llamada xtensa-esp32-elf y ubicada en

C:\Users\[tu_nombre_de_usuario]\Documentos\Arduino\hardware\espressif\esp32\tools\xtensa-esp32-elf, 

que es donde vamos a grabar el compilador que va a utilizar nuestro IDE para traducir nuestros sketches para que el módulo ESP32 entienda lo que queremos que haga.

Ahora, antes de conectar nada, tenemos que estar seguros que nuestro IDE Arduino está cerrado. Para que funcione todo lo que le hemos instalado. Lo abrimos y si conectamos nuestro módulo ESP32 via USB, Windows debería reconocerlo. Si nos vamos al menú herramientas de nuestro Arduino, y nos vamos a las placas disponibles dentro de la opción placas, veremos que nos aparece el módulo ESP32 abajo en el desplegable.

Para comunicarnos bien con él, debemos verificar que el puerto COM al que está conectado está bien identificado, que la frecuencia de trabajo es 80MHz y que la velocidad de transferencia la dejamos en 115200 baudios

A partir de aquí y conociendo el pin-out de la placa que tengamos entre manos y lo que hemos aprendido sobre como programar, no nos resultará complicado empezar a adaptar algunos de los ejemplos básicos que el propio IDE de Arduino trae establecidos, pero que todavía no son compatibles con el módulo ESP32.

Reconocimientos: Esta entrada está basada en una transcripción hecha del video que biblioman09 nos ofrece en YouTube sobre este particular y que incluímos al final de esta breve guía, así como de las instrucciones traducidas del inglés disponibles en repositorio de GitHub de Espressif.

¿Qué es un ESP32?

Hoy os traemos una nueva plaquita que acaba de aterrizar al mercado y que previsiblemente muy pronto veremos en todas partes:  la ESP32 de Espressif.

Sin entrar en demasiados detalles, os adjunto aquí una pequeña tabla comparativa preparada por nuestros colegas del canal educ8s que hace unas semanas le dedicó un pequeño reportaje a esta fantástica placa.

No solo es que el microcontrolador sea 10 veces más rápido, sino que además es al ser de arquitectura de 32 bits y doble nucleo la velocidad de procesamiento de datos es muy superior a la que nos tiene acostumbrados nuestro querido ATmega328P de ATMEL, o cualquiera de las diferentes versiones que tiene disponible en la gran familia

Pero si ya fuera poco la cuestión de la potencia del micro, todavía hay más. Si habéis podido echarle un vistazo a la primera tabla, la ESP32 nos ofrece nada más y nada menos 18 pines analógicos, 3 veces más que nuestra placa Arduino UNO, pero podríamos argumentar que nuestra placa Arduino Mega algo parecido 16, y es verdad pero es que la resolución de los pines analógicos de la ESP32, es de 12 bits y no de 10 como los que tiene nuestro Arduino UNO o nuestra Arduino MEGA. Para estar a la altura deberíamos optar por nuestra Arduino DUE, que al igual que la ESP32, nos ofrece dos pines de salida analógica (Digital to Analog Converter) de 12 bits.  Aunque menos potente, parecida. Pero si solo fuera una cuestión de tamaño, y no lo decimos por grande es una cuarta parte del tamaño de nuestro Arduino UNO.

Es que en este tamaño tan reducido, se ha incluido una antena un módulo WIFI y un módulo Bluetooth, además de capacidad criptográfica para permitir que este módulo se puede convertir en el rey de IoT (Internet of thing, o internet de las cosas).

Un ejemplo de la capacidad de desarrollar soluciones extremas lo podéis encontrar en Youtube, donde Jeija dice haber conseguido transmitir señales de video solo con la ESP32 a unos 10 kms campo a través.

Y por si fuera poco, el precio parece de lo más abordable. Una tentación para probar cuánto de verdad hay en un módulo alucinante.

Números decimales, variables tipo float y función print

Es habitual que a veces necesitemos hacer algunos cálculos precisos con las variables que estemos manejando en nuestro sketch, y precisemos el manejo de decimales. Por ejemplo pudiera ser que quisiéramos usar nuestro Arduino para medir voltajes gracias a las entradas analógicas que tenemos en nuestra placa.

Como vimos en la entrada que dedicamos a la resolución de los pines analógicos  podríamos conseguir distinguir variaciones de hasta 4.9 milivoltios en nuestras mediciones. Así que por qué no ponernos manos a la obra y fabricarnoslo.


Versión 1 - Regla de tres para obtener el valor de voltaje
Para ello solo tenemos que aplicar una regla de tres muy sencillita:

Sin embargo, cuando abrimos el monitor serie para evaluar los resultados, el resultado que nos devuelve es siempre  "0" y no lo que esperábamos visualizar: un valor comprendido entre 0-5 voltios.

la razón del error es probable que esté localizada en el cálculo que hemos hecho al dividir 5/1023, que aunque nosotros de forma lógica pensamos que debería ser un número 0.00488758553, nuestro Arduino razona de diferente manera y lo redondea a 0. Y claro cualquier número multiplicado por 0 es 0. Así que tendremos que arreglarlo.

Versión 2 - Manejo de decimales

Vamos a escribir lo mismo pero de diferente forma. En lugar de 5/1023, vamos e escribir 5.0/1023.0, para nosotros es exactamente lo mismo que 5/1023, pero escribiéndoselo así, nuestro Arduino piensa que lo que tiene entre manos tiene que dar como resultado un número decimal. Veamos el resultado.

Bastante mejor, pero no todo lo bien que quisiéramos, si ahora en lugar de limitarnos a querer saber si en la salida tenemos 0, 1, 2, 3, 4 ó 5 voltios, quisiéramos sacar toda la precisión que tiene nuestros pines analógicos, que son capaces de discriminar variaciones de tensión de 4,9 milivoltios, lo único que se nos ocurre es es cambiar la definición de nuestra variable voltaje.



Versión 3 - Uso de variable tipo float
Hasta ahora hemos utilizado números enteros en todos nuestros ejemplos. Sin embargo, es muy habitual que los cálculos matemáticos den como resultados números decimales y no enteros. Para manejarlos, Arduino nos permite utilizar dos tipos de variables: float y double.

Los float tienen una precisión de 6 o 7 dígitos decimales. Al contrario que en otras plataformas, donde tu podrías obtener mayor precisión usando una variable tipo double (por ejemplo, por encima de 15 dígitos), en Arduino los double tienen el mismo tamaño que los float. En Arduino se mantienen los dos tipos por compatibilidad con C y C++, pero es importante tener en cuenta que no hay diferencia entre ambos. Los dos permiten utilizar números decimales entre el intervalo 3.4028235e+38 y -3.4028235e+38.
Así que parece evidente lo que debemos hacer. Vamos a cambiar la definición de la variable voltaje de entero (int) a decimal (float). Con ello deberíamos resolver el problema.
Pero ojo, a pesar de haber declarado la variable voltaje como float, parece que hay algún error en alguna parte, el resultado solo contiene dos números decimales y no todos los que esperábamos.

El origen del error esta vez no proviene de los cálculos, ni de la declaración de las variables. El error proviene de la función que estamos usando para visualizar los datos a través del monitor serie. Por defecto print y println sólo muestran dos posiciones decimales.

Versión 4 - Números decimales, variables tipo float y función print

De modo que si queremos sacar tres decimales, el truco está en decírselo a la función print de forma explícita. Pare ello después de indicarle lo que queremos que pinte en el monitor serie, le pondremos el número de decimales con los que queremos que nos lo enseñe.

De este modo ahora, si que nuestro sketch nos mostrará las medidas que queríamos obtener.

Espero que hayamos podido explicar bien el problema y como resolverlo adecuadamente. En breve haremos una entrada un poco más técnica sobre la manipulación de los números decimales y el porqué restas tan simples como  5.1-0.1 nunca dan 5.

Y ya sabéis, si tenéis alguna sugerencia o duda, no tenéis más que mandarnos un correo a

e intentaremos responder a vuestra pregunta lo antes que podamos.

Ejemplos - Basics - BareMinimum

En la entrada de hoy vamos a revisar el contenido del segundo sketch de ejemplo que trae el IDE de Arduino dentro del capítulo Básico, el llamado BareMinimum.

Está disponible dentro de la opción del IDE: Ejemplos > 01.Basics > BareMinimum

Y si cargáis el Sketch veréis que se compone exclusivamente de los dos bloques básicos y mínimos que debemos de contemplar a la hora de componer nuestro sketch, la sección de la configuración inicial, o setup ( ), y la sección del código a ejecutar de forma ininterrumpida,  o loop ( ).




En donde setup() es la parte encargada de recoger la configuración y loop() es la que contiene el programa que se ejecutará cíclicamente (de ahí el término loop –bucle-). Ambas funciones son necesarias para que el programa trabaje.

La función de configuración (setup) debe contener la inicialización de los elementos y esta función sólo se ejecuta una vez justo después de hacer el reset y no se vuelve a ejecutar hasta que no haya otro reset. Es la primera función a ejecutar en el programa y se utiliza para configurar, inicializar variables, comenzar a usar librerías, etc…

La función bucle (loop) siguiente contiene el código que se ejecutará continuamente (lectura de entradas, activación de salidas, etc). Esta función es el núcleo de todos los programas de Arduino y se usa para el control activo de la placa.

La función loop se ejecuta justo después de setup.


Efectivamente, este sketch se corresponde con la mínima estructura para escribir un programa, pero incluso así, hubiera sido adecuado incluir en el mínimo, la opción de comentarios al inicio del mismo. 

Si ves algún sketch, verás partes del código que están escritas en lenguaje humano, es decir, no entendible para el IDE de Arduino. Un buen sketch va siempre acompañado de unos buenos comentarios, es decir, líneas de código que el programa ignorará y que nos servirán, por ejemplo, para describir el funcionamiento del programa de forma global, el por qué de una función, la utilización de unas determinadas variables, etc.

 Recordemos que una línea de comentario comienza por //  y termina con la siguiente línea de código. Al igual que los comentarios de bloque, los comentarios de línea son ignorados por el programa y no ocupan espacio en la memoria, por lo que son las herramientas adecuadas para poder explicar qué tipo de funcionamiento pretendemos implementar en nuestro Sketch de modo que cualquiera pueda entender con facilidad las líneas de códigos que a continuación hemos desarrollado.

Un ejemplo simple lo podemos encontrar en muchos programas disponibles en internet.

Un  par de ejemplos de comentarios en línea lo podemos ver en recuadro azul del sketch Blink mostrada a continuación.

Los comentarios de varias líneas o bloques de comentarios han de estar delimintados por /* al comienzo y por */ al final. Dentro de un bloque de comentarios no se puede especificar otro bloque de comentarios, pues éste acaba cuando se percibe el primer símbolo de cierre */.

Un ejemplo del mismo lo podemos ver en el recuadro negro del sketch Blink mostrado anteriormente.

Ejemplos - Basics - AnalogReadSerial

Con esta entrada comenzaremos a repasar la serie de ejemplos que el IDE Arduino trae instalado para permitirnos aprender a usar las funciones más básicas de nuestro placa.

En este caso vamos a revisar el primer ejemplo de los considerados básicos, relacionados con la lectura de una señal de tensión analógica.

Para esta práctica vamos a necesitar repasar unas cuantas ideas que vimos anteriormente:

1. ¿Qué es un voltaje?
2. ¿Qué es la ley de Ohm?
3. ¿Qué es un divisor de tensión?
4. ¿Qué es un potenciómetro?
5. ¿Qué es una señal analógica?
6. ¿Qué es un convertidor analógico digital?
7. ¿Cuántos pines tiene nuestro Arduino capaz de leer señales analógicas?

Adicionalmente vamos a necesitar introducir una señal analógica variable por uno de los pines analógicos de nuestra placa.  Para ellos usaremos vamos necesitaremos aplicar lo que hemos aprendido sobre los divisores de tensión.

Sabemos que si colocamos nuestro voltímetro entre dos resistencias conectadas a una diferencia de potencial concreto, el voltaje que mediríamos vendría dado por la formula

Y cómo aplicando la Ley de Ohm al circuito completo sabemos que V= I*(R1+R2), si despejamos I de esta ecuación no quedaría que I= V/(R1+R2), y sustituyéndolo en la ecuación anterior donde V2=I*R2, obtendremos que

Esto que estamos haciendo de forma manual con un polímetro conectado entre los extremos de la resistencia R2, también lo podríamos hacer gracias a los pines analógicos de nuestra placa Arduino.

Por ejemplo, imaginemos que no tenemos un polímetro a mano y queremos conseguir una tensión de 2.5 voltios en nuestra placa, aunque sabemos que los únicas tensiones que suministra son de 5V y de 3.3V. Para ello con lo que hemos aprendido más arriba, podría ser suficiente poner dos resistencias de igual valor (por ejemplo 10K) y coger la tensión en el punto donde se unen ambas. Con ello teóricamente obtendríamos los 2.5voltios, pero para estar seguros de que no nos hemos equivocado, como tenemos una placa Arduino con 6 pines analógicos, conectaremos esa señal a un pin analógico e intentaremos medir el valor con un programita sencillo.

Esto lo podríamos esquematizar de la siguiente manera

Ahora solo nos queda ver cómo podemos ver el valor de voltaje que está midiendo nuestro Arduino. Para ello tendremos que usar una función que se llaman analogRead(), que solo requiere que le pasemos un parámetro (el pin que estemos usando) y te devolverá un valor entero comprendido entre 0  y 1023. El 0 representará a 0 voltios y el 1023 a 5 voltios.

Para entender el porqué de esta traducción de números, es mejor que repaseis el capítulo dedicado a al convertidor analógico digital.

De forma resumida podemos decir que en los pines analógicos de nuestro Arduino UNO, tenemos unos convertidores Analógicos Digitales (ADC) de 10 bits, esto es, que son capaces de trocear los 5 voltios máximos de tensión que son capaces de medir en 2 elevado a 10, o lo que es lo mismo 1024 trocitos.

Ahora solo nos queda escribir un pequeño código para que podamos ver en pantalla, el valor que estamos registrando por el PIN analógico seleccionado (en nuestro ejemplo el A0). Que debería ser algo parecido a 511 (el valor entero más proximo a dividir 1023 entre 2).

Pues bien esto mismo que hemos aprendido aplicándolo a un divisor de tensión, lo podríamos aplicar para medir la tensión de cualquier sensor analógico que tengamos a mano. Solo necesitaríamos que nos suministrara una tensión comprendida entre 0 y 5 voltios, y conectarlo al PIN analógico donde querramos registrar los valores. Algo similar lo podemos simular reemplazando el sensor con un potenciómetro.


Por lo que si ahora conectamos un cable a un pin analógico de nuestra placa Arduino, como pudiera ser cualquiera de los marcados como "Analog In"

podremos leer la señal analógica  a través de un PIN analógico seleccionado.

Y ya sabéis, si tenéis alguna sugerencia o duda, no tenéis más que mandarnos un correo a

e intentaremos responder a vuestra pregunta lo antes que podamos.