La forma más rápida: mokxi.com/ delante de un enlace
Escribe mokxi.com/ delante de un enlace de Wokwi, CircuitJS, GitHub, gist, GitLab, Bitbucket, Codeberg, sitio de pegado, Dropbox, Google Drive, Instructables, Arduino Project Hub, Hackster o un enlace compartido de Arduino Cloud en la barra de direcciones de tu navegador, por ejemplo mokxi.com/wokwi.com/projects/322062421191557714, y presiona Enter. El editor se abre con ese proyecto importado. No se necesita cuenta. Un enlace de Tinkercad lleva a la página de importación en su lugar, con los pasos para Tinkercad. Un enlace de Cirkit Designer no funciona así: pégalo en la página de importación.
Dónde importar
Open the página de importación, o en el editor abre la ▾ beside
Save and choose Import a project. You can also paste a project link, a
diagram.json or a sketch anywhere on the canvas, or drop files, a folder or
a zip straight onto the editor. Mokxi works out what the project is from what
is inside it, not from its name.
Qué pasa cuando se abre
- El proyecto que tenías abierto se conserva. Deshacer en la línea de resumen de la importación lo devuelve, y Guardar ▾ > Volver a mi último proyecto lo abre más tarde.
- La línea de resumen dice qué pasó. Presiónala para el reporte completo: qué se convirtió en una nota en el lienzo, y qué falta (conexiones, archivos y bibliotecas), cada uno con su razón.
- Los componentes que Mokxi no tiene se convierten en notas rosas donde estaban, y una línea de "Omitido:" en el reporte nombra cada uno.
- Los cables se acomodan por ti. Donde la fuente dibujó sus cables (Wokwi, Cirkit, muchos archivos de Fritzing), siguen la misma ruta. Donde no (un esquemático, una netlist, un archivo de placa de Tinkercad), una importación de hasta 30 cables se acomoda con Ordenar cables al abrirse. Una más grande conserva cables rectos: presiona T para ordenarlos.
- Mokxi AI puede terminarlo. Cuando algo quedó fuera, la línea de resumen ofrece Pedir a Mokxi AI que lo termine. Mokxi AI propone el componente de Mokxi más cercano para cada nota, con sus pines cableados, y la biblioteca que instalar o el
#includeque cambiar para cada uno que falta. Cada componente y pin se verifica primero contra el catálogo real. Nada cambia hasta que presionas un botón en una línea (Agregar al lienzo, Instalar, Cambiar el include), y cada presión es un paso de Deshacer. - Cuéntanos envía de dónde vino el proyecto y qué faltaba (nunca tu código). Una persona real lee cada reporte. Una importación que falla ofrece Intentar de nuevo cuando otro intento podría ayudar.
Fuentes en esta página
Wokwi, Cirkit Designer, GitHub, GitLab, Bitbucket y Codeberg, sitios de pegado, Dropbox y Google Drive, Instructables, Project Hub, Hackster y Arduino Cloud, Fritzing, SimulIDE, KiCad, EasyEDA, Qucs y gEDA, Falstad CircuitJS, Tinkercad, PlatformIO, el IDE de Arduino, un archivo .hex compilado, un enlace de Mokxi, texto pegado, una foto, LTspice, y Proteus, Multisim y CircuitMaker.
Desde Wokwi
Full guide: Importar un proyecto de Wokwi, con un enlace que abre ya importado.
¿Nuevo en Mokxi y vienes de Wokwi? Coming from Wokwi coloca cada idea de Wokwi junto a su nombre aquí, y te dice qué cambia.
Usa cualquiera de estas opciones:
- Un enlace. Pega el enlace de un proyecto público, como
https://wokwi.com/projects/322062421191557714. El servidor de Mokxi descarga los archivos del proyecto desde wokwi.com, y solo desde ahí, y tu navegador los lee. De un proyecto privado nadie puede descargarlo más que tú: ábrelo en Wokwi, descarga el zip del proyecto y suéltalo aquí. - Los archivos. Suelta o elige
diagram.json, el sketch (sketch.inoo como se llame), cualquier pestaña extra.hy.cpp, ylibraries.txt. - El zip. El zip del proyecto descargado de Wokwi funciona tal cual.
Lo que se transfiere:
- Componentes. Placas, LEDs, resistencias, botones, interruptores deslizantes, potenciómetros, servos, zumbadores, LCDs de caracteres (con o sin el módulo I2C), OLEDs, NeoPixels, anillos y tiras, pantallas de siete segmentos y TM1637, matrices MAX7219, pantallas ILI9341, el HC-SR04, DHT22, PIR, DS18B20, MPU6050, DS1307 y HX711, teclados, codificadores rotatorios, joysticks, relés, drivers y motores a pasos, registros de corrimiento, tarjetas microSD y compuertas lógicas se convierten en el componente de Mokxi correspondiente, con su color, valor, dirección I2C y cantidad de píxeles.
- Cables. Cada conexión entre dos componentes que tienen equivalencia se convierte en un cable, con los nombres de los pines traducidos (
GND.2es el segundo pin GND de la placa,V+en un servo es VCC, y así sucesivamente) y el color de cable de Mokxi más cercano. Un cable sigue la ruta dibujada en Wokwi; uno sin ruta recibe una sola esquina. Presiona Ordenar cables para enrutarlos alrededor de los componentes. - Protoboards. Un componente conectado a una protoboard de Wokwi queda conectado en los mismos orificios de una protoboard de Mokxi. Cuando el componente de Mokxi tiene un tamaño distinto (aquí una resistencia es más corta), una pata queda en su orificio y las demás se cablean a los suyos.
- Etiquetas. Una etiqueta de texto de Wokwi se convierte en una nota adhesiva.
- Código. El sketch y sus pestañas se convierten en los archivos de la placa.
Qué no, y cómo se te informa:
- Custom chips come across as parts that run their own code when the
chip's files come with them (
<name>.chip.jsonand<name>.chip.c, a barechip.jsonandchip.c, a chip in a folder of its own, or a builtchip.wasm), or whendiagram.jsonnames them underdependencies. See chips personalizados. El código de un chip nunca se convierte en una pestaña del sketch de la placa. Un chip cuyos archivos faltan es una nota rosa, y el reporte dice qué faltaba, como un.chip.cthat came without its.chip.json. - Los componentes que Mokxi aún no tiene se convierten en una nota rosa en el lienzo donde estaba el componente, con su nombre. Sus cables se listan en el reporte.
- Las conexiones del monitor serie de Wokwi se omiten: el monitor serie de Mokxi siempre está conectado a la placa.
- Los proyectos de MicroPython se ejecutan en la Raspberry Pi Pico y las placas clásicas ESP32 (la DevKit V1, la DevKitC y la LOLIN32 Lite). En otras placas los archivos
.pyse conservan como texto pero no se ejecutan. - Los proyectos de CircuitPython (un
code.py) se ejecutan en la Raspberry Pi Pico y la Arduino Nano RP2040 Connect, con el firmware oficial de CircuitPython. En otras placas elcode.pyse conserva como texto, y el reporte explica por qué.
Desde Cirkit Designer
Full guide: Abrir un enlace de proyecto de Cirkit Designer, con la lista de componentes y los pasos.
Pega el enlace de un proyecto compartido (https://app.cirkitdesigner.com/project/<id>, con o sin número de versión al final) en la página de importación o en el lienzo. El servidor de Mokxi descarga el archivo del proyecto desde Cirkit, y solo desde allí, sin iniciar sesión. Un proyecto que no esté compartido no se puede leer.
- Componentes. El Arduino Uno, Nano y Mega, el ESP32 y ESP32-S3, la Raspberry Pi Pico, los LEDs y LEDs RGB, las resistencias con su valor, los pulsadores, los zumbadores, los servos, los potenciómetros, el DHT11 y DHT22, el HC-SR04, las OLED SSD1306, las LCD 16x2 (con o sin I2C), los relés, el 74HC595, el L298N, el DS18B20, el MPU6050, los receptores IR, los sensores PIR, los módulos sensores de luz, los teclados, los NeoPixels, anillos y tiras, las pantallas TM1637 y MAX7219 y las pantallas de siete segmentos.
- Los cables siguen las rutas dibujadas en Cirkit.
- Código. El sketch de una placa llega a esa misma placa.
- Cualquier otra cosa se convierte en una nota rosa con su nombre, y el reporte la lista.
Desde GitHub
Full guide: GitHub a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Pega un enlace a un repositorio público, una carpeta dentro de uno, un solo archivo .ino o un gist. Un proyecto de PlatformIO o una carpeta de sketch de Arduino llega con su código y su lista de bibliotecas. Un enlace a un platformio.ini, o a un archivo en una carpeta src/ de PlatformIO, trae todo el proyecto que lo rodea. El servidor de Mokxi descarga proyectos públicos solo de GitHub, no envía ningún inicio de sesión y limita el tamaño (10 MB para un repositorio, 2 MB para un archivo o un gist). Para un repositorio privado, descarga el zip de GitHub y arrástralo en su lugar.
Desde GitLab, Bitbucket y Codeberg
Igual que con GitHub: pega el enlace a un repositorio público, una carpeta dentro de uno o un solo archivo de sketch en gitlab.com, bitbucket.org o codeberg.org. Mokxi lee el zip del repositorio que crea el propio sitio (10 MB como máximo) y abre la carpeta que enlazaste, o el archivo (2 MB como máximo). Los repositorios privados requieren iniciar sesión, algo que Mokxi nunca envía, así que descarga el zip allí y arrástralo en su lugar.
Desde un sitio de pastes
Pega el enlace a un paste en pastebin.com, paste.ee, dpaste.org o hastebin.com. Mokxi descarga su texto sin formato y lo lee como lee cualquier cosa pegada: un sketch, un diagram.json, una exportación de CircuitJS. Un paste que el sitio guarda tras un inicio de sesión (hastebin.com ya lo pide) no se puede leer; copia su texto y pégalo directamente.
Desde Dropbox y Google Drive
Un enlace a un archivo o carpeta de Dropbox, y un enlace a un archivo de Google Drive, funcionan cuando cualquier persona con el enlace puede abrirlos sin iniciar sesión. Una carpeta de Dropbox llega como el zip que Dropbox crea de ella y se lee como un zip arrastrado. Una carpeta de Drive, un Google Doc, un archivo que te pida iniciar sesión y un archivo demasiado grande para que Drive lo analice en busca de virus no se pueden leer: Mokxi te lo avisa, y puedes descargar el archivo y arrastrarlo en su lugar. Los archivos están limitados a 2 MB y los zips a 10 MB.
Desde Instructables
Pega la dirección del proyecto (instructables.com/<Project-Name>/). Mokxi lee los enlaces de archivos adjuntos de la página y abre los archivos .ino, .zip y .fzz adjuntos, además de cualquier adjunto .txt que contenga código. Solo lee instructables.com y su servidor de archivos, y como máximo ocho adjuntos, 8 MB en total. Un proyecto sin archivos adjuntos no tiene nada que leer: copia el código de sus pasos y pégalo.
Desde Arduino Project Hub, Hackster y Arduino Cloud
Full guides: Arduino Project Hub, Hackster and Arduino Cloud, cada una con los pasos y lo que lee la página.
Pega la dirección de la página de un proyecto (projecthub.arduino.cc/<user>/<project> o hackster.io/<user>/<project>). Mokxi lee el código pegado en la página (su sección de código, y cualquier bloque en la historia que sea un sketch) y los archivos .ino, .zip, .fzz, .h, .cpp y .txt de código adjuntos. El primer sketch se abre como <project>.ino; otros bloques de código se convierten en sus pestañas, y un segundo sketch completo (las páginas suelen mostrar dos versiones) se guarda como pestaña .txt. Los comandos de shell y las tablas de componentes se omiten. Cuando la página no tiene código propio pero enlaza a GitHub, Mokxi abre el proyecto de GitHub al que enlaza. El hardware que la página lista aparece como nota en el reporte, no como componentes: colócalos tú mismo. Los esquemas y fotos de protoboard, los archivos de impresión 3D y los videos no pasan. Mokxi solo lee el sitio propio de la página y su servidor de archivos, como máximo ocho archivos, 8 MB en total.
Un sketch compartido de Arduino Cloud (un enlace de app.arduino.cc/sketches/<id>, o un enlace de create.arduino.cc/editor/.../preview desde Compartir sketch) se abre con sus archivos de código, cuando su dueño lo configuró como Público: cualquier persona con el enlace puede ver el sketch. Un sketch privado no se puede leer sin iniciar sesión: descárgalo ahí (Descargar sketch, que da un zip) y suelta el zip en la página de importación.
Desde Fritzing
Full guide: De Fritzing a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Suelta el archivo .fzz (Archivo, Guardar en Fritzing escribe uno). Es un zip que contiene el sketch y el código de la pestaña Code de Fritzing, y ambos pasan. Un .fz sin acompañar también funciona, con el .ino soltado a su lado.
- Qué se lee. La vista de protoboard: cada componente, dónde está colocado, cada cable y las tiras de la protoboard. Las vistas de esquemático y de PCB no se leen, porque un cable dibujado solo ahí nunca estuvo en la protoboard; el reporte cuenta los componentes que están solamente ahí.
- Componentes. La biblioteca principal de Fritzing: el Arduino Uno, Nano y Mega 2560, resistencias con su valor, LEDs con su color, LEDs RGB, pulsadores, interruptores de palanca, de inclinación y reed, potenciómetros, capacitores cerámicos y electrolíticos, diodos y zener, transistores NPN y PNP, un MOSFET de canal N, el regulador 7805, LDR, termistores, el LM35, FSR, el HC-SR04, el RHT03 (DHT22), bocinas piezo, servos, motores de corriente continua, la LCD 16x2, un display de siete segmentos, el 555, el 74HC595, el puente H L293D y baterías de 9 V y AA; también diodos, capacitores y reguladores de cualquier paquete, conectores DC, un chip que Mokxi tiene por su número de parte (un LM358, un 4N35, el IC genérico de Fritzing etiquetado 595), un ATmega168 o 328 sin más (corre como el Uno del que es el corazón), y las fuentes, el multímetro y el osciloscopio del simulador.
- Placas de tiras. Las tiras de cobre, y los cortes en ellas, se unen con cables de la misma manera que las tiras de una protoboard.
- Los headers de pines y las puntas de prueba son conectores, no componentes: se omiten, y los cables que se encontraban en ellos siguen encontrándose.
- Protoboards. La protoboard en sí no pasa. Los componentes de cada una de sus tiras se unen con cables en su lugar, lo que conecta exactamente los mismos pines.
- Notas. Las notas de Fritzing se convierten en notas adhesivas.
- Los componentes de otras bibliotecas, y los componentes personalizados, se convierten en una nota rosa con sus nombres.
Desde SimulIDE
Full guide: De SimulIDE a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Suelta el archivo de circuito: .sim1 de SimulIDE 1.0 en adelante, o .simu de versiones anteriores.
- Qué se lee. Cada componente, dónde está colocado y cómo está girado, cada cable, los nodos de unión y los túneles (dos túneles con el mismo nombre son una sola conexión). Las etiquetas de texto se convierten en notas adhesivas.
- Componentes. Resistencias, capacitores, inductores, LEDs, diodos y zener, potenciómetros, LDR, termistores, tierra, voltajes fijos, rieles y baterías, BJT, MOSFET, amplificadores operacionales, el LM555, pulsadores e interruptores, motores de corriente continua, servos, el DHT22, el HC-SR04, la LCD HD44780, displays de siete segmentos, compuertas AND, OR y XOR de dos entradas, relojes, y el Arduino Uno, Nano y Mega (sus pines se leen por etiqueta, como
D13yA0); también chips 74xx y CD4000, arreglos de resistencias, barras de LEDs, displays de varios dígitos, compuertas con más entradas (como una cadena de compuertas de dos entradas), sondas, medidores, el osciloscopio y el analizador lógico, los displays Nokia 5110, SSD1306 e ILI9341, y un ATmega sin más (como el Uno). SimulIDE alimenta sus chips y displays sin cables, así que la importación les cablea la alimentación. - Código. SimulIDE guarda el sketch en su propio editor y carga un
.hexcompilado en la placa, mientras que Mokxi compila desde el código fuente, así que pon el.inoen la carpeta o el zip junto con el circuito. El informe indica cuándo solo estaba la ruta del.hex.
Desde KiCad
Full guide: De KiCad a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Suelta el esquemático: un .kicad_sch (KiCad 6 en adelante), el .kicad_pro o un zip de la carpeta del proyecto (Mokxi abre el esquemático raíz del proyecto), o el .sch de KiCad 4 y 5. También funciona copiar y pegar el texto del archivo.
- Qué se lee. Todos los símbolos, su posición, cómo están girados y reflejados, todos los cables y uniones, etiquetas, etiquetas globales y símbolos de alimentación. Las redes se forman como las forma KiCad: los extremos de cables, pines y etiquetas que se tocan se unen; un pin o etiqueta en medio de un cable se une a él; los cables que solo se cruzan no; y las etiquetas o símbolos de alimentación con el mismo nombre forman una sola red. Los pines de alimentación ocultos de un chip (como VCC y GND de un 74HC595) se unen a la red de su propio nombre, como en KiCad.
- Componentes. Arduino Uno, Nano y Mega, módulos ESP32, ESP32-S3, ESP32-C3 y Pico, resistencias, capacitores, inductores, LED y LED RGB, diodos y zener, potenciómetros, botones de dos pines, interruptores deslizantes de tres, transistores y MOSFET, zumbadores, baterías, chips 74xx y CD4000, el 555, amplificadores operacionales, reguladores lineales (78xx, AMS1117), NeoPixels, y los módulos comunes de sensores y pantallas por nombre. Los componentes de dos pines conservan la dirección con la que los dibuja el esquemático.
- Lo que queda como notas. Un símbolo sin un componente equivalente en Mokxi se convierte en una nota etiquetada donde estaba, y el informe lo lista con las conexiones que se llevó. Un componente se asigna solo cuando de verdad es ese componente: una matriz de diodos TVS no es un diodo, un motor de CA no es un motor de CC, un interruptor de cuatro pines o un SPST no es el interruptor de Mokxi, y un conector etiquetado como "OLED" sigue siendo un header de pines. Los headers de pines, puntos de prueba y agujeros de montaje son donde se conectan los cables, así que se dejan fuera y se nombran en el informe.
- Hojas dentro de hojas. Una subhoja cuyo archivo viene con lo cargado, y que se usa una sola vez, se lee y se une por sus etiquetas jerárquicas y los pines de hoja de su padre. Una subhoja que falte en lo cargado, o que se use más de una vez, se deja fuera y se nombra en el informe.
- Archivos antiguos. Un
.schde KiCad 4 o 5 no incluye sus símbolos, así que sus pines se encuentran en el-cache.libo.libque lo acompaña. Agrégalo a lo que subas. Sin él, los componentes quedan como notas y el reporte explica por qué; no se adivina ningún pin. - Código. Un esquemático no tiene. Agrega el
.inoa lo que subas y se cargará en la placa. - No se lee. Los buses (cables de bus, entradas de bus y etiquetas como
D[0..7]), el diseño de la placa (.kicad_pcb), los modelos de simulación y los símbolos marcados no se cargan. - Posiciones. Los componentes conservan sus posiciones relativas en la hoja. Los cables se ordenan con Ordenar al abrir el proyecto (hasta 30 cables); un esquemático más grande queda con cables rectos, de pin a pin, hasta que presiones Ordenar cables.
Desde EasyEDA
Full guide: De EasyEDA a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Abre el esquemático en el editor EasyEDA Standard, elige File, luego Export, luego EasyEDA Source, y suelta aquí el archivo .json (o pega su texto). Un enlace a un proyecto de EasyEDA u OSHWLab no se descarga: Mokxi te indica estos pasos en su lugar. Los proyectos de EasyEDA Pro (.epro) tienen otro formato y todavía no se leen. Los archivos de más de 1 MB se omiten, así que exporta solo el esquemático cuando un proyecto sea grande.
- Qué se lee. Cada componente con su designador, valor, paquete y pines; los cables; las uniones; las etiquetas de red; y las banderas de alimentación y tierra. Un archivo fuente de EasyEDA no tiene netlist, así que Mokxi encuentra las conexiones como las dibuja el editor: un cable une todo lo que esté a lo largo de él, y las etiquetas y banderas con el mismo nombre son una sola conexión, en todas las hojas. Las hojas se colocan una junto a otra.
- Componentes. Resistencias, capacitores, inductores, LEDs, diodos, transistores, interruptores, potenciómetros, módulos comunes y chips 74xx y CD4000, y placas tipo Arduino, por su designador, valor, paquete y nombres de pines (la misma tabla que usan los lectores de KiCad y SPICE). Un componente para el que Mokxi no tiene equivalente se convierte en una nota rosa con su nombre, y el informe lo lista.
- Pines. Un pin sin equivalente en el componente de Mokxi se lista en el informe y se deja sin conectar, nunca se adivina.
- No se lee. La placa (PCB) del mismo proyecto, los dibujos y texto de la hoja, y las bibliotecas de componentes. Un marco o logotipo sin pines se omite.
- Código. Un esquemático no tiene código. Agrega el
.inoa la subida y quedará en la placa.
Desde Qucs y gEDA
Full guides: Qucs and gEDA y Lepton EDA, cada uno con un esquemático de ejemplo que se abre aquí.
Suelta el esquemático, un archivo .sch. Mokxi lee lo que hay dentro para saber qué herramienta lo guardó: Qucs (y Qucs-S y QucsStudio, que guardan igual) o gEDA gschem (y Lepton EDA, que continúa con gEDA). También puedes pegar el texto del archivo en el cuadro.
- Componentes. Resistencias, capacitores, inductores, diodos y zeners, BJTs (NPN y PNP), MOSFETs, tierra, fuentes de voltaje de CD y fuentes senoidales, de ambas herramientas; de gEDA también LEDs, baterías, potenciómetros, botones pulsadores y símbolos de alimentación (
Vcc,+5V,+3.3V). Cualquier otra cosa se convierte en una nota adhesiva con su nombre, y el informe lo lista. - Pines y redes. Ninguno de los dos archivos indica dónde están los pines de un componente: Qucs los guarda en su programa y gEDA en el archivo
.symde cada símbolo. Mokxi conoce los pines de los componentes de arriba, y calcula dónde queda cada uno según cómo se gire y se refleje el componente. Los cables y redes que se cruzan se unen, las etiquetas de cables de Qucs y los nombres de red de gEDA con el mismo nombre forman una sola red, y los símbolos de alimentación de gEDA son redes con nombre. Un símbolo de gEDA incrustado en el esquemático trae sus propios pines, así que también se lee. - Se omite. Bloques de simulación (
.DC,.TR), ecuaciones, diagramas, directivas y modelos de SPICE, cajetines y dibujos: Mokxi ejecuta el circuito por sí mismo, así que coloca una sonda, medidor u osciloscopio donde quieras observar. Un valor que Qucs toma de una variable (R = Rload) recibe el valor predeterminado de Mokxi, y el informe indica cuál. - KiCad. Un
.schde KiCad es un formato distinto: consulta Desde KiCad más arriba.
Desde Falstad CircuitJS
Full guide: Falstad CircuitJS a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Usa cualquiera de estas opciones:
- Un enlace. Pega un enlace de CircuitJS con
?ctz=o?cct=, obtenido en File, Export As Link. El circuito está guardado en el propio enlace, así que Mokxi lo lee ahí y no descarga nada. - El texto. Pega el texto de File, Export As Text, o suelta un archivo de circuito guardado. Se leen tanto el formato de texto antiguo como el formato XML más reciente.
Lo que se transfiere: resistencias, capacitores, inductancias, fuentes y rieles de CD, fuentes senoidales, cuadradas, triangulares, de diente de sierra y de pulso (como generador), tierra, interruptores, diodos, zeners, LEDs con su color, transistores NPN y PNP, MOSFETs, amplificadores operacionales, potenciómetros, el 555, LDRs, termistores, motores de CD, compuertas lógicas (más de dos entradas se convierten en una cadena de compuertas de dos entradas), inversores, entradas y salidas lógicas, flip-flops D y JK, contadores, multiplexores y conmutadores analógicos (como chips 74HC y CD4000 con su alimentación), relés, lámparas, displays de siete segmentos y de números, y voltímetros y amperímetros (como un multímetro). Los nodos etiquetados unen cada nodo con el mismo nombre, y el texto se convierte en una nota adhesiva.
Dos cosas son diferentes en Mokxi, y el informe lo dice: un amplificador operacional de CircuitJS se alimenta sin cables, así que la importación le agrega una alimentación y una tierra; y CircuitJS no necesita símbolo de tierra, así que agrega uno donde esté el 0 V del circuito si no lo tenía. Todos los demás elementos (transformadores, líneas de transmisión, subcircuitos personalizados y similares) se convierten en una nota rosa con su nombre.
Desde Tinkercad
Full guide: De Tinkercad a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Tinkercad Circuits puede exportar un circuito como un archivo de placa, que contiene cada componente y cada cable. Con su código al lado, todo el proyecto se transfiere, cableado:
- El circuito. Abre el circuito en Tinkercad, presiona Export y descarga el archivo
.brd. - El código. Abre Code, cambia a Text y presiona el botón de descarga para guardar el
.ino(o selecciona todo y cópialo). - Suelta ambos en la página de importación o sobre el editor, juntos.
Mokxi coloca cada componente que tiene donde estaba: el Uno y el micro:bit, LEDs con su color, LEDs RGB, resistencias y potenciómetros con su valor, botones, interruptores deslizantes y DIP, piezos, servos, motores de CD y de engranajes, el TMP36, fotorresistencias y fototransistores, el HC-SR04, PIR, receptor IR, sensores de humedad, fuerza y gas, el teclado 4x4, LCDs 16x2 y I2C, displays de siete segmentos, NeoPixels, transistores, diodos, capacitores, la batería de 9 V y la fuente de alimentación, relés, el 7805, el L293D, el LM741, el 555, chips 74HC y el CD4511. Cada uno queda cableado como lo tenía Tinkercad, y el código va en la placa. La protoboard no se transfiere: sus tiras ya están en el cableado. Un componente que Mokxi no tiene (un sensor Parallax PING, por ejemplo) queda como una nota con su nombre, y el informe lo lista.
El archivo de placa no tiene código ni ajustes como el voltaje de una fuente de alimentación (se pone en 5 V) o una dirección I2C, así que el informe lo dice cuando importan.
¿No hay .brd? Copia la tabla Component List (o descárgala como CSV), pégala en el cuadro de importación con el código debajo, o suelta el .csv y el .ino juntos. Los componentes llegan en filas con sus valores, listos para que los cables.
Mokxi nunca lee las páginas de Tinkercad: un enlace de Tinkercad requiere iniciar sesión, así que la página de importación explica cómo exportarlo en su lugar.
Desde PlatformIO
Full guide: De PlatformIO a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Suelta la carpeta del proyecto, o un zip de ella, con platformio.ini en la raíz.
- La placa viene del entorno que compila por defecto (
default_envs, si no el primer[env:...]), suboardse lee igual a como lo escribe la exportación de PlatformIO, y puedes elegir otra. - El código.
src/main.cppse convierte en elsketch.inode la placa (su#include <Arduino.h>y sus declaraciones funcionan tal cual), y los demás archivos desrc/einclude/van a su lado. Los archivos en carpetas dentro desrc/no, porque un proyecto de Mokxi no tiene carpetas. - Bibliotecas. Cada entrada de
lib_depsse revisa como una línea delibraries.txtde Wokwi, y las bibliotecas propias del proyecto enlib/vienen junto con él como bibliotecas propias del proyecto. Una biblioteca que PlatformIO descarga desde una URL de Git se marca como faltante. - Otros frameworks. Mokxi compila sketches de Arduino; el informe lo dice cuando el proyecto usa otro framework, como ESP-IDF.
Desde el IDE de Arduino
Full guide: Abre un archivo .ino en línea, con la placa adivinada, el cableado que Mokxi agrega y un sketch de ejemplo.
Suelta un .ino, la carpeta completa del sketch, o un zip de ella, o pega el sketch en el cuadro de importación. Cada pestaña .ino, .h, .cpp y .c junto al sketch se transfiere. Los archivos en carpetas dentro del sketch (como src/) no, porque un proyecto de Mokxi no tiene carpetas: muévelos junto al sketch e inclúyelos por nombre.
Cuando la carpeta del sketch tiene un sketch.yaml (el IDE de Arduino 2 y arduino-cli) o un sketch.json (una descarga de Arduino Cloud), su placa viene de ahí, y sus bibliotecas se revisan, junto con la línea depends= de cada biblioteca en una carpeta libraries/. El thingProperties.h de un sketch de Arduino Cloud se conserva, pero una placa simulada no puede conectarse a Arduino IoT Cloud, así que sus variables de nube conservan sus valores iniciales.
Si no, el IDE de Arduino no registra la placa, así que Mokxi la adivina a partir del sketch: WiFi.h o ledcWrite significa un ESP32, ESP8266WiFi.h un ESP8266, Serial1 o el pin 40 una Mega, A7 una Nano, y así. Elige la correcta en la lista Board antes de abrir.
Un sketch llega sin circuito, así que Mokxi cablea uno según lo que dice el código: las bibliotecas que incluye (Servo, DHT, LiquidCrystal_I2C, Adafruit_SSD1306, Adafruit_NeoPixel y otras) y los pines que configura y usa. Un LED recibe su resistencia de 220 ohm. El resumen dice qué se cableó, como "Cableamos: servo en el 9, LED en el 13 (con 220 ohm)"; mueve o recablea lo que difiera de tu circuito. Cuando el código no dice nada sobre lo conectado, el proyecto empieza con solo la placa, lista para que la cables. Para responder la publicación de alguien en un foro con su código corregido y funcionando, usa mokxi.com/fix (ver Ayuda a alguien a corregir su código).
Desde un archivo .hex compilado
Drop a compiled program, the .hex file the Arduino IDE saves with
Sketch, Export Compiled Binary, or one somebody sent you, and it runs
as it is: the project opens with the board alone, running that program as the
one uploaded in its panel Firmware. Empieza en el Uno, o en el Mega 2560 cuando el programa es demasiado grande para un Uno. Un .hex does
not say which board it was built for, so pick the right one from the Board
list before opening: the list offers the AVR boards whose flash holds it (Uno,
Nano, Mega 2560, Leonardo, Pro Mini and ATtiny85). When the Arduino IDE saved
two, the one without with_bootloader in its name is used.
Un programa compilado no tiene código para editar. Conecta componentes a sus pines como siempre; para cambiar lo que hace, importa en su lugar el sketch del que se compiló.
Un enlace de Mokxi
Un enlace de Mokxi pegado en el cuadro de importación, como mokxi.com/p/... o un enlace compartido del editor de app.mokxi.com, ya es un proyecto de Mokxi, así que no hay nada que importar: el cuadro lo dice y lo abre.
Pegar
La caja de importación lee lo que pegan los asistentes de chat y los foros: código dentro de bloques de Markdown (```), un diagram.json de Wokwi y su sketch en dos bloques de una misma respuesta, y un proyecto con palabras a su alrededor. Un enlace a un sitio que Mokxi no puede leer indica dónde guarda ese sitio el proyecto y cómo traerlo (una carpeta de Drive, un enlace de OneDrive o Mega, un video de YouTube).
Una foto o una captura de pantalla
Mokxi no puede leer por sí mismo una imagen de un circuito. Suelta una y la importación ofrece Copiar indicaciones de la foto: entrega esas indicaciones y la imagen a ChatGPT, Claude o Gemini, y pega aquí su respuesta. Escribe el circuito en el formato de proyecto de IA de Mokxi y enumera lo que tuvo que adivinar.
Desde LTspice
Full guide: LTspice a Mokxi, paso a paso, con un ejemplo que se abre aquí.
Suelta el esquemático (.asc) en la página de importación o sobre el editor, o pega su texto. LTspice guarda dónde está cada símbolo y por dónde corre cada cable, no qué pines están unidos, así que Mokxi deduce las redes como lo hace LTspice: un pin, un extremo de cable o una etiqueta en el mismo punto es un nodo, un extremo de cable que cae sobre otro cable se une a él, los cables que solo se cruzan no, y las etiquetas con el mismo nombre forman una sola red. Una etiqueta llamada 0 es tierra, y cada una se convierte en un componente de tierra.
Lo que se transfiere: resistencias, capacitores (también polarizados), inductores, diodos (también Schottky y zener), LEDs, transistores NPN y PNP, MOSFET de canal N y P, fuentes de voltaje de CD (como una fuente flotante), fuentes de seno y de pulso (como un generador, cuando el pin negativo de la fuente está en tierra), y los amplificadores operacionales de cinco pines (UniversalOpamp2, opamp2) cuando su pin de alimentación negativa es tierra. Se conserva el nombre del modelo cuando Mokxi tiene ese componente exacto (2N3904, 1N4007, IRLZ44N; un grupo de ganancia como BC337-40 es su componente); de lo contrario, el componente es el predeterminado de Mokxi de su tipo y el informe lo indica. Una línea .param se usa para llenar un {name} en un valor. Los comentarios se convierten en notas adhesivas.
The simulation commands (.tran, .op, .ac, .step and the rest) are read
into the report's notes. Mokxi runs live, so press Run and watch the nodes
with a scope or a meter; a frequency or DC sweep is not carried.
Lo que no se transfiere, cada uno como una nota rosa que lo nombra: fuentes de corriente, fuentes de comportamiento, PWL y otras fuentes especiales, una fuente de seno o pulso cuyo pin negativo no está en tierra, un amplificador operacional con alimentación negativa, todo símbolo que no sea uno de los estándar anteriores (CI, interruptores, líneas de transmisión, subcircuitos), porque sus posiciones de pines están en el archivo de símbolos que guarda LTspice y no en el esquemático. Las tarjetas de modelo y las bibliotecas (.model, .lib) no se importan. No se necesita LTspice, y no se ejecuta nada del archivo.
Una netlist de SPICE exportada por LTspice (View > SPICE Netlist, un .net o un .cir) se abre como netlist, como en la siguiente sección.
Desde Proteus, Multisim y CircuitMaker
Proteus, Multisim y CircuitMaker guardan los diseños en sus propios formatos cerrados, que solo ellos pueden abrir. Desde Multisim, elige Transfer, luego Export Netlist; desde CircuitMaker, elige File, luego Export, luego SPICE Netlist. Abre el .cir con Guardar ▾ > Abrir JSON o SPICE. Desde Proteus, toma una captura de pantalla y usa las indicaciones de la foto. Una netlist de LTspice (.net, desde View > SPICE Netlist) se abre igual que cualquier deck de SPICE, y un esquemático de LTspice (.asc) se importa directamente (consulta Desde LTspice).
Bibliotecas
El informe revisa todas las bibliotecas que nombra el proyecto, en el libraries.txt de Wokwi, el lib_deps de PlatformIO y las líneas #include del sketch:
- Integrada. Mokxi compila con ella tal cual, como
Servo.h,LiquidCrystal_I2C.h,Adafruit_SSD1306.h,Adafruit_NeoPixel.hyDHT.h. - Úsalo en su lugar. Mokxi tiene un controlador que hace el mismo trabajo con otro nombre, y el reporte indica qué header incluir.
- Falta. Nada en Mokxi lo proporciona.
Un zip con una carpeta libraries/ (el diseño del sketchbook de Arduino) o una carpeta de PlatformIO lib/ trae sus bibliotecas como bibliotecas propias del proyecto, en todos los planes. Consulta los planes.
Sacar un proyecto de nuevo
Nada encierra un proyecto. El botón Exportar del encabezado del editor lo descarga como un proyecto de Wokwi (diagram.json, sketch.ino y libraries.txt, en un zip), una carpeta de sketch del IDE de Arduino o un proyecto de PlatformIO. La exportación a Wokwi incluye los componentes y los cables además del código; los componentes para los que Wokwi no tiene equivalente se listan en su README, y las tiras de una protoboard se convierten en cables directos.
Seguridad
Nada de lo que importas se ejecuta mientras se lee. Las subidas, los zips y el texto pegado tienen un límite de tamaño; una ruta que salga del proyecto (../) o que empiece en una unidad se rechaza y se nombra en el reporte; solo se conservan los archivos fuente y del proyecto; los archivos XML que declaran un tipo de documento o entidades se rechazan, así que ninguna entidad se expande ni se descarga jamás; un enlace de CircuitJS se desempaqueta con un límite; y los archivos de biblioteca cumplen las mismas reglas que una biblioteca subida en el editor.
Related
- Si vienes de Wokwi: cada idea de Wokwi junto a su nombre en Mokxi.
- Ayuda a alguien a arreglar su código: un sketch de foro, conectado y funcionando, con una respuesta para pegar.
- Netlists de SPICE y chips personalizados.