El editor

El editor de código y la compilación

Un proyecto por placa, un clang real corriendo en la pestaña y diagnósticos en los que puedes hacer clic.

Un proyecto por placa

El panel de la derecha es una estación de trabajo, no un cuadro de texto. Cada placa del diagrama se programa por separado y tiene sus propios archivos: un sketch, más los headers y fuentes adicionales que agregues, tal como un proyecto real. Un selector de placas en la parte de arriba elige qué placa estás viendo; debajo hay una franja de archivos con pestañas y botones para agregar, renombrar y eliminar un archivo.

Los archivos viajan con el diagrama. Se guardan junto a él asociados al id de la placa, se exportan e importan con él y se eliminan con la placa.

Un diagrama sin ninguna placa sigue teniendo un sketch, para que puedas escribir código antes de decidir qué lo va a ejecutar. Los nombres de archivo pueden tener letras, dígitos, _, . y -, y todo lo que termine en .ino, .c, .cpp, .cc, .h, .hpp o .hh recibe resaltado de C++.

Ocultar el panel de código

Cuando el lienzo y el código están uno al lado del otro, el botón en el extremo derecho del encabezado del panel de código lo pliega y el lienzo ocupa todo el ancho. Queda una barra delgada de Código en el borde derecho del lienzo: haz clic en ella para recuperar el código con el ancho que tenía. Ctrl+\ (Cmd+\ en una Mac) hace ambas cosas, sin importar dónde esté el foco, incluido el código.

Tu navegador recuerda la elección, así que el código queda plegado la próxima vez que abras el editor. En una ventana más angosta, donde el lienzo y el código están apilados, y en un celular, el panel de código se queda donde está.

Pestañas de ensamblador

Una pestaña que termina en .S o .s es ensamblador, y se compila y enlaza con las pestañas .ino y .cpp de la misma placa, así como el IDE de Arduino compila una junto a un sketch. Un .S pasa primero por el preprocesador de C, así que #include <avr/io.h> y #define funcionan en él; un .s se ensambla tal como está escrito. C y ensamblador se llaman entre sí mediante extern "C", y las pestañas de ensamblador tienen su propio resaltado y el mismo margen de puntos de interrupción que un sketch.

Una placa también puede ser todo un proyecto de ensamblador sin núcleo de Arduino: elige una plantilla en Ensamblador (sin Arduino) en la sección de Firmware de las propiedades de la placa, en el Uno, el Nano, el Pro Mini, el Pico o la STM32F411 Black Pill. Escribir ensamblador cubre ambos casos, las convenciones de llamada, avr/io.h en un .S, asm volatile en línea y qué significan los errores.

Writing code

El panel de código edita como lo hace un editor de código de escritorio, Sublime Text en particular, y las teclas son las que sus usuarios ya conocen. Todas están listadas en Atajos de teclado.

  • Completion as you type. The list offers the Arduino calls of the board the files belong to (pinMode, digitalWrite, analogRead, millis, the pin names), the C and C++ keywords, and the names the project already uses. After a dot it offers the object's methods: Serial. lists print, println, available and the rest, and lcd. lists what a LiquidCrystal_I2C lcd(...) declared in the file can do. After #include < it lists the libraries the board can compile.
  • Solo nombres que compilan. La lista se lee de los headers que el compilador mismo usa para esa placa, así que un ESP32 ofrece ledcAttach y un Uno no, y las clases de una biblioteca aparecen cuando el archivo la incluye. Una prueba compila cada sugerencia en cada placa.
  • Snippets. setup writes both setup() and loop(); for, if, ifelse, else, switch, while and do write the whole block. Tab moves to the next blank to fill in.
  • Varios cursores. Ctrl/Cmd+D selecciona la palabra y luego su siguiente coincidencia, Alt y un clic agrega un cursor, y Alt y un arrastre selecciona una columna.
  • Buscar y reemplazar, con expresiones regulares, ir a la línea, búsqueda y cierre de llaves y paréntesis, plegado, comentar o descomentar, duplicar y mover líneas, y un Enter que indenta la línea siguiente sin dejar espacios al final.
  • Auto Format. Ctrl/Cmd+T, como en el Arduino IDE, o Ctrl/Cmd+Shift+F indenta de nuevo el archivo abierto, dos espacios por nivel, y no toca cadenas ni comentarios. En una ventana normal del navegador Ctrl/Cmd+T abre una pestaña nueva, así que Ctrl/Cmd+Shift+F es el que conviene aprender. Atajos de teclado tiene los detalles.
  • Las líneas largas se ajustan al borde del panel, bajo su propia indentación, así que un comentario largo nunca empuja el inicio del código fuera de la vista. Alt+Z desactiva el ajuste, y el editor lo recuerda. En un celular las líneas se mantienen enteras y el código se desplaza a un lado con el tamaño que cabe en el archivo.
  • Errores en el código. Después de una compilación, cada error y advertencia del compilador queda subrayado en su línea. Señálalo para leer el mensaje, presiona F8 para ir al siguiente, o Ctrl/Cmd+Shift+M para la lista. La siguiente compilación los borra.

