GitHub – davidmonterocrespo24/velxio: Emular Arduino, ESP32 e Raspberry Pi. no seu navegador. Escreva código, compile e execute em 19 placas reais – Arduino Uno, ESP32, ESP32-C3, Raspberry Pi Pico, Raspberry Pi 3 e muito mais. Sem hardware, sem nuvem, sem limites.. Discord: https://discord.gg/rCScB9cG · GitHub

Ao vivo em velxio.dev

Um emulador multiplaca totalmente local e de código aberto. Escreva Arduino C++ ou Python, compile-o e simule-o com emulação de CPU real e mais de 48 componentes eletrônicos interativos — todos rodando em seu navegador.

19 placas · 5 arquiteturas de CPU: AVR8 (ATmega/ATtiny), ARM Cortex-M0+ (RP2040), RISC-V RV32IMC/EC (ESP32-C3/CH32V003), Xtensa LX6/LX7 (ESP32/ESP32-S3 via QEMU) e ARM Cortex-A53 (Raspberry Pi 3 Linux via QEMU).

Velxio é gratuito e de código aberto. Construir e manter um emulador multiplaca completo leva muito tempo – se isso economizar seu tempo ou se você gostar do projeto, patrocinar-me diretamente ajuda a manter o desenvolvimento em andamento.

Seu suporte ajuda a cobrir custos de servidor, manutenção de biblioteca e libera tempo para adicionar novas placas, componentes e recursos. Obrigado!

https://velxio.dev – nenhuma instalação necessária. Abra o editor, escreva seu esboço e simule diretamente no navegador.

Para auto-hospedar com Docker (comando único):

docker run -d -p 3080:80 ghcr.io/davidmonterocrespo24/velxio:master

Em seguida, abra http://localhost:3080.

Simulação Raspberry Pi Pico – teste de leitura ADC com dois potenciômetros, Serial Monitor mostrando saída ao vivo e console de compilação na parte inferior.

Arduino Uno acionando um display ILI9341 240×320 TFT via SPI — renderizando uma demonstração gráfica em tempo real usando Adafruit_GFX + Adafruit_ILI9341.

O Library Manager carrega o índice completo da biblioteca do Arduino ao abrir – navegue e instale bibliotecas sem digitar primeiro.

Seletor de componentes mostrando 48 componentes disponíveis com visualizações visuais, pesquisa e filtros de categoria.

Simulação multiplaca — Raspberry Pi 3 e Arduino rodando simultaneamente na mesma tela, conectados via serial. Misture diferentes arquiteturas em um único circuito.

Simulação ESP32 com sensor de distância ultrassônico HC-SR04 – emulação Xtensa real via QEMU com temporização GPIO de disparo/eco.

• Editor de Mônaco — Editor C++/Python completo com realce de sintaxe, preenchimento automático, minimapa e tema escuro
• Espaço de trabalho com vários arquivos — criar, renomear, excluir e alternar entre vários .ino / .h / .cpp / .py arquivos
• Compilação Arduino através de arduino-cli back-end — compila esboços para .hex / .bin arquivos
• Compilar/Executar/Parar/Redefinir botões da barra de ferramentas com mensagens de status
• Console de compilação — painel de saída redimensionável mostrando a saída completa do compilador, avisos e erros

• Emulação real ATmega328p / ATmega2560 / ATmega32u4 / ATtiny85 na velocidade de clock nativa via avr8js
• GPIO completo — PORTB, PORTC, PORTD (Uno/Nano/Mega); todas as portas ATtiny85 (PB0 – PB5)
• Temporizador0/Temporizador1/Temporizador2 – millis(), delay()PWM via analogWrite()
• USAR – transmissão e recepção completas, detecção automática de taxa de transmissão
• ADC – analogRead()injeção de tensão de potenciômetros na tela
• IPS — periférico SPI de hardware (ILI9341, cartão SD, etc.)
• I2C (TWI) — hardware I2C com barramento de dispositivo virtual
• ATtiny85 — todos os 6 pinos de E/S, USI (Fio), Timer0/Timer1, ADC de 10 bits; usa AttinyCore
• Loop de simulação de ~60 FPS via requestAnimationFrame

• Emulação real de RP2040 a 133 MHz via rp2040js – ARM Cortex-M0+
• Todos os 30 pinos GPIO — entrada/saída, ouvintes de eventos, injeção de estado de pino
• UART0 + UART1 — saída serial no Serial Monitor; Entrada serial da IU
• ADC — 12 bits no GPIO 26–29 (A0–A3) + sensor de temperatura interna (ch4)
• I2C0 + I2C1 — modo mestre com barramento de dispositivo virtual (DS1307, TMP102, EEPROM)
• SPI0 + SPI1 — padrão de loopback; manipulador personalizado suportado
• PWM — disponível em qualquer pino GPIO
• Otimização WFI – delay() avança no tempo de simulação em vez de esperar ocupado
• Osciloscópio – Carimbos de data e hora de transição GPIO com resolução de aproximadamente 8 ns
• Compilado com o núcleo earlephilhower arduino-pico

