352 lines
23 KiB
JSON
352 lines
23 KiB
JSON
{
|
|
"docs": {
|
|
"components": {
|
|
"label": "// riferimento",
|
|
"heading": "Riferimento Componenti",
|
|
"lead": "Velxio include <strong>oltre 48 componenti elettronici interattivi</strong> basati su <a>wokwi-elements</a>. Tutti i componenti possono essere posizionati sul canvas di simulazione, collegati con fili e interagire in tempo reale con il tuo sketch Arduino.",
|
|
"addingHeading": "Aggiungere Componenti",
|
|
"adding1": "Clicca il pulsante <strong>+</strong> sul canvas di simulazione.",
|
|
"adding2": "Usa la <strong>ricerca</strong> o naviga per <strong>categoria</strong> nel selettore componenti.",
|
|
"adding3": "Clicca un componente per posizionarlo sul canvas.",
|
|
"adding4": "<strong>Trascina</strong> per riposizionare; clicca per aprire il <strong>Dialogo Proprietà</strong>.",
|
|
"connectingHeading": "Collegare Componenti",
|
|
"connecting1": "Clicca un <strong>pin</strong> su qualsiasi componente, un filo parte da quel pin.",
|
|
"connecting2": "Clicca un <strong>pin di destinazione</strong> per completare il collegamento.",
|
|
"connecting3": "I fili sono <strong>colorati</strong> in base al tipo di segnale:",
|
|
"thColor": "Colore",
|
|
"thSignalType": "Tipo di Segnale",
|
|
"colorRed": "Rosso",
|
|
"colorBlack": "Nero",
|
|
"colorBlue": "Blu",
|
|
"colorGreen": "Verde",
|
|
"colorPurple": "Viola",
|
|
"colorGold": "Oro",
|
|
"colorOrange": "Arancione",
|
|
"colorCyan": "Ciano",
|
|
"sigVcc": "VCC (alimentazione)",
|
|
"sigGnd": "GND (terra)",
|
|
"sigAnalog": "Analogico",
|
|
"sigDigital": "Digitale",
|
|
"sigPwm": "PWM",
|
|
"sigI2c": "I2C (SDA/SCL)",
|
|
"sigSpi": "SPI (MOSI/MISO/SCK)",
|
|
"sigUsart": "USART (TX/RX)",
|
|
"categoriesHeading": "Categorie di Componenti",
|
|
"outputHeading": "Uscita",
|
|
"thComponent": "Componente",
|
|
"thDescription": "Descrizione",
|
|
"compLed": "LED",
|
|
"compLedDesc": "LED singolo con colore configurabile",
|
|
"compRgbLed": "LED RGB",
|
|
"compRgbLedDesc": "LED a tre colori (canali rosso, verde, blu)",
|
|
"comp7Seg": "Display a 7 Segmenti",
|
|
"comp7SegDesc": "Display numerico a una cifra",
|
|
"compLcd16x2": "LCD 16x2",
|
|
"compLcd16x2Desc": "LCD a caratteri a 2 righe (I2C o parallelo)",
|
|
"compLcd20x4": "LCD 20x4",
|
|
"compLcd20x4Desc": "LCD a caratteri a 4 righe",
|
|
"compIli9341": "TFT ILI9341",
|
|
"compIli9341Desc": "Display TFT a colori 240x320 (SPI)",
|
|
"compBuzzer": "Buzzer",
|
|
"compBuzzerDesc": "Buzzer piezoelettrico passivo",
|
|
"compNeoPixel": "NeoPixel",
|
|
"compNeoPixelDesc": "Striscia LED RGB indirizzabile individualmente",
|
|
"inputHeading": "Ingresso",
|
|
"compPushButton": "Pulsante",
|
|
"compPushButtonDesc": "Pulsante momentaneo",
|
|
"compSlideSwitch": "Interruttore a Scorrimento",
|
|
"compSlideSwitchDesc": "Interruttore a scorrimento SPDT",
|
|
"compPotentiometer": "Potenziometro",
|
|
"compPotentiometerDesc": "Divisore di tensione analogico (ingresso ADC)",
|
|
"compRotaryEncoder": "Encoder Rotativo",
|
|
"compRotaryEncoderDesc": "Encoder rotativo incrementale",
|
|
"compKeypad": "Tastierino 4x4",
|
|
"compKeypadDesc": "Tastierino a matrice 16 pulsanti",
|
|
"compJoystick": "Joystick",
|
|
"compJoystickDesc": "Joystick analogico a due assi",
|
|
"sensorsHeading": "Sensori",
|
|
"compHcSr04": "HC-SR04",
|
|
"compHcSr04Desc": "Sensore di distanza a ultrasuoni",
|
|
"compDht22": "DHT22",
|
|
"compDht22Desc": "Sensore di temperatura e umidità",
|
|
"compPir": "PIR Movimento",
|
|
"compPirDesc": "Sensore di movimento a infrarossi passivo",
|
|
"compPhoto": "Fotoresistenza",
|
|
"compPhotoDesc": "Resistore dipendente dalla luce (LDR)",
|
|
"compIrRecv": "Ricevitore IR",
|
|
"compIrRecvDesc": "Ricevitore a infrarossi 38 kHz",
|
|
"passiveHeading": "Componenti Passivi",
|
|
"compResistor": "Resistore",
|
|
"compResistorDesc": "Resistore standard (valore configurabile)",
|
|
"compCapacitor": "Condensatore",
|
|
"compCapacitorDesc": "Condensatore elettrolitico",
|
|
"compInductor": "Induttore",
|
|
"compInductorDesc": "Induttore a bobina",
|
|
"propsHeading": "Proprietà dei Componenti",
|
|
"propsLead": "Ogni componente ha un <strong>Dialogo Proprietà</strong> accessibile cliccandoci sopra sul canvas:",
|
|
"thProperty": "Proprietà",
|
|
"propArduinoPin": "Pin Arduino",
|
|
"propArduinoPinDesc": "Il pin digitale o analogico a cui è collegato questo componente",
|
|
"propColor": "Colore",
|
|
"propColorDesc": "Colore visivo (LED, fili)",
|
|
"propValue": "Valore",
|
|
"propValueDesc": "Valore del componente (es. resistenza in Ohm)",
|
|
"propRotation": "Rotazione",
|
|
"propRotationDesc": "Ruota con incrementi di 90 gradi",
|
|
"propDelete": "Elimina",
|
|
"propDeleteDesc": "Rimuovi il componente dal canvas"
|
|
},
|
|
"sectionMeta": {
|
|
"intro": {
|
|
"title": "Introduzione | Documentazione Velxio",
|
|
"description": "Scopri Velxio, l'emulatore Arduino open-source gratuito con emulazione CPU AVR8 e RP2040 reale e oltre 48 componenti elettronici interattivi."
|
|
},
|
|
"gettingStarted": {
|
|
"title": "Per Iniziare | Documentazione Velxio",
|
|
"description": "Inizia con Velxio: usa l'editor ospitato, auto-ospita con Docker o configura un ambiente di sviluppo locale. Simula il tuo primo sketch Arduino in pochi minuti."
|
|
},
|
|
"emulator": {
|
|
"title": "Architettura dell'Emulatore | Documentazione Velxio",
|
|
"description": "Come Velxio emula CPU AVR8 (ATmega328p), RP2040 e RISC-V (ESP32-C3). Copre cicli di esecuzione, periferiche e mappatura pin per tutte le schede supportate."
|
|
},
|
|
"riscvEmulation": {
|
|
"title": "Emulazione RISC-V (ESP32-C3) | Documentazione Velxio",
|
|
"description": "Emulatore RV32IMC lato browser per ESP32-C3, XIAO ESP32-C3 e C3 SuperMini. Copre mappa di memoria, GPIO, UART0, parser immagine ESP32, ISA RV32IMC e suite di test."
|
|
},
|
|
"esp32Emulation": {
|
|
"title": "Emulazione ESP32 (Xtensa) | Documentazione Velxio",
|
|
"description": "Emulazione basata su QEMU per ESP32 e ESP32-S3 (Xtensa LX6/LX7). Copre il fork lcgamboa, libqemu-xtensa, GPIO, WiFi, I2C, SPI, RMT/NeoPixel e LEDC/PWM."
|
|
},
|
|
"components": {
|
|
"title": "Riferimento Componenti | Documentazione Velxio",
|
|
"description": "Riferimento completo per tutti i 48+ componenti elettronici interattivi in Velxio: LED, display, sensori, pulsanti, potenziometri e altro. Include dettagli su cablaggio e proprietà."
|
|
},
|
|
"roadmap": {
|
|
"title": "Roadmap | Documentazione Velxio",
|
|
"description": "Roadmap delle funzionalità di Velxio: cosa è implementato, cosa è in corso e cosa è pianificato per le versioni future."
|
|
},
|
|
"architecture": {
|
|
"title": "Architettura del Progetto | Documentazione Velxio",
|
|
"description": "Panoramica dettagliata dell'architettura del sistema Velxio: frontend, backend, pipeline di emulazione AVR8, flussi di dati, store Zustand e sistema di cablaggio."
|
|
},
|
|
"thirdParty": {
|
|
"title": "Librerie Wokwi | Documentazione Velxio",
|
|
"description": "Come Velxio integra le librerie open-source ufficiali Wokwi: avr8js, wokwi-elements e rp2040js. Copre configurazione, aggiornamenti e i 48 componenti disponibili."
|
|
},
|
|
"mcp": {
|
|
"title": "Server MCP | Documentazione Velxio",
|
|
"description": "Riferimento del server MCP Velxio: integra agenti AI (Claude, Cursor) con Velxio tramite Model Context Protocol. Copre strumenti, trasporti, formato circuito ed esempi guidati."
|
|
},
|
|
"setup": {
|
|
"title": "Stato del Progetto | Documentazione Velxio",
|
|
"description": "Stato completo di tutte le funzionalità implementate di Velxio: emulazione AVR, sistema componenti, sistema di cablaggio, editor di codice, progetti di esempio e prossimi passi."
|
|
},
|
|
"rp2040Emulation": {
|
|
"title": "Emulazione RP2040 (Raspberry Pi Pico) | Documentazione Velxio",
|
|
"description": "Come Velxio emula Raspberry Pi Pico e Pico W usando rp2040js: ARM Cortex-M0+ a 133 MHz, GPIO, UART, ADC, I2C, SPI, PWM e ottimizzazione WFI."
|
|
},
|
|
"raspberryPi3Emulation": {
|
|
"title": "Emulazione Raspberry Pi 3 (QEMU) | Documentazione Velxio",
|
|
"description": "Come Velxio emula un Raspberry Pi 3B completo usando QEMU raspi3b: vero Raspberry Pi OS, shim Python + RPi.GPIO, UART a doppio canale, VFS e ponte seriale multi-scheda."
|
|
},
|
|
"buildQemu": {
|
|
"title": "Compilare QEMU dal sorgente | Documentazione Velxio",
|
|
"description": "Guida passo-passo per compilare libqemu-xtensa e libqemu-riscv32 dal fork lcgamboa/qemu. Trasparenza completa sotto licenza AGPLv3."
|
|
}
|
|
},
|
|
"rp2040": {
|
|
"label": "// arm cortex-m0+",
|
|
"heading": "Emulazione RP2040 (Raspberry Pi Pico)",
|
|
"lead": "Raspberry Pi Pico e Pico W sono emulati interamente nel browser usando <a>rp2040js</a>, un emulatore open-source ARM Cortex-M0+. Non è richiesto QEMU o un processo backend, il binario viene eseguito a piena velocità all'interno di un Web Worker.",
|
|
"boardsHeading": "Schede Supportate",
|
|
"boardPico": "Raspberry Pi Pico",
|
|
"altPico": "Raspberry Pi Pico",
|
|
"boardPicoW": "Raspberry Pi Pico W",
|
|
"altPicoW": "Raspberry Pi Pico W",
|
|
"thBoard": "Scheda",
|
|
"thFqbn": "FQBN",
|
|
"thBuiltinLed": "LED Integrato",
|
|
"ledGpio25": "GPIO 25",
|
|
"ledCyw43": "GPIO 25 (tramite CYW43)",
|
|
"binaryHeading": "Formato Binario",
|
|
"binaryBody1": "Il backend compila lo sketch con <code>arduino-cli</code> target <code>rp2040:rp2040:rpipico</code> e restituisce un binario ARM grezzo (<code>.bin</code>) codificato in base64. A differenza di AVR, non c'è Intel HEX, il binario viene caricato direttamente nella flash RP2040 all'offset 0.",
|
|
"binaryBody2": "Il backend prepone anche <code>#define Serial Serial1</code> allo sketch in modo che le chiamate Arduino <code>Serial</code> vengano reindirizzate a UART0 (la porta seriale virtuale trasmessa al Monitor Seriale).",
|
|
"peripheralsHeading": "Periferiche",
|
|
"thPeripheral": "Periferica",
|
|
"thSupport": "Supporto",
|
|
"thNotes": "Note",
|
|
"perGpio": "GPIO (30 pin)",
|
|
"supFull": "Completo",
|
|
"perGpioNotes": "Lettura/scrittura digitale, pull-up/down",
|
|
"perUart": "UART0 / UART1",
|
|
"perUartNotes": "Monitor Seriale tramite UART0",
|
|
"perAdc": "ADC (ch 0-3)",
|
|
"perAdcNotes": "GPIO 26-29; ch 4 = sensore di temperatura",
|
|
"perI2c": "I2C0 / I2C1",
|
|
"supPartial": "Parziale",
|
|
"perI2cNotes": "Dispositivi virtuali DS1307 RTC, TempSensor, EEPROM",
|
|
"perSpi": "SPI0 / SPI1",
|
|
"supLoopback": "Loopback",
|
|
"perSpiNotes": "TX in loopback su RX",
|
|
"perPwm": "PWM",
|
|
"supFreqOnly": "Solo frequenza",
|
|
"perPwmNotes": "Nessuna forma d'onda in uscita verso i componenti",
|
|
"perTimer": "Timer / Allarme",
|
|
"perTimerNotes": "Usato da <code>delay()</code> e <code>millis()</code>",
|
|
"wfiHeading": "Ottimizzazione WFI",
|
|
"wfiBody": "Quando la CPU esegue un'istruzione <strong>WFI</strong> (Wait For Interrupt), l'emulatore avanza rapidamente il clock di sistema fino al prossimo allarme programmato invece di girare a vuoto nei cicli di idle. Ciò riduce drasticamente l'uso della CPU durante le chiamate <code>delay()</code>.",
|
|
"simLoopHeading": "Ciclo di Simulazione",
|
|
"simLoopBody": "La simulazione viene eseguita all'interno di <code>requestAnimationFrame</code> a circa 60 FPS. Ogni frame esegue circa <strong>2.200.000</strong> cicli CPU (133 MHz / 60 fps). I listener GPIO si attivano ogni volta che lo stato di un pin cambia e aggiornano i componenti visivi sul canvas.",
|
|
"limitsHeading": "Limitazioni Note",
|
|
"limit1": "Il chip wireless Pico W (CYW43439) non è emulato, WiFi/Bluetooth non funzioneranno",
|
|
"limit2": "Solo loopback SPI, nessuna emulazione di dispositivo SPI reale",
|
|
"limit3": "PWM produce la frequenza corretta ma nessuna forma d'onda visiva sui componenti",
|
|
"limit4": "DMA non emulato",
|
|
"limit5": "Secondo core CPU (core 1) non emulato, <code>multicore_launch_core1()</code> non ha effetto",
|
|
"fullDocsHeading": "Documentazione Completa",
|
|
"fullDocsBody": "Vedi il riferimento tecnico completo: <a>RP2040_EMULATION.md</a>"
|
|
},
|
|
"rpi3": {
|
|
"label": "// qemu raspi3b",
|
|
"heading": "Emulazione Raspberry Pi 3 (QEMU)",
|
|
"lead": "Raspberry Pi 3B è emulato usando <strong>QEMU 8.1.3</strong> con <code>-M raspi3b</code>. Questa è l'unica scheda in Velxio che esegue un sistema operativo completo, una vera immagine <strong>Raspberry Pi OS (Trixie)</strong> avviata all'interno dell'emulatore. Gli utenti scrivono script Python (non C++), che vengono eseguiti dall'interprete Python 3 reale all'interno della VM.",
|
|
"boardsHeading": "Schede Supportate",
|
|
"boardRpi3": "Raspberry Pi 3B",
|
|
"altRpi3": "Raspberry Pi 3B",
|
|
"thBoard": "Scheda",
|
|
"thQemuMachine": "Macchina QEMU",
|
|
"thCpu": "CPU",
|
|
"boardRpi3Name": "Raspberry Pi 3B",
|
|
"cpuBcm": "BCM2837, 4x Cortex-A53 @ 1.2 GHz",
|
|
"serialHeading": "Architettura Seriale a Doppio Canale",
|
|
"serialLead": "QEMU espone due canali UART al backend:",
|
|
"serialUser": "<strong>ttyAMA0</strong>: Seriale utente: terminale interattivo (Monitor Seriale). L'output <code>print()</code> dell'utente appare qui.",
|
|
"serialGpio": "<strong>ttyAMA1</strong>: Shim GPIO: trasporta un protocollo testuale tra lo shim GPIO all'interno della VM e il backend.",
|
|
"shimHeading": "Shim RPi.GPIO",
|
|
"shimBody1": "Uno shim <code>RPi.GPIO</code> personalizzato viene iniettato in <code>/usr/local/lib/python3.11/dist-packages/RPi/GPIO.py</code> all'interno della VM. Quando il codice utente chiama <code>GPIO.output(pin, value)</code>, lo shim scrive una riga come <code>GPIO 17 1</code> su <strong>ttyAMA1</strong>. Il backend la legge, attiva un evento WebSocket <code>gpio_change</code> e il frontend aggiorna il componente visivo sul canvas.",
|
|
"shimBody2": "Funziona anche al contrario: il frontend può inviare <code>SET 17 1</code> tramite WebSocket - backend - ttyAMA1 - shim - il codice utente lo legge tramite <code>GPIO.input(17)</code>.",
|
|
"vfsHeading": "File System Virtuale (VFS)",
|
|
"vfsBody": "Ogni istanza della scheda Raspberry Pi ha il proprio VFS che mappa i file all'interno della VM in esecuzione. L'albero predefinito è:",
|
|
"overlayHeading": "Immagini Overlay",
|
|
"overlayBody": "L'immagine SD base di Raspberry Pi OS non viene mai modificata. Ogni sessione crea un nuovo <strong>overlay qcow2</strong> sopra l'immagine base, quindi tutte le modifiche in fase di esecuzione sono isolate e scartate al termine della sessione.",
|
|
"limitsHeading": "Limitazioni Note",
|
|
"limit1": "Nessuna emulazione di dispositivi I2C o SPI",
|
|
"limit2": "Nessuna forma d'onda PWM in uscita verso i componenti",
|
|
"limit3": "Nessuna rete (WiFi/Ethernet non emulati)",
|
|
"limit4": "Lo stato della sessione non viene persistito, l'overlay viene scartato all'arresto",
|
|
"limit5": "Il tempo di avvio è lento (~10-20 s) poiché deve avviarsi un sistema operativo completo",
|
|
"limit6": "Richiede che l'immagine SD base di circa 5.67 GB sia presente sul server",
|
|
"fullDocsHeading": "Documentazione Completa",
|
|
"fullDocsBody": "Vedi il riferimento tecnico completo: <a>RASPBERRYPI3_EMULATION.md</a>"
|
|
},
|
|
"gettingStarted": {
|
|
"label": "// configurazione",
|
|
"heading": "Per Iniziare",
|
|
"lead": "Segui questi passaggi per simulare il tuo primo sketch Arduino.",
|
|
"option1Heading": "Opzione 1: Usa la Versione Ospitata",
|
|
"option1Body": "Nessuna installazione necessaria, vai su <a>https://velxio.dev</a> e inizia a programmare immediatamente.",
|
|
"option2Heading": "Opzione 2: Auto-Hosting con Docker",
|
|
"option2Body": "Esegui un singolo comando Docker per avviare un'istanza completamente locale:",
|
|
"option2After": "Poi apri <strong>http://localhost:3080</strong> nel tuo browser.",
|
|
"option3Heading": "Opzione 3: Configurazione Manuale (Sviluppo)",
|
|
"option3Prereq": "<strong>Prerequisiti:</strong> Node.js 18+, Python 3.12+, <code>arduino-cli</code>",
|
|
"option3Step1": "1. Clona il repository",
|
|
"option3Step2": "2. Avvia il backend",
|
|
"option3Step3": "3. Avvia il frontend",
|
|
"option3Step3After": "Apri <strong>http://localhost:5173</strong>.",
|
|
"option3Step4": "4. Configura arduino-cli (prima volta)",
|
|
"firstSimulationHeading": "La Tua Prima Simulazione",
|
|
"firstSim1": "<strong>Apri l'editor</strong> su <a>velxio.dev/editor</a>.",
|
|
"firstSim2": "<strong>Seleziona una scheda</strong> dalla barra degli strumenti (es. <em>Arduino Uno</em>).",
|
|
"firstSim3": "<strong>Scrivi codice Arduino</strong> nell'editor Monaco, ad esempio:",
|
|
"firstSim4": "<strong>Clicca Compila</strong>: il backend chiama <code>arduino-cli</code> e restituisce un file <code>.hex</code>.",
|
|
"firstSim5": "<strong>Clicca Esegui</strong>: l'emulatore AVR8 esegue il programma compilato.",
|
|
"firstSim6": "<strong>Aggiungi componenti</strong> usando il selettore componenti (clicca il pulsante <strong>+</strong> sul canvas).",
|
|
"firstSim7": "<strong>Collega fili</strong> cliccando un pin del componente e poi un altro pin.",
|
|
"troubleshootingHeading": "Risoluzione dei Problemi",
|
|
"thProblem": "Problema",
|
|
"thSolution": "Soluzione",
|
|
"tsArduinoCliMissingProblem": "<code>arduino-cli: comando non trovato</code>",
|
|
"tsArduinoCliMissingSolution": "Installa <code>arduino-cli</code> e aggiungilo al tuo PATH.",
|
|
"tsLedNoBlinkProblem": "Il LED non lampeggia",
|
|
"tsLedNoBlinkSolution": "Controlla la console del browser per errori del listener di porta; verifica l'assegnazione del pin nel dialogo delle proprietà del componente.",
|
|
"tsSerialEmptyProblem": "Il Monitor Seriale è vuoto",
|
|
"tsSerialEmptySolution": "Assicurati che <code>Serial.begin()</code> sia chiamato all'interno di <code>setup()</code> prima di qualsiasi <code>Serial.print()</code>.",
|
|
"tsCompileErrorsProblem": "Errori di compilazione",
|
|
"tsCompileErrorsSolution": "Controlla la console di compilazione nella parte inferiore dell'editor per l'output completo di <code>arduino-cli</code>."
|
|
},
|
|
"thirdParty": {
|
|
"label": "// librerie open-source",
|
|
"heading": "Librerie Wokwi",
|
|
"lead": "Velxio utilizza i repository open-source ufficiali Wokwi clonati localmente in <code>third-party/</code>. Questo fornisce motori di emulazione e componenti visivi aggiornati e compatibili senza dipendenze dal registro npm.",
|
|
"clonedHeading": "Repository Clonati",
|
|
"thLibrary": "Libreria",
|
|
"thLocation": "Posizione",
|
|
"libElementsDesc": "Oltre 48 componenti web Lit (LED, LCD, sensori, pulsanti...)",
|
|
"libAvr8jsDesc": "Emulatore CPU ATmega328p / ATmega2560 a 16 MHz",
|
|
"libRp2040jsDesc": "Emulatore Raspberry Pi Pico (RP2040)",
|
|
"npmIntro": "Tutte e tre le librerie sono estratte direttamente dal registro npm da <code>frontend/package.json</code>. I cloni di riferimento possono risiedere in <code>third-party/</code> per crediti e hacking offline, ma la build non li richiede.",
|
|
"updatingHeading": "Aggiornare le Librerie",
|
|
"updatingBody": "Modifica i pin delle versioni in <code>frontend/package.json</code> (<code>@wokwi/elements</code>, <code>avr8js</code>, <code>rp2040js</code>) ed esegui <code>npm install</code> in <code>frontend/</code>.",
|
|
"afterBumpHeading": "Dopo l'aggiornamento di wokwi-elements (solo quando si aggiungono nuovi componenti)",
|
|
"afterBumpBody": "Il generatore di metadati scansiona <code>src/</code> upstream, che il pacchetto npm non include. Clona wokwi-elements una volta in <code>third-party/</code> e rigenera:",
|
|
"availableHeading": "Componenti Wokwi Disponibili (48)",
|
|
"thCategory": "Categoria",
|
|
"thComponents": "Componenti",
|
|
"catBoards": "Schede",
|
|
"catBoardsList": "Arduino Uno, Mega, Nano, ESP32 DevKit",
|
|
"catSensors": "Sensori",
|
|
"catSensorsList": "DHT22, HC-SR04, PIR, Fotoresistenza, NTC, Joystick",
|
|
"catDisplays": "Display",
|
|
"catDisplaysList": "LCD 16x2, LCD 20x4, 7 Segmenti",
|
|
"catInput": "Ingresso",
|
|
"catInputList": "Pulsante, pulsante 6mm, interruttore a scorrimento, DIP switch 8, potenziometro",
|
|
"catOutput": "Uscita",
|
|
"catOutputList": "LED, LED RGB, grafico a barre LED, Buzzer, NeoPixel",
|
|
"catMotors": "Motori",
|
|
"catMotorsList": "Servo, motore passo-passo",
|
|
"catPassive": "Passivi",
|
|
"catPassiveList": "Resistore, potenziometro lineare, anello LED, tastierino a matrice",
|
|
"catOther": "Altro",
|
|
"catOtherList": "Ricevitore IR, RTC DS1307, breadboard, ecc.",
|
|
"howAvrHeading": "Come avr8js Alimenta la Simulazione",
|
|
"fullDetailsCallout": "<strong>Dettagli completi:</strong> Vedi <a>docs/WOKWI_LIBS.md</a> nel repository."
|
|
},
|
|
"mcp": {
|
|
"label": "// integrazione AI",
|
|
"heading": "Server MCP",
|
|
"lead": "Velxio espone un server <a>Model Context Protocol</a> (MCP) che consente agli agenti AI (Claude, Cursor e altri) di creare circuiti, generare codice e compilare sketch Arduino direttamente.",
|
|
"toolsHeading": "Strumenti Disponibili",
|
|
"thTool": "Strumento",
|
|
"toolCompileDesc": "Compila file sketch Arduino - Intel HEX / binario",
|
|
"toolRunDesc": "Compila e segna l'artefatto come pronto per la simulazione",
|
|
"toolImportDesc": "Analizza un <code>diagram.json</code> Wokwi - circuito Velxio",
|
|
"toolExportDesc": "Serializza un circuito Velxio - <code>diagram.json</code> Wokwi",
|
|
"toolCreateDesc": "Crea una nuova definizione di circuito",
|
|
"toolUpdateDesc": "Unisci modifiche in un circuito esistente",
|
|
"toolGenerateDesc": "Genera codice <code>.ino</code> iniziale da un circuito",
|
|
"transportHeading": "Opzioni di Trasporto",
|
|
"stdioHeading": "1. stdio: Agenti Claude Desktop / CLI",
|
|
"stdioConfigBody": "Configurazione Claude Desktop (<code>~/.claude/claude_desktop_config.json</code>):",
|
|
"sseHeading": "2. SSE / HTTP: IDE Cursor / agenti web",
|
|
"sseConfigBody": "Configurazione client MCP:",
|
|
"circuitFormatHeading": "Formato Dati del Circuito",
|
|
"circuitFormatLead": "I circuiti Velxio sono semplici oggetti JSON:",
|
|
"fqbnHeading": "FQBN di Schede Supportate",
|
|
"thFqbn": "FQBN",
|
|
"exampleHeading": "Esempio: LED Lampeggiante da Zero",
|
|
"setupHeading": "Configurazione",
|
|
"fullRefCallout": "<strong>Riferimento completo:</strong> Vedi <a>docs/MCP.md</a> nel repository."
|
|
},
|
|
"pagesNav": {
|
|
"home": "Home",
|
|
"editor": "Editor",
|
|
"examples": "Esempi"
|
|
},
|
|
"toggleSidebar": "Attiva/disattiva barra laterale",
|
|
"viewOnGitHub": "Vedi su GitHub",
|
|
"pageTitle": "Documentazione",
|
|
"pages": "Pagine"
|
|
}
|
|
}
|