Qué pasa cuando presionas Ejecutar

A cada placa se le hace una sola pregunta: ¿esto necesita compilarse? Hay tres respuestas.

  • Ejecutar la imagen tal cual. Un ELF cargado no se compiló a partir de estos archivos, y un ejemplo integrado sin modificar ya está compilado.
  • Reutilizar la última compilación. La decisión es un hash de cada nombre de archivo y de cada byte que contiene, así que una tecla y un deshacer te dejan exactamente donde estabas.
  • Compilarlo. Compilar y luego ejecutar el resultado.

La compilación en sí es un clang real y un lld real, compilados a WebAssembly y corriendo en un Web Worker, así que una primera compilación de cuatro segundos nunca le cuesta un cuadro al lienzo. No se sube nada y no hay servidor de compilación, ni cola, ni minutos de compilación.

La primera compilación, y todas las que siguen

El conjunto de herramientas son unos setenta megabytes de clang, transmitidos una vez desde nuestro propio almacenamiento y luego guardados en la caché del navegador. La primera compilación en un navegador nuevo tarda unos segundos; una visita de regreso toma un segundo y medio, y editar y ejecutar después de eso toma más o menos dos décimas de segundo.

Junto con él viene el runtime: nuestro propio C y C++ independiente para esa familia de placas, con los mismos headers, código de arranque, script del enlazador y opciones que usa el propio script de compilación del repositorio. Por eso un sketch que incluye uno de los controladores compartidos compila en cualquier placa que los tenga.

El lenguaje Arduino, en todas las placas

El runtime es propio de Mokxi, pero habla el lenguaje de la referencia de Arduino: un sketch copiado de un tutorial usa aquí las mismas llamadas que en una placa real.

  • Punto flotante. La aritmética con float y double funciona en todas partes, con una biblioteca de punto flotante por software en el runtime, como en un Uno real, donde el chip tampoco tiene hardware de punto flotante. double es de 32 bits en las placas AVR (Uno, Nano, Mega, Leonardo, ATtiny85), igual que en el núcleo Arduino AVR, y de 64 bits en las demás. Serial.print(x, 3) imprime tres decimales.
  • The math library. sqrt, pow, sin, cos, tan, atan2, log, exp, floor, round and the rest of math.h, plus PI, radians(), degrees(), map() and constrain(). Include <math.h> or not; either works.
  • String. Arduino's String class: + and +=, indexOf, substring, toInt, toFloat, trim, replace and the rest. Its text lives on the heap, which on an Uno is whatever of its 2 KB the sketch leaves free, so building long Strings in a loop runs out here as it does on the bench.
  • Leer del puerto serie. parseInt, parseFloat, readString, readStringUntil, readBytes, find y setTimeout, y una función serialEvent() se llama entre loop()s cuando llega una entrada.
  • Medir un pulso. pulseIn y pulseInLong devuelven la duración de un pulso en microsegundos, 0 si se agota el tiempo, que es como se lee un HC-SR04. shiftIn y shiftOut desplazan un byte hacia adentro o hacia afuera.
  • Sonido. tone(pin, frequency) y tone(pin, frequency, duration) reproducen una onda cuadrada desde una interrupción de temporizador sin detener el sketch, y noTone(pin) la detiene. En un Uno usa el temporizador 2, igual que el núcleo de Arduino, así que el PWM en los pines 3 y 11 se pausa mientras suena una nota. En el XIAO y el Uno R4, una nota suena en los pines PWM. #include "pitches.h" da los nombres NOTE_.
  • La biblioteca de C. sprintf, snprintf, atoi, atof, strtol, strcpy, strcmp, strtok, dtostrf, itoa, malloc y similares. Como en un Uno real, %f en sprintf imprime ? en las placas AVR; usa dtostrf ahí.
  • Caracteres. isDigit, isAlpha, isSpace, isUpperCase y el resto.
  • std::atomic. #include <atomic> funciona en todas las placas cuyo núcleo Arduino real lo tiene: las placas ESP32 y ESP8266, las placas RP2040, las placas STM32, el Uno R4, el XIAO SAMD21 y el micro:bit. load, store, fetch_add, compare_exchange, atomic_flag y las barreras se ejecutan. El núcleo de las placas AVR no tiene <atomic>, así que en un Uno, Nano, Mega, Leonardo o ATtiny85 la compilación se detiene, igual que en el Arduino IDE, con un mensaje que dice qué usar en su lugar: una volatile variable con noInterrupts() y interrupts() alrededor del código que la toca. ATOMIC_BLOCK de <util/atomic.h> también funciona en las placas AVR.