Consulte docs/RP2040_EMULATION.md para obter detalhes técnicos completos.

• Emulação dual-core Real Xtensa LX6/LX7 via lcgamboa/qemu
• GPIO completo – todos os 40 pinos GPIO, rastreamento de direção, retornos de chamada de estado, correção GPIO32–39
• UART0/1/2 – serial multi-UART, detecção de taxa de transmissão
• ADC — 12 bits em todos os pinos compatíveis com ADC (injeção de 0–3300 mV de potenciômetros)
• I2C — barramento síncrono com resposta de dispositivo virtual
• IPS — full-duplex com injeção de byte MISO configurável
• RMT/NeoPixel — decodificador RMT de hardware, decodificação de quadro GRB WS2812 de 24 bits
• LED/PWM — Leitura do ciclo de trabalho de 16 canais, mapeamento LEDC → GPIO, brilho do LED
• Wi-fi — Emulação SLIRP NAT (WiFi.begin("PICSimLabWifi", ""))
• Requer arduino-esp32 2.0.17 (IDF 4.4.x) — única versão compatível com lcgamboa WiFi

Consulte docs/ESP32_EMULATION.md para configuração e detalhes técnicos completos.

• Emulação RV32IMC em TypeScript – sem back-end, sem QEMU, sem WebSocket
• GPIO 0–21 via registros W1TS/W1TC MMIO (ESP32-C3); PB0–PB5 (CH32V003)
• UART0 saída serial no Serial Monitor
• CH32V003 — Núcleo RV32EC a 48 MHz, flash de 16 KB, pacote DIP-8/SOP — ultracompacto
• Inicialização instantânea — latência zero, funciona offline
• Testável por CI – o mesmo TypeScript é executado no Vitest

Consulte docs/RISCV_EMULATION.md para obter detalhes técnicos completos.

• Emulação BCM2837 completa através de qemu-system-aarch64 -M raspi3b
• Inicializa o verdadeiro Raspberry Pi OS (Trixie) — executa scripts Python diretamente
• Calço RPi.GPIO — substituição imediata da biblioteca GPIO; envia eventos pin para o frontend através de um protocolo de texto
• GPIO 0–27 — saída e entrada, detecção de eventos, PWM (estado binário)
• Série dupla — ttyAMA0 para usuário Serial Monitor, ttyAMA1 para protocolo GPIO
• Sistema de arquivos virtuais – edite scripts Python na UI, faça upload para Pi na inicialização
• Ponte serial multiplaca — Pi ↔ Comunicação serial Arduino na mesma tela
• sobreposição qcow2 — imagem base SD nunca modificada; alterações de sessão são isoladas

Consulte docs/RASPBERRYPI3_EMULATION.md para obter detalhes técnicos completos.

• Saída serial ao vivo — personagens conforme o esboço/roteiro os envia
• Detecção automática de taxa de transmissão — lê registros de hardware, sem necessidade de configuração manual
• Enviar dados para o pino RX da UI
• Rolagem automática com alternância

• 48 componentes eletrônicos de elementos wokwi
• Seletor de componentes com pesquisa, filtros de categoria e visualizações ao vivo
• Arrastar e soltar reposicionamento na tela de simulação
• Rotação de componentes em incrementos de 90°
• Caixa de diálogo Propriedade – funções dos pinos, atribuição dos pinos do Arduino, girar e excluir

• Criação de fio — clique em um alfinete para iniciar, clique em outro alfinete para conectar
• Roteamento ortogonal – sem caminhos diagonais
• 8 cores de fio tipo sinal: Vermelho (VCC), Preto (GND), Azul (Analógico), Verde (Digital), Roxo (PWM), Dourado (I2C), Laranja (SPI), Ciano (USART)
• Edição de fios baseada em segmento — arraste segmentos perpendiculares à sua orientação

• Navegue e instale o índice completo da biblioteca do Arduino diretamente da IU
• Pesquisa ao vivo, guia instalada, exibição de versão

• E-mail/senha e Google OAuth entrar
• Salvar projeto com nome, descrição e visibilidade pública/privada
• URL do projeto — cada projeto recebe um URL permanente em /project/:id
• Arquivos de esboço armazenados em disco por projeto (acessível do host via volume Docker)
• Perfil de usuário no /:username mostrando projetos públicos

• Exemplos integrados, incluindo Blink, Semáforo, Controle de botão, Fade LED, Serial Hello World, RGB LED, Simon Says, LCD 20×4 e controle serial Pi + Arduino
• Carregamento com um clique no editor

