377 lines
23 KiB
JSON
377 lines
23 KiB
JSON
{
|
|
"docs": {
|
|
"riscv": {
|
|
"label": "// risc-v",
|
|
"heading": "Émulation RISC-V (ESP32-C3)",
|
|
"lead": "Les cartes ESP32-C3, XIAO ESP32-C3 et C3 SuperMini fonctionnent sur l'architecture <strong>RISC-V RV32IMC</strong> à 160 MHz. Velxio les émule via le même backend basé sur QEMU que la famille Xtensa ESP32, en utilisant <code>libqemu-riscv32</code> avec la cible machine <code>esp32c3-picsimlab</code>. Une implémentation TypeScript distincte du jeu d'instructions existe dans le dépôt pour les tests unitaires du décodage RV32IMC, mais ce n'est pas le chemin d'émulation de production.",
|
|
"boardsHeading": "Cartes supportées",
|
|
"boardEsp32C3": "ESP32-C3 DevKit",
|
|
"boardXiaoC3": "Seeed XIAO ESP32-C3",
|
|
"boardC3Super": "ESP32-C3 SuperMini",
|
|
"altEsp32C3": "ESP32-C3 DevKit",
|
|
"altXiaoC3": "Seeed XIAO ESP32-C3",
|
|
"altC3Super": "ESP32-C3 SuperMini",
|
|
"thBoard": "Carte",
|
|
"thCpu": "CPU",
|
|
"thFlash": "Flash",
|
|
"thRam": "RAM",
|
|
"boardEsp32C3Name": "ESP32-C3",
|
|
"boardXiaoC3Name": "XIAO ESP32-C3",
|
|
"boardC3SuperName": "C3 SuperMini",
|
|
"cpuValue": "RV32IMC @ 160 MHz",
|
|
"flashValue": "4 Mo",
|
|
"ramValue": "384 Ko DRAM",
|
|
"memoryHeading": "Carte mémoire",
|
|
"thRegion": "Région",
|
|
"thBaseAddr": "Adresse de base",
|
|
"thSize": "Taille",
|
|
"thDescription": "Description",
|
|
"regIrom": "IROM (Flash)",
|
|
"regIromDesc": "Code stocké dans la flash",
|
|
"regDrom": "DROM (Flash R/O)",
|
|
"regDromDesc": "Données en lecture seule dans la flash",
|
|
"regDram": "DRAM",
|
|
"regDramDesc": "RAM de données (pile + tas)",
|
|
"regIram": "IRAM",
|
|
"regIramDesc": "RAM d'instructions (copiée depuis la flash)",
|
|
"regUart": "UART0",
|
|
"regUartDesc": "Port série 0 (GPIO 20/21)",
|
|
"regGpio": "GPIO",
|
|
"regGpioDesc": "Sortie / entrée / activation GPIO",
|
|
"size4mb": "4 Mo",
|
|
"size384kb": "384 Ko",
|
|
"size1kb": "1 Ko",
|
|
"size512b": "512 o",
|
|
"isaHeading": "Support ISA",
|
|
"isaRv32i": "<strong>RV32I</strong>: Jeu d'instructions entier de base (ALU, load/store, branchements, JAL/JALR)",
|
|
"isaRv32m": "<strong>RV32M</strong>: Multiplication/division : MUL, MULH, MULHSU, MULHU, DIV, DIVU, REM, REMU",
|
|
"isaRv32c": "<strong>RV32C</strong>: Instructions compressées 16 bits : C.LI, C.ADDI, C.LUI, C.J, C.JAL, C.BEQZ, C.BNEZ, C.MV, C.ADD, C.JR, C.JALR, C.LW, C.SW, C.LWSP, C.SWSP, C.SLLI, C.ADDI4SPN",
|
|
"compileFlowHeading": "Flux de compilation",
|
|
"compileFlowLead": "Lorsque vous cliquez sur <strong>Compiler + Exécuter</strong> pour une carte ESP32-C3 :",
|
|
"compileStep1": "Le backend compile votre sketch avec <code>arduino-cli</code> en utilisant le cœur <code>esp32:esp32</code>.",
|
|
"compileStep2": "Le binaire résultant est une <strong>image flash fusionnée de 4 Mo</strong> : bootloader à <code>0x1000</code>, table de partition à <code>0x8000</code>, application à <code>0x10000</code>.",
|
|
"compileStep3": "Le <code>esp32ImageParser.ts</code> du frontend trouve l'application à l'offset <code>0x10000</code>, lit l'en-tête d'image ESP32 de 24 octets (magic <code>0xE9</code>), et extrait tous les segments (adresse de chargement + données).",
|
|
"compileStep4": "Chaque segment est écrit dans la région mémoire correcte (IROM, DROM, DRAM ou IRAM) du <code>Esp32C3Simulator</code>.",
|
|
"compileStep5": "Le CPU commence l'exécution à partir du point d'entrée spécifié dans l'en-tête de l'image.",
|
|
"gpioHeading": "Registres GPIO",
|
|
"thRegister": "Registre",
|
|
"thOffset": "Offset",
|
|
"regOutDesc": "Valeur de sortie actuelle",
|
|
"regW1tsDesc": "Définir les bits (écrire 1 pour définir)",
|
|
"regW1tcDesc": "Effacer les bits (écrire 1 pour effacer)",
|
|
"regEnableDesc": "Activation de sortie",
|
|
"regInDesc": "États des broches d'entrée",
|
|
"uart0Heading": "UART0",
|
|
"uart0Body": "L'écriture d'un octet à <code>0x60000000</code> (FIFO UART0) déclenche le callback <code>onSerialData</code>, qui envoie les caractères au moniteur série. La lecture à la même adresse dépile la FIFO de réception (utilisée par <code>Serial.read()</code>). Le registre d'état UART retourne toujours 0 (TX prêt).",
|
|
"sourceFilesHeading": "Fichiers source clés",
|
|
"thFile": "Fichier",
|
|
"thRole": "Rôle",
|
|
"fileRiscVCoreDesc": "Interpréteur RV32IMC (step, hooks MMIO)",
|
|
"fileEsp32C3SimDesc": "Périphériques ESP32-C3, carte mémoire, cycle de vie",
|
|
"fileImageParserDesc": "Analyse l'image flash fusionnée, extrait les segments",
|
|
"fullDetailsCallout": "<strong>Détails complets :</strong> <a>docs/RISCV_EMULATION.md</a> dans le dépôt."
|
|
},
|
|
"setup": {
|
|
"label": "// état du projet",
|
|
"heading": "État du projet",
|
|
"lead": "Un aperçu complet de toutes les fonctionnalités actuellement implémentées dans Velxio.",
|
|
"avrHeading": "Émulation AVR (avr8js)",
|
|
"thFeature": "Fonctionnalité",
|
|
"thStatus": "Statut",
|
|
"statWorking": "Fonctionnel",
|
|
"featAtmega": "CPU ATmega328p à 16 MHz",
|
|
"featTimers": "Timer0, Timer1, Timer2",
|
|
"featUsart": "USART (Serial)",
|
|
"featAdc": "ADC (<code>analogRead</code>)",
|
|
"featGpio": "GPIO complet (PORTB / PORTC / PORTD)",
|
|
"feat60fps": "Boucle ~60 FPS (267k cycles/trame)",
|
|
"featSpeed": "Contrôle de vitesse (0,1x - 10x)",
|
|
"featPwm": "Surveillance PWM (6 canaux)",
|
|
"featInjection": "Injection externe sur broches (entrées)",
|
|
"compSysHeading": "Système de composants (48+)",
|
|
"featAst": "Découverte automatique via AST",
|
|
"statAstDetected": "48 composants détectés",
|
|
"featPicker": "ComponentPickerModal avec recherche",
|
|
"featCategories": "9 catégories avec filtres",
|
|
"featDynRender": "Rendu générique DynamicComponent",
|
|
"featDnd": "Glisser-déposer sur le canevas",
|
|
"featRotation": "Rotation (incréments de 90 degrés)",
|
|
"featPropsDialog": "Boîte de dialogue des propriétés (clic simple)",
|
|
"featPinOverlay": "Superposition de broches (points cyan cliquables)",
|
|
"partsHeading": "Pièces interactives (16 simulées)",
|
|
"thPart": "Pièce",
|
|
"thType": "Type",
|
|
"partLed": "LED",
|
|
"partRgb": "LED RGB",
|
|
"partLedBar": "Barre de LED (10 LED)",
|
|
"part7Seg": "Afficheur 7 segments",
|
|
"partPushButton": "Bouton poussoir",
|
|
"partPushButton6": "Bouton poussoir 6mm",
|
|
"partSlide": "Interrupteur à glissière",
|
|
"partDipSwitch": "DIP Switch 8",
|
|
"partPot": "Potentiomètre",
|
|
"partSlidePot": "Potentiomètre à glissière",
|
|
"partPhoto": "Photorésistance",
|
|
"partJoystick": "Joystick analogique",
|
|
"partServo": "Servo",
|
|
"partBuzzer": "Buzzer",
|
|
"partLcd1602": "LCD 1602",
|
|
"partLcd2004": "LCD 2004",
|
|
"typeOutput": "Sortie",
|
|
"typeOutputDigPwm": "Sortie (numérique + PWM)",
|
|
"typeInput": "Entrée",
|
|
"typeInputAdc": "Entrée (ADC)",
|
|
"typeInputAdcDigital": "Entrée (ADC + numérique)",
|
|
"typeInputOutput": "Entrée / Sortie",
|
|
"typeOutputAudio": "Sortie (Web Audio)",
|
|
"typeOutputHd44780": "Sortie (HD44780 complet)",
|
|
"wireHeading": "Système de fils",
|
|
"featPinClick": "Création broche à broche par clic",
|
|
"featPreview": "Aperçu en temps réel (tireté vert)",
|
|
"featOrtho": "Routage orthogonal (pas de diagonales)",
|
|
"featSegEdit": "Édition de segments (glissement perpendiculaire)",
|
|
"feat8Colors": "8 couleurs par type de signal",
|
|
"featAutoUpdate": "Mise à jour automatique lors du déplacement des composants",
|
|
"featSnap": "Alignement sur la grille (20 px)",
|
|
"featSelDel": "Sélection et suppression de fils",
|
|
"examplesHeading": "Exemples de projets (8)",
|
|
"thExample": "Exemple",
|
|
"thDifficulty": "Difficulté",
|
|
"exBlink": "Clignotement LED",
|
|
"exTraffic": "Feu de circulation",
|
|
"exButton": "Contrôle par bouton",
|
|
"exFade": "Fondu LED (PWM)",
|
|
"exSerial": "Serial Hello World",
|
|
"exRgbColors": "Couleurs LED RGB",
|
|
"exSimon": "Jeu Simon Says",
|
|
"exLcd": "Afficheur LCD 20x4",
|
|
"catBasics": "Bases",
|
|
"catComm": "Communication",
|
|
"catGames": "Jeux",
|
|
"catDisplaysCat": "Afficheurs",
|
|
"diffBeginner": "Débutant",
|
|
"diffIntermediate": "Intermédiaire",
|
|
"diffAdvanced": "Avancé",
|
|
"troubleshootingHeading": "Dépannage",
|
|
"tsModuleProblem": "<code>Cannot find module '@wokwi/elements'</code> / <code>'avr8js'</code>",
|
|
"tsLedProblem": "La LED ne clignote pas",
|
|
"tsLedSolution": "Compilez d'abord, puis cliquez sur Exécuter. Vérifiez l'affectation des broches dans la boîte de dialogue des propriétés du composant.",
|
|
"tsNewCompProblem": "Nouveau composant absent du sélecteur",
|
|
"tsNewCompSolution": "Voir \"Après la mise à jour de wokwi-elements\" ci-dessus - clonez wokwi-elements dans <code>third-party/</code> puis exécutez <code>npm run generate:metadata</code>.",
|
|
"fullStatusCallout": "<strong>Statut complet :</strong> Voir <a>docs/SETUP_COMPLETE.md</a> dans le dépôt."
|
|
},
|
|
"esp32": {
|
|
"label": "// xtensa",
|
|
"heading": "Émulation ESP32 (Xtensa)",
|
|
"lead": "Les cartes ESP32 et ESP32-S3 utilisent une architecture <strong>Xtensa LX6 / LX7</strong>. Comme aucun émulateur Xtensa de qualité production n'est disponible en pur JavaScript, Velxio utilise un <strong>backend basé sur QEMU</strong> pour ces cartes, le fork lcgamboa avec libqemu-xtensa, compilé en binaire natif et servi par le backend FastAPI.",
|
|
"noteCallout": "<strong>Remarque :</strong> Cette section s'applique aux <strong>ESP32</strong>, <strong>ESP32-S3</strong> (Xtensa) et <strong>ESP32-C3</strong> (RISC-V) - ils partagent tous le même pipeline QEMU lcgamboa, juste avec différents binaires libqemu et cibles machine. Voir <strong>Émulation RISC-V (ESP32-C3)</strong> pour les différences spécifiques au C3.",
|
|
"howHeading": "Fonctionnement",
|
|
"how1": "Le sketch Arduino est compilé par <code>arduino-cli</code> en une image flash ESP32 <code>.bin</code>.",
|
|
"how2": "Le frontend envoie le binaire au backend via WebSocket (<code>Esp32Bridge</code>).",
|
|
"how3": "Le backend lance un processus QEMU avec le plugin Xtensa lcgamboa, charge l'image.",
|
|
"how4": "Les événements GPIO et UART sont transmis via WebSocket au navigateur.",
|
|
"how5": "Le frontend met à jour les états des composants (LED, afficheur, etc.) en temps réel.",
|
|
"boardsHeading": "Cartes supportées",
|
|
"boardEsp32Devkit": "ESP32 DevKit C V4",
|
|
"altEsp32Devkit": "ESP32 DevKit C V4",
|
|
"boardEsp32S3": "ESP32-S3",
|
|
"altEsp32S3": "ESP32-S3",
|
|
"boardEsp32Cam": "ESP32-CAM",
|
|
"altEsp32Cam": "ESP32-CAM",
|
|
"boardXiaoS3": "Seeed XIAO ESP32-S3",
|
|
"altXiaoS3": "Seeed XIAO ESP32-S3",
|
|
"boardNanoEsp32": "Arduino Nano ESP32",
|
|
"altNanoEsp32": "Arduino Nano ESP32",
|
|
"thBoard": "Carte",
|
|
"thCpu": "CPU",
|
|
"thEmulation": "Émulation",
|
|
"boardEsp32": "ESP32",
|
|
"boardEsp32S3Name": "ESP32-S3",
|
|
"cpuLx6": "Xtensa LX6 double cœur @ 240 MHz",
|
|
"cpuLx7": "Xtensa LX7 double cœur @ 240 MHz",
|
|
"emuQemu": "QEMU (lcgamboa)",
|
|
"peripheralsHeading": "Support périphérique",
|
|
"perGpio": "<strong>GPIO</strong> : sortie/entrée numérique, contrôle LED",
|
|
"perUart": "<strong>UART</strong> : moniteur série via <code>Serial.print()</code>",
|
|
"perI2cSpi": "<strong>I2C / SPI</strong> : communication périphérique",
|
|
"perRmt": "<strong>RMT / NeoPixel</strong> : bandeaux LED adressables",
|
|
"perLedc": "<strong>LEDC / PWM</strong> : canaux PWM matériels",
|
|
"perWifi": "<strong>WiFi</strong> : partiel (événements de connexion transmis)",
|
|
"requirementsHeading": "Prérequis",
|
|
"requirementsBody": "L'émulation basée sur QEMU nécessite que le backend Velxio soit en cours d'exécution. Cela signifie qu'elle fonctionne avec la <strong>version hébergée</strong> sur <a>velxio.dev</a> et avec <strong>l'auto-hébergement Docker</strong>, mais pas dans un déploiement frontend statique pur.",
|
|
"fullDetailsCallout": "<strong>Détails complets :</strong> <a>docs/ESP32_EMULATION.md</a> dans le dépôt."
|
|
},
|
|
"roadmap": {
|
|
"label": "// futur",
|
|
"heading": "Feuille de route",
|
|
"lead": "Fonctionnalités implémentées, en cours et prévues pour les futures versions de Velxio.",
|
|
"implementedHeading": "Implémenté",
|
|
"impMonaco": "Éditeur Monaco avec coloration syntaxique C++, autocomplétion et minimap",
|
|
"impMultiFile": "Espace de travail multi-fichiers, créer, renommer, supprimer et basculer entre les fichiers",
|
|
"impArduinoCli": "Compilation Arduino via <code>arduino-cli</code> (support sketch multi-fichiers)",
|
|
"impAvr": "Émulation réelle ATmega328p / ATmega2560 à 16 MHz via avr8js",
|
|
"impPeripherals": "Support complet GPIO, Timers, USART, ADC, SPI, I2C",
|
|
"impRp2040": "Émulation réelle RP2040 à 133 MHz via rp2040js",
|
|
"impWokwi": "48+ composants wokwi-elements avec sélecteur de composants",
|
|
"impWires": "Création de fils, routage orthogonal et édition par segments",
|
|
"impSerial": "Moniteur série avec détection automatique du débit en baudes et support d'envoi",
|
|
"impLibMgr": "Gestionnaire de bibliothèques (parcourir et installer les bibliothèques Arduino)",
|
|
"impAuth": "Authentification par email/mot de passe et Google OAuth",
|
|
"impProjects": "Sauvegarde, mise à jour, suppression de projets avec URLs permanentes",
|
|
"impExamples": "8 exemples de projets intégrés",
|
|
"impDocker": "Image Docker mono-conteneur publiée sur GHCR + Docker Hub",
|
|
"inProgressHeading": "En cours",
|
|
"ipWires": "Connexions filaires fonctionnelles, routage et validation des signaux électriques",
|
|
"ipWireErrors": "Gestion des erreurs de connexion filaire, détection des courts-circuits et connexions invalides",
|
|
"nearTermHeading": "Prévu : Court terme",
|
|
"ntUndoRedo": "Annuler / rétablir pour les modifications de code et du canevas",
|
|
"ntExport": "Exporter / importer des projets sous forme de fichiers <code>.zip</code>",
|
|
"ntMoreBoards": "Plus de cartes, ESP32, Arduino Leonardo",
|
|
"ntBreadboard": "Plaque d'essai, placer des composants avec routage automatique des fils",
|
|
"midTermHeading": "Prévu : Moyen terme",
|
|
"mtTypeDoc": "Documentation API TypeDoc, générée automatiquement à partir du code source",
|
|
"mtGhPages": "Site de documentation GitHub Pages, déploiement automatique sur push vers <code>main</code>",
|
|
"mtSensors": "Plus de simulations de capteurs, HC-SR04, DHT22, récepteur IR",
|
|
"mtEeprom": "Émulation EEPROM, lecture/écriture persistante entre les redémarrages de simulation",
|
|
"mtScope": "Composant oscilloscope, tracer les tensions des broches analogiques dans le temps",
|
|
"longTermHeading": "Prévu : Long terme",
|
|
"ltMultiplayer": "Multijoueur, partager et co-éditer des simulations en temps réel",
|
|
"ltTutorials": "Système de tutoriel intégré, projets guidés étape par étape dans l'éditeur",
|
|
"ltSdk": "SDK de composants personnalisés, définir de nouveaux composants avec une API JSON/TypeScript",
|
|
"ltMobile": "Support mobile / tablette, mise en page responsive pour les écrans tactiles",
|
|
"contributeCallout": "<strong>Vous voulez contribuer ?</strong> Les demandes de fonctionnalités, rapports de bugs et pull requests sont les bienvenus sur <a>github.com/davidmonterocrespo24/velxio</a>."
|
|
},
|
|
"emulator": {
|
|
"label": "// internes",
|
|
"heading": "Architecture de l'émulateur",
|
|
"lead": "Velxio utilise une <strong>émulation CPU réelle</strong> plutôt qu'un modèle simplifié. Ce document décrit le fonctionnement de chaque couche de la simulation.",
|
|
"dataFlowHeading": "Flux de données haut niveau",
|
|
"avr8Heading": "Émulation AVR8 (Arduino Uno / Nano / Mega)",
|
|
"avr8Body": "Le backend AVR utilise <a>avr8js</a>, qui implémente un processeur ATmega328p / ATmega2560 complet.",
|
|
"execLoopHeading": "Boucle d'exécution",
|
|
"execLoopBody": "Chaque trame d'animation exécute environ 267 000 cycles CPU (16 MHz / 60 FPS) :",
|
|
"peripheralsHeading": "Périphériques supportés",
|
|
"thPeripheral": "Périphérique",
|
|
"thDetails": "Détails",
|
|
"perGpio": "GPIO",
|
|
"perGpioDetail": "PORTB (broches 8-13), PORTC (A0-A5), PORTD (broches 0-7)",
|
|
"perTimers": "Timer0 / Timer1 / Timer2",
|
|
"perTimersDetail": "<code>millis()</code>, <code>delay()</code>, PWM via <code>analogWrite()</code>",
|
|
"perUsart": "USART",
|
|
"perUsartDetail": "Émission et réception complètes, alimente le moniteur série",
|
|
"perAdc": "ADC",
|
|
"perAdcDetail": "10 bits, référence 5 V sur les broches A0-A5",
|
|
"perSpi": "SPI",
|
|
"perSpiDetail": "SPI matériel (permet ILI9341, carte SD, etc.)",
|
|
"perI2c": "I2C (TWI)",
|
|
"perI2cDetail": "I2C matériel avec bus de périphériques virtuels",
|
|
"pinMappingHeading": "Correspondance des broches",
|
|
"thArduinoPin": "Broche Arduino",
|
|
"thAvrPort": "Port AVR",
|
|
"thBit": "Bit",
|
|
"rp2040Heading": "Émulation RP2040 (Raspberry Pi Pico)",
|
|
"rp2040Body": "Le backend RP2040 utilise <a>rp2040js</a>.",
|
|
"rp2040Bullet1": "Émulation réelle RP2040 à 133 MHz",
|
|
"rp2040Bullet2": "Sortie série UART0 affichée dans le moniteur série",
|
|
"rp2040Bullet3": "ADC 12 bits sur GPIO 26-29 (A0-A3) avec référence 3,3 V",
|
|
"hexHeading": "Format de fichier HEX",
|
|
"hexBody": "La compilation Arduino produit le format <strong>Intel HEX</strong>. L'analyseur dans <code>hexParser.ts</code> :",
|
|
"hex1": "Lit les lignes commençant par <code>:</code>",
|
|
"hex2": "Extrait l'adresse, le type d'enregistrement et les octets de données",
|
|
"hex3": "Retourne un <code>Uint8Array</code> des octets du programme",
|
|
"hex4": "<code>AVRSimulator</code> convertit cela en <code>Uint16Array</code> (mots 16 bits, little-endian)",
|
|
"sourceFilesHeading": "Fichiers source clés",
|
|
"thFile": "Fichier",
|
|
"thPurpose": "Objectif",
|
|
"fileAvrSimDesc": "Wrapper de l'émulateur CPU AVR8",
|
|
"filePinManagerDesc": "Mappe les broches Arduino aux composants UI",
|
|
"fileHexParserDesc": "Analyseur Intel HEX",
|
|
"fileSimCanvasDesc": "Rendu du canevas",
|
|
"fileArduinoCliDesc": "Wrapper arduino-cli",
|
|
"fileCompileRouteDesc": "Point d'API de compilation"
|
|
},
|
|
"architecture": {
|
|
"label": "// conception système",
|
|
"heading": "Architecture du projet",
|
|
"lead": "Velxio est un émulateur Arduino entièrement local utilisant les dépôts officiels Wokwi pour une compatibilité maximale. Il propose une émulation CPU AVR8 réelle, 48+ composants électroniques interactifs, un système de fils complet et un pipeline de découverte de composants à la compilation.",
|
|
"overviewHeading": "Vue d'ensemble haut niveau",
|
|
"dataFlowsHeading": "Flux de données",
|
|
"compilationHeading": "1. Compilation",
|
|
"simLoopHeading": "2. Boucle de simulation",
|
|
"inputCompsHeading": "3. Composants d'entrée",
|
|
"storesHeading": "Stores frontend clés (Zustand)",
|
|
"thStore": "Store",
|
|
"thKeyState": "État clé",
|
|
"storeEditorState": "files[], activeFileId",
|
|
"storeEditorPurpose": "Espace de travail Monaco multi-fichiers",
|
|
"storeSimState": "simulator, components, wires, running",
|
|
"storeSimPurpose": "État de la simulation + canevas",
|
|
"storeAuthState": "user, token",
|
|
"storeAuthPurpose": "Authentification (localStorage persisté)",
|
|
"storeProjectState": "projectId, slug",
|
|
"storeProjectPurpose": "Projet actuellement ouvert",
|
|
"routesHeading": "Routes backend",
|
|
"thRoute": "Route",
|
|
"routeCompileDesc": "Compiler les fichiers sketch - Intel HEX / UF2",
|
|
"routeBoardsDesc": "Lister les cartes disponibles",
|
|
"routeAuthDesc": "Email/mot de passe + Google OAuth",
|
|
"routeProjectsDesc": "Persistance CRUD des projets (SQLite)",
|
|
"routeLibsDesc": "Intégration du gestionnaire de bibliothèques Arduino",
|
|
"routeHealthDesc": "Point de terminaison de vérification de santé",
|
|
"wireSysHeading": "Système de fils",
|
|
"wireSysLead": "Les fils sont stockés comme des objets avec des points de départ/fin liés aux positions des broches des composants :",
|
|
"wireBullet1": "Routage orthogonal, pas de segments diagonaux",
|
|
"wireBullet2": "Glissement de segment, glisser perpendiculairement à l'orientation du segment",
|
|
"wireBullet3": "Mise à jour automatique, les positions des fils sont recalculées lorsque les composants bougent",
|
|
"wireBullet4": "Alignement sur la grille, grille de 20 px pour tous les points d'extrémité des fils",
|
|
"fullDetailsCallout": "<strong>Détails complets :</strong> Voir <a>docs/ARCHITECTURE.md</a> dans le dépôt."
|
|
},
|
|
"intro": {
|
|
"label": "// aperçu",
|
|
"heading": "Introduction",
|
|
"lead": "<strong>Velxio</strong> est un émulateur Arduino open-source entièrement local qui fonctionne entièrement dans votre navigateur. Écrivez du code Arduino C++, compilez-le avec un vrai backend <code>arduino-cli</code>, et simulez-le en utilisant une véritable émulation CPU AVR8 / RP2040, avec 48+ composants électroniques interactifs, le tout sans installer de logiciel sur votre machine.",
|
|
"whyHeading": "Pourquoi Velxio ?",
|
|
"whyNoInstall": "<strong>Aucune installation requise</strong> : tout fonctionne dans le navigateur.",
|
|
"whyRealEmulation": "<strong>Émulation réelle</strong> : pas un modèle simplifié, mais une émulation CPU AVR8 / RP2040 précise.",
|
|
"whyInteractive": "<strong>Composants interactifs</strong> : LED, boutons, potentiomètres, afficheurs, capteurs, et plus.",
|
|
"whyOpenSource": "<strong>Open-source</strong> : inspectez, modifiez et auto-hébergez-le vous-même.",
|
|
"boardsHeading": "Cartes supportées",
|
|
"thBoard": "Carte",
|
|
"thCpu": "CPU",
|
|
"thEmulator": "Émulateur",
|
|
"boardArduinoUno": "Arduino Uno",
|
|
"boardArduinoNano": "Arduino Nano",
|
|
"boardArduinoMega": "Arduino Mega",
|
|
"boardPiPico": "Raspberry Pi Pico",
|
|
"boardEsp32C3": "ESP32-C3 / XIAO C3 / C3 SuperMini",
|
|
"boardEsp32": "ESP32 / ESP32-S3",
|
|
"cpuAtmega328p": "ATmega328p @ 16 MHz",
|
|
"cpuAtmega2560": "ATmega2560 @ 16 MHz",
|
|
"cpuRp2040": "RP2040 @ 133 MHz",
|
|
"cpuRv32imc": "RV32IMC @ 160 MHz",
|
|
"cpuXtensa": "Xtensa LX6/LX7 @ 240 MHz",
|
|
"emuAvr8js": "avr8js",
|
|
"emuRp2040js": "rp2040js",
|
|
"emuEsp32C3": "Esp32C3Simulator (navigateur)",
|
|
"emuQemu": "QEMU (lcgamboa)",
|
|
"liveDemoCallout": "<strong>Démo en direct :</strong> <a>velxio.dev</a>, aucune installation nécessaire, ouvrez l'éditeur et commencez à simuler immédiatement."
|
|
},
|
|
"nav": {
|
|
"intro": "Introduction",
|
|
"gettingStarted": "Pour commencer",
|
|
"emulator": "Architecture de l'émulateur",
|
|
"riscvEmulation": "Émulation RISC-V (ESP32-C3)",
|
|
"esp32Emulation": "Émulation ESP32 (Xtensa)",
|
|
"rp2040Emulation": "Émulation RP2040 (Raspberry Pi Pico)",
|
|
"raspberryPi3Emulation": "Émulation Raspberry Pi 3 (QEMU)",
|
|
"components": "Référence des composants",
|
|
"architecture": "Architecture du projet",
|
|
"thirdParty": "Bibliothèques Wokwi",
|
|
"mcp": "Serveur MCP",
|
|
"setup": "État du projet",
|
|
"roadmap": "Feuille de route",
|
|
"buildQemu": "Compiler QEMU"
|
|
}
|
|
}
|
|
}
|