El ATtiny85 tiene 8 KB de flash y sus llamadas solo alcanzan 4 KB, así que un sketch que arrastra la biblioteca matemática o mucho punto flotante a menudo le queda grande, aquí igual que en el banco de trabajo.

Arduino libraries that compile as they are

Pega un tutorial y sus includes funcionan: el runtime lleva las bibliotecas comunes que más usa la gente, con sus nombres de siempre. Cada una es un header propio de Mokxi, escrito sobre los controladores de los componentes de la caja; nada de eso es código de la biblioteca original, y cada una conserva las llamadas que usan los tutoriales.

La tabla es el puñado que más usan los tutoriales, no la lista completa. Escribe #include < en el editor para ver todas las bibliotecas que la placa en la que estás puede compilar.

Header Qué controla Placas
Servo.h, ESP32Servo.h un servomotor de pasatiempos en cualquier pin todas las placas que compilan
Wire.h I2C como maestro, en los pines I2C propios de la placa o en cualesquiera dos todas las placas que compilan
SPI.h SPI en los pines SPI propios de la placa todas las placas que compilan
EEPROM.h read, write, update, get, put, EEPROM[i] todas las placas que compilan
LiquidCrystal_I2C.h the 16x2 LCD behind its I2C backpack todas las placas que compilan
Adafruit_GFX.h, Adafruit_SSD1306.h la OLED I2C de 128x64 todas menos la ATtiny85
Adafruit_NeoPixel.h WS2812 strips and panels placas AVR, familia ESP32, Pico, Uno R4
DHT.h el DHT11 y el DHT22 todas las placas que compilan
OneWire.h, DallasTemperature.h termómetros DS18B20, cualquier cantidad en un pin todas menos la ATtiny85
Adafruit_BME280.h, Adafruit_BMP280.h, SparkFunBME280.h los sensores de presión de Bosch todas menos la ATtiny85
RTClib.h los relojes DS3231 y DS1307, DateTime y TimeSpan todas menos la ATtiny85
Adafruit_INA219.h el monitor de corriente INA219 todas menos la ATtiny85
Adafruit_ADS1X15.h el ADC de dieciséis bits ADS1115 todas menos la ATtiny85
Adafruit_MCP23X17.h el expansor de puertos MCP23017 todas menos la ATtiny85
SoftwareSerial.h un puerto serie en dos pines comunes, para un HC-05 o un GPS Uno, Nano, Pro Mini, Mega, Leonardo, Pro Micro, ESP8266, ESP32, ESP32-S3
TinyGPS++.h NMEA del GPS NEO-6M probado en el Uno, el Mega y el NodeMCU

En lo que difieren de las bibliotecas originales, que la página de ayuda de cada componente detalla:

  • Servo envía un pulso por cada write() en lugar de pulsar desde un temporizador. Sus anchos son los de la biblioteca original: attach(pin) va de 544 a 2400 microsegundos, write(90) es 1472, y attach(pin, min, max) define otra ventana. Los valores predeterminados del componente de servo son los mismos, de 544 a 2400.
  • EEPROM es la EEPROM propia del chip en el Uno, Nano, Mega, Leonardo y ATtiny85, y 4 KB de RAM en todas las demás placas, cuyos modelos no tienen nada escribible que sobreviva a un reinicio. Un Ejecutar nuevo arranca borrada de cualquier forma.
  • La fuente de la pantalla de las pantallas Adafruit GFX es la 5x8 propia de Mokxi, con minúsculas, en la celda de 6x8 de la original. setFont() dibuja exactamente la fuente que lleva el sketch, y los headers de Fonts/ son las letras de Mokxi al tamaño de cada fuente, no los tipos GNU FreeFont.
  • DHT devuelve floats construidos con las décimas completas del sensor. Se imprimen, isnan y computeHeatIndex funcionan, y también cualquier operación aritmética propia sobre ellos.
  • Wire es solo maestro, y por software, como todos los buses aquí.
  • SoftwareSerial en las placas AVR funciona como la biblioteca de Arduino: una interrupción de cambio de pin y bucles contados, un puerto escuchando a la vez, semidúplex, un búfer compartido de 64 bytes. Recibir necesita un pin con interrupción de cambio de pin, que en un Mega son 10 a 15, 50 a 53 y A8 a A15. En el ESP8266, ESP32 y ESP32-S3 es al estilo EspSoftwareSerial: flancos medidos en una interrupción, así que varios puertos reciben a la vez. Solo 8N1. Cualquier otra placa lo avisa al compilar.
  • Las bibliotecas de sensores devuelven floats igual que DHT, construidos con las cuentas propias de los chips. DEVICE_DISCONNECTED_C se compara con una lectura como lo hacen los tutoriales, y el readPressure() / 100.0F de los tutoriales de presión funciona tal cual; readPressureHPa() también está ahí.