# Pull and run
docker run -d \
  --name velxio \
  -p 3080:80 \
  -v $(pwd)/data:/app/data \
  ghcr.io/davidmonterocrespo24/velxio:master

Abra http://localhost:3080.

O /app/data volume contém:

• velxio.db — Banco de dados SQLite (usuários, metadados de projetos)
• projects/{id}/ — arquivos de esboço por projeto

git clone https://github.com/davidmonterocrespo24/velxio.git
cd velxio
cp backend/.env.example backend/.env   # edit as needed
docker compose -f docker-compose.prod.yml up -d

Pré-requisitos: Node.js 18+, Python 3.12+, arduino-cli

git clone https://github.com/davidmonterocrespo24/velxio.git
cd velxio

# Backend
cd backend
python -m venv venv && source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt
uvicorn app.main:app --reload --port 8001

# Frontend (new terminal)
cd frontend
npm install
npm run dev

Abra http://localhost:5173.

Configuração do arduino-cli (primeira vez):

arduino-cli core update-index
arduino-cli core install arduino:avr

# For Raspberry Pi Pico / Pico W:
arduino-cli config add board_manager.additional_urls \
  https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
arduino-cli core install rp2040:rp2040

# For ESP32 / ESP32-S3 / ESP32-C3:
arduino-cli config add board_manager.additional_urls \
  https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
arduino-cli core install esp32:esp32@2.0.17

velxio/
├── frontend/                    # React + Vite + TypeScript
│   └── src/
│       ├── pages/               # LandingPage, EditorPage, UserProfilePage, ...
│       ├── components/          # Editor, simulator canvas, modals, layout
│       ├── simulation/          # AVRSimulator, RP2040Simulator, RiscVCore,
│       │                        # RaspberryPi3Bridge, Esp32Bridge, PinManager
│       ├── store/               # Zustand stores (auth, editor, simulator, project, vfs)
│       └── services/            # API clients
├── backend/                     # FastAPI + Python
│   └── app/
│       ├── api/routes/          # compile, auth, projects, libraries, simulation (ws)
│       ├── models/              # User, Project (SQLAlchemy)
│       ├── services/            # arduino_cli, esp32_worker, qemu_manager, gpio_shim
│       └── core/                # config, security, dependencies
├── wokwi-libs/                  # Local clones of Wokwi repos
│   ├── wokwi-elements/          # Web Components for electronic parts
│   ├── avr8js/                  # AVR8 CPU emulator
│   ├── rp2040js/                # RP2040 emulator
│   └── qemu-lcgamboa/           # QEMU fork for ESP32 Xtensa emulation
├── img/                         # Raspberry Pi 3 boot images (kernel8.img, dtb, OS image)
├── deploy/                      # nginx.conf, entrypoint.sh
├── docs/                        # Technical documentation
├── Dockerfile.standalone        # Single-container production image
├── docker-compose.yml           # Development compose
└── docker-compose.prod.yml      # Production compose

arduino-cli: command not found – instale o arduino-cli e adicione ao PATH.

LED não pisca — verifique os ouvintes de porta no console do navegador; verifique o mapeamento de pinos na caixa de diálogo de propriedades do componente.

Serial Monitor não mostra nada – garantir Serial.begin() é chamado antes Serial.print().

ESP32 não inicia – verificar libqemu-xtensa.dll (Windows) ou libqemu-xtensa.so (Linux) está presente em backend/app/services/.

Pi 3 demora muito para inicializar — QEMU precisa de 2 a 5 segundos para inicializar; o status de “inicialização” na interface do usuário é esperado.

Erros de compilação — verifique o console de compilação; verifique se o núcleo correto está instalado para a placa selecionada.

Junte-se ao servidor Discord para fazer perguntas, compartilhar projetos e acompanhar atualizações:

discord.gg/rCScB9cG

Sugestões, relatórios de bugs e solicitações pull são bem-vindas em github.com/davidmonterocrespo24/velxio.

Se você quiser apoiar o projeto financeiramente, consulte a seção Apoie o Projeto acima ou patrocine diretamente em github.com/sponsors/davidmonterocrespo24.

Observação: Todos os contribuidores devem assinar um Contrato de Licença de Contribuidor (CLA) para que o modelo de licenciamento duplo permaneça válido. Uma verificação de CLA é executada automaticamente em solicitações pull.

Velxio usa um licenciamento duplo modelo:

A AGPLv3 é uma licença certificada de código aberto. É gratuito para todos os usos – inclusive comerciais – desde que quaisquer modificações ou implantações acessíveis pela rede disponibilizem seu código-fonte sob a mesma licença. As empresas que não conseguirem cumprir essa exigência podem adquirir uma Licença Comercial.

Para consultas de licenciamento comercial: davidmonterocrespo24@gmail.com

Consulte LICENSE e COMMERCIAL_LICENSE.md para obter os termos completos.