El artículo de ayuda de cada placa indica qué pines usa Wire.begin() en ella.

Agregar una biblioteca

Tres franjas debajo del código se encargan de las bibliotecas, y agregar una es gratis en todos los planes:

  • Libraries muestra las bibliotecas propias del proyecto, cada una con un botón para quitarla. + Add library acepta un .zip con la estructura de Arduino, o archivos .h y .cpp sueltos, e indica qué archivos conservó y cuáles omitió, como los ejemplos.
  • Arduino Library Manager: todas las bibliotecas, un toque. Pulsa Search y escribe un nombre, un header o una palabra sobre ella. Cada resultado tiene Install, que la descarga junto con las bibliotecas de las que depende. Una biblioteca que Mokxi ya trae integrada dice Built in, una del proyecto dice Installed, y una que no incluye la placa que estás editando se instala con una advertencia.
  • Bibliotecas integradas. Pulsa Browse para buscar las bibliotecas que trae Mokxi, con This board only para quedarte solo con lo que compila en tu placa. Add #include pone el header de la biblioteca al inicio del archivo abierto (o avisa que ya está), y Details muestra sus headers y Open example.

Un sketch que incluye una biblioteca que el proyecto no tiene se detiene en el file not found de clang. La pestaña Compilación entonces nombra el header de Mokxi que hace el mismo trabajo, u ofrece Install para la biblioteca desde Arduino Library Manager, que la coloca en el proyecto y vuelve a compilar.

Python en el Pico, el ESP32 y la Raspberry Pi

Estas placas pueden ejecutar Python en lugar de un sketch. La elección está en la lista de program en la sección Firmware de las propiedades de la placa:

  • Raspberry Pi Pico. Elige MicroPython (main.py) y escribe main.py. Run arranca el firmware oficial de MicroPython en el chip simulado y copia tus archivos .py en él, como lo hace Thonny. print() se muestra en el monitor serie. La Pico W hace lo mismo con su propia versión, con network.WLAN en la red simulada. Consulta la Pico y la Pico W.
  • las placas ESP32. La misma opción arranca el firmware oficial de MicroPython para el chip, con network.WLAN en la red simulada, en el ESP32 clásico (DevKit V1, DevKitC, LOLIN32 Lite), el ESP32-S3 (con la XIAO ESP32-S3 y la Nano ESP32), el ESP32-C3 (con la XIAO ESP32-C3 y la SuperMini) y el ESP32-C6 (con la XIAO ESP32-C6). El ESP8266 no tiene MicroPython aquí. Consulta MicroPython en el ESP32.
  • CircuitPython en la Pico, la Pico W, la Arduino Nano RP2040 Connect y la ESP32-S3. Elige CircuitPython (code.py) y escribe code.py. Ejecutar arranca el firmware oficial de CircuitPython y guarda code.py en la unidad CIRCUITPY de la placa, junto con las bibliotecas de Adafruit que importa. Consulta CircuitPython en la Pico.
  • Raspberry Pi 4, Pi 5 y Zero 2 W. La placa recibe un main.py, y Ejecutar lo inicia con gpiozero y RPi.GPIO manejando el header. No hay Linux debajo. Consulta la Raspberry Pi.

La pestaña Compilación

Debajo de la tira de archivos. Se mantiene fuera del camino hasta que haya algo que decir, y entonces muestra tres cosas: los pasos con sus tiempos, para que una primera compilación lenta se lea como progreso y no como un cuelgue; los diagnósticos del compilador como líneas en las que puedes hacer clic para llegar al archivo, la línea y la columna de los que se queja; y una frase sencilla al final, como Compilado esp1.elf, 1.5 KB, 0.21 s.

Una sola herramienta de compilación para todas las placas

Cada placa se compila en el navegador con la misma herramienta clang, cada una para su propio chip: los Arduinos AVR como el Uno (avr -mmcu=atmega328p), las placas ESP32 con RISC-V como el ESP32-C3 (riscv32 -march=rv32imc), y las placas Arm como la Pico (thumbv6m, Cortex-M0+) y la STM32F411 (thumbv7em, Cortex-M4, coma flotante por software). La página de placas las enumera todas.

El detalle completo, hasta la lista de comandos y las claves de la caché, está en compilar en el navegador.

Si una compilación falla, el sketch no compila te guía por lo que te dice la pestaña Compilación.