Traduction automatique, non relue par un locuteur natif. L'anglais fait foi.

API et intégrationsModifier sur GitHubSource : README.crates.md

Kshana : la marque, un réticule de boussole marquant l'instant précis, à côté du logotype kshanaKshana : la marque, un réticule de boussole marquant l'instant précis, à côté du logotype kshana

Kshana · क्षण · l'instant précis
Un simulateur open source pour la résilience PNT (positionnement, navigation et synchronisation temporelle).

Version v0.40.0 176 capacités sur 401 vérifiées par rapport à des références externes indépendantes Environ 95 % de couverture de lignes, imposée à 85 % en intégration continue Licence : AGPL-3.0-only, ou une licence commerciale DOI 10.5281/zenodo.20528627

Répétez la minute où le GNSS s'éteint : la console de mission de Kshana, tracée à partir d'une exécution réelle du moteur, une campagne enchaînée de brouillage, de leurrage, de holdover et d'intégrité sur les 102 satellites de GPS, Galileo, BeiDou et GLONASSRépétez la minute où le GNSS s'éteint : la console de mission de Kshana, tracée à partir d'une exécution réelle du moteur, une campagne enchaînée de brouillage, de leurrage, de holdover et d'intégrité sur les 102 satellites de GPS, Galileo, BeiDou et GLONASS

Répétez la minute où le GNSS s'éteint#

Kshana rejoue le brouillage, le leurrage et le holdover d'horloge lorsque les signaux GNSS (Global Navigation Satellite System) défaillent, et vous dit combien de temps un système garde l'heure et la position dans son budget, et quelle horloge ou quel capteur apporte le plus de marge. Voici le crate Rust : le moteur sous forme de bibliothèque, et la commande kshana. Chaque exécution est reproductible bit à bit à partir du scénario, de la graine et de la version du moteur.

Essayez d'abord sans rien installer : Kshana Studio exécute tout le moteur dans votre navigateur, compilé en WebAssembly, et ne téléverse rien.

Preuves#

176 sur 401 capacités vérifiées par rapport à des références externes indépendantes ; 221 honnêtement étiquetées modélisées, 4 détenues par un partenaire. Chaque capacité porte une étiquette dans un registre vérifié par machine : VALIDATED (une référence externe indépendante concorde : données réelles, implémentation indépendante ou vecteurs de référence publiés), MODELLED (cohérent en interne, et dit à voix haute) ou PARTNER (un partenaire matériel la détient). Parmi les vérifications : les 666 vecteurs SGP4 (Simplified General Perturbations 4) de l'AIAA (American Institute of Aeronautics and Astronautics) 2006-6753 à 4,12 mm, et le modèle de forces de Cowell à 0,08 m près par rapport à Orekit 12,2.

Comment une capacité obtient son étiquette : capacité, référence indépendante, test, étiquette du registre. L'état de vérification sur l'ensemble des 401 capacités : 176 vérifiées, 221 modélisées, 4 détenues par un partenaireComment une capacité obtient son étiquette : capacité, référence indépendante, test, étiquette du registre. L'état de vérification sur l'ensemble des 401 capacités : 176 vérifiées, 221 modélisées, 4 détenues par un partenaire

Installation#

cargo add kshana            # use the engine as a library
cargo install kshana        # or install the command-line interface (CLI)

Utilisation — bibliothèque#

L'exemple est un programme complet : il porte son propre scénario, écrit en TOML (Tom's Obvious, Minimal Language), de sorte qu'il s'exécute comme src/main.rs d'un projet cargo new neuf après cargo add kshana, sans rien d'autre sur le disque.

use kshana::api;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A complete scenario, not a sketch: scenarios/clock-holdover.toml without its
    // comment lines. It runs 2 h, 10 min of GNSS then about 1.8 h with GNSS denied, and
    // asks how long a strontium optical clock and a chip-scale atomic clock (CSAC) each
    // hold time to within 20 ns. sigma_y(1s) is a clock's Allan deviation at an averaging
    // time of one second; q_wf, the white-frequency-noise intensity, is its square.
    let toml = r#"
seed = 42
threshold_ns = 20.0

[time]
step_s = 10.0
duration_s = 7200.0

[gnss]
windows = [
  { t0 = 0.0,    t1 = 600.0,  state = "nominal" },
  { t0 = 600.0,  t1 = 7200.0, state = "denied" },
]

[clock_quantum]
id = "optical-sr-lattice"
provenance = "Strontium optical lattice clock, space-oriented goal sigma_y(1s)=1e-15 (Origlia/Schiller/Bongs et al., arXiv:1503.08457); q_wf=sigma_y(1s)^2; ground-demonstrator maturity, not flown; flicker/aging not modeled"
y0   = 5.0e-17
q_wf = 1.0e-30
q_rw = 0.0

[clock_classical]
id = "csac-sa45s"
provenance = "Microchip SA65 / SA.45s CSAC datasheet sigma_y(1s)=3e-10; q_wf=sigma_y(1s)^2; flicker/aging not modeled"
y0   = 5.0e-10
q_wf = 9.0e-20
q_rw = 0.0
"#;
    let out = api::run_toml(toml)?; // RunOutput { json, svg, summary, csv }
    println!("{}", out.summary); // the one-line result string
    std::fs::write("clock-holdover.result.json", &out.json)?; // the full result document
    Ok(())
}

out.json est le document de résultat en JSON (JavaScript Object Notation), out.svg le graphique en SVG (Scalable Vector Graphics) et out.csv, pour les types de scénario qui publient une table, cette table en CSV (valeurs séparées par des virgules).

Référence de l'API, générée à partir de src/api.rs#

Chaque fonction publique de kshana::api au moteur v0.40.0, lue dans la source à la compilation.

FonctionSignatureCe qu'il fait
kshana::api::without_figure_tiers(json: &str) -> Option<String>json avec son bloc final figure_tiers retiré, octet pour octet tel qu'était le document avant l'existence de ce bloc ; None lorsque le document n'a pas un tel bloc, ou en a un qui n'est pas sa dernière clé (ce que ce crate n'émet jamais, de sorte qu'un harnais doit le traiter comme un échec plutôt que de retirer quelque chose dont il ne peut rendre compte).
kshana::api::list_scenario_kinds() -> Vec<ScenarioMeta>Lister chaque type de scénario intégré avec ses métadonnées.
kshana::api::list_scenario_kinds_json() -> StringLes types de scénario intégrés et leurs métadonnées sous forme de tableau JSON — la forme que les liaisons de langage exposent pour l'introspection programmatique.
kshana::api::kind_description_in(lang: &crate::i18n::Lang, kind: &str) -> Option<String>La description du type de scénario intégré kind dans lang, tirée du catalogue (l'anglais lorsque la langue n'en a pas de traduction) ; None pour un nom qui n'est pas un type intégré.
kshana::api::kind_description(kind: &str) -> Option<String>[kind_description_in] dans la langue courante ([crate::i18n::current]).
kshana::api::list_scenario_kinds_json_lang(lang: &str) -> Result<String, String>[list_scenario_kinds_json] avec chaque description dans lang (une balise comme celle que prend --lang, telle que de ou zh-Hans) ; les noms et les listes de champs sont les mêmes dans toutes les langues, et pour l'anglais le document est identique octet pour octet à [list_scenario_kinds_json].
kshana::api::kind_modules_json() -> String[KIND_MODULES] sous forme d'objet JSON, type de scénario vers tableau de noms de modules, dans l'ordre de la table.
kshana::api::field_importance_json() -> String[HEADLINE_FIELDS] en JSON : {kind: {"headline": [path, ...]}}, dans l'ordre de la table.
kshana::api::scenarios_reference_md() -> StringProduire le catalogue des types de scénario intégrés sous forme de référence Markdown autonome (docs/SCENARIOS.md) : chaque type de scénario pouvant être lancé avec sa description d'une ligne et ses champs TOML obligatoires / facultatifs.
kshana::api::validate_scenario(src: &str) -> Vec<String>Analyser un TOML de scénario avec l'introspection propre du crate et renvoyer une liste de problèmes — afin qu'on puisse dire à l'appelant ce qui ne va pas AVANT une exécution (éventuellement longue), au lieu de se heurter à un échec tardif à l'exécution.
kshana::api::export_sp3(src: &str) -> Result<String, String>Exporter la constellation propagée d'un scénario d'orbite/de constellation sous forme de texte SP3-c.
kshana::api::auto_export_sp3(src: &str) -> Result<Option<String>, String>Si src est un scénario d'orbite avec export_sp3 = true, renvoyer son texte SP3-c ; sinon None.
kshana::api::export_omm(src: &str) -> Result<String, String>Exporter les éléments moyens TLE d'un scénario d'orbite sous forme de catalogue OMM du CCSDS — un OMM (Orbit Mean-Elements Message) par satellite défini par TLE, sous forme KVN, portant le véritable numéro de catalogue NORAD, l'identifiant COSPAR et l'époque de chaque TLE.
kshana::api::auto_export_omm(src: &str) -> Result<Option<String>, String>Si src est un scénario d'orbite avec export_omm = true, renvoyer le texte de son catalogue OMM ; sinon None.
kshana::api::export_oem(src: &str) -> Result<String, String>Exporter la constellation propagée d'un scénario d'orbite sous forme de texte OEM du CCSDS — la série temporelle d'états inertiels (TEME), position ET vitesse, dans le format d'échange d'éphémérides de vaisseau spatial que lisent les outils de dynamique de vol (GMAT/Orekit/STK).
kshana::api::auto_export_oem(src: &str) -> Result<Option<String>, String>Si src est un scénario d'orbite avec export_oem = true, renvoyer son texte OEM ; sinon None.
kshana::api::inject_eop(src: &str, finals2000a_body: &str) -> Result<String, String>Insérer en ligne un véritable corps finals2000A de l'IERS dans le champ eop_finals2000a d'un scénario (le chemin CLI --eop <file>), en renvoyant le TOML fusionné.
kshana::api::with_study_meta(json: &str, meta: &crate::report::StudyMeta) -> StringInsérer un bloc de métadonnées d'étude dans un document JSON de résultat déjà produit, en renvoyant le document avec une clé "meta" de premier niveau insérée juste après l'accolade ouvrante.
kshana::api::run_scenario(src: &str) -> Result<RunOutput, KshanaError>Exécuter un scénario et renvoyer un résultat typé avec une erreur structurée — le point d'entrée que les appelants de liaison devraient préférer à [run_toml], qui renvoie une erreur sous forme de chaîne.
kshana::api::run_toml(src: &str) -> Result<RunOutput, String>Analyser, répartir et exécuter un scénario donné sous forme de chaîne TOML.
kshana::api::run_toml_lang(src: &str, lang: &str) -> Result<RunOutput, String>[run_toml] pour un utilisateur dans la langue lang (une balise telle que de, pt-BR, zh-Hans, en-XA).
kshana::api::run_toml_bilingual(src: &str, lang: &str) -> Result<(RunOutput, Option<RunOutput>), String>Les deux exécutions de [run_toml_lang] gardées séparées : l'exécution anglaise, dont le json et le csv sont les fichiers machine, et, pour une autre langue, l'exécution dans cette langue pour tout ce qu'une personne lit.
kshana::api::run_toml_human(src: &str, lang: &str) -> Result<HumanOutput, String>La seconde passe de [run_toml_bilingual] seule : exécuter le scénario une fois dans lang et ne renvoyer que ce qu'une personne lit.
kshana::api::run_scenario_lang(src: &str, lang: &str) -> Result<RunOutput, KshanaError>[run_scenario] pour un utilisateur dans la langue lang ; voir [run_toml_lang].
kshana::api::error_info_json(src: &str, lang: &str) -> StringExécute src dans la langue lang et, en cas d'échec, décrit l'échec comme un objet JSON {"kind": <kind_tag>, "code": <code stable ou null>, "message": <texte dans la langue>}.
kshana::api::without_evidence(json: &str) -> Stringjson sans l'étiquette de preuve ([crate::evidence_label]) ; inchangé s'il n'en porte aucune.
kshana::api::without_evidence_labels(mut out: RunOutput) -> RunOutputout avec l'étiquette de preuve retirée de son JSON, de son SVG et de son CSV, octet pour octet tel que l'exécution les produisait avant l'existence de l'étiquette ; une sortie sans étiquette est inchangée.
kshana::api::run_toml_untiered(src: &str) -> Result<RunOutput, String>[run_toml] sans le bloc figure_tiers par type de scénario que [run_toml_inner] ajoute (RM-04) : pour une exécution dont le document est intégré dans le résultat d'un autre type de scénario (un membre de campagne), afin que le document externe conserve ses octets.
kshana::api::append_figure_tiers(json: &str, block: &serde_json::Value) -> Result<String, String>json avec bloc ajouté comme dernière clé, figure_tiers, octet pour octet tel que l'enveloppe Documented l'aurait sérialisé : mise en forme sur deux espaces, le bloc imbriqué d'un niveau.

Formats d'échange dans le crate : analyseur et écrivain de CCSDS Tracking Data Message (TDM) (kshana::ccsds_tdm) ; Kshana Interchange Format (KIF) (kshana::interchange).

Utilisation — CLI#

Une installation depuis le registre n'a pas de répertoire scenarios/, de sorte que la CLI emporte avec elle les scénarios de référence ; kshana example les liste, et nomme les quelques-uns qu'elle laisse de côté avec la raison (chacun lit des données livrées avec le dépôt seulement, ou suit un préréglage qu'une version peut retenir).

kshana example clock-holdover > clock-holdover.toml   # write a bundled scenario to a file
kshana clock-holdover.toml                            # run it
kshana --validate clock-holdover.toml                 # lint it without running
kshana example                                        # list every bundled scenario
kshana kinds                                          # list every scenario kind

kshana example orbit-sgp4-gps > orbit-sgp4-gps.toml   # the GPS constellation, real orbital elements
kshana orbit-sgp4-gps.toml --export list              # which exchange formats apply
kshana orbit-sgp4-gps.toml --export all               # every exchange file that applies
kshana orbit-sgp4-gps.toml --animate html             # a self-contained animation page

Une exécution se répartit selon le kind du scénario et écrit <scenario>.result.json, .chart.svg, .report.html (une page de rapport imprimable en HTML, HyperText Markup Language) et .report.json (le même rapport, lisible par machine), plus .table.csv pour les types de scénario qui publient une table, à côté du fichier de scénario. --export ajoute des fichiers d'échange : CZML (le Cesium Language) et KML (Keyhole Markup Language) pour les visualiseurs de globe, GeoJSON pour les cartes, des fichiers d'éphémérides STK (Systems Tool Kit) et des enregistrements SigMF (Signal Metadata Format) pour le type de scénario spectrum. --animate ajoute une animation SVG, HTML ou image par image.

Depuis un clone du dépôt, les mêmes commandes prennent directement les fichiers sous scenarios/, y compris l'étude multi-scénarios (kshana --study scenarios/quantum-pnt-demonstrator.suite.toml) et lunar-llr-datum, le seul scénario qui lit de véritables données de télémétrie laser livrées avec le dépôt seulement.

Chaque capacité de la matrice de vérification est étiquetée validée (vérifiée par rapport à une référence externe indépendante), modélisée ou détenue par un partenaire ; les valeurs des horloges optiques sont des objectifs spatiaux sur du matériel au sol (aucune horloge optique au strontium n'a volé). La maturité n'est pas uniforme selon les domaines — le PNT terrestre est validé par rapport à des données réelles ; la navigation en espace lointain et sur Mars est modélisée, seuls ses éléments constitutifs (temps de lumière, positions des planètes) étant validés par rapport à des références externes ; la détermination d'orbite (OD) de missions réelles en espace lointain figure sur la feuille de route.

Capacités#

Le moteur compte 92 types de scénario ; kshana kinds les liste avec leurs champs. Nouveaux dans la version 0.38.0 : gnss-ssv (signaux GNSS pour des véhicules spatiaux au-dessus, autour et au-delà des orbites GNSS) et lunar-infrastructure (orbite et surface lunaires comme infrastructure de navigation et géodésique), tous deux MODELLED, et holdover-test (un enregistrement d'erreur de temps comparé aux masques de l'ITU-T).

  • Spectre : comment un brouilleur prend la bande L du GNSS, bande par bande.
  • Horloges et synchronisation temporelle : holdover par rapport à un seuil, transfert de temps, et holdover télécom par rapport aux masques du secteur de la normalisation de l'Union internationale des télécommunications (UIT-T).
  • Constellations autour de n'importe quel corps : couverture, dilution de précision et disponibilité autour de la Terre, de la Lune ou de Mars, et le système solaire à une époque.
  • Navigation en orbite terrestre basse : signal, passage et liaison, message de navigation, et position fusionnée, étape par étape.
  • Campagnes : une mission enchaînée, un balayage ou un ensemble de Monte-Carlo dans un seul scénario.
  • Rapports, animation et exportations : chaque valeur avec son unité et son étiquette ; un dessin animé d'une exécution ; des fichiers SP3 (Standard Product 3), des messages d'orbite CCSDS (Consultative Committee for Space Data Systems), CZML (Cesium Language), KML (Keyhole Markup Language), GeoJSON, STK (Systems Tool Kit) et SigMF (Signal Metadata Format).
  • Confiance GNSS d'un navire (receiver_trust, y compris receiver_trust::live) : un score de 0 à 100 avec ses motifs à partir des NMEA d'un récepteur, en direct ou depuis un journal ; à titre consultatif, pas un équipement de navigation homologué.
  • Paquets de preuves (evidence) : un dossier technique signé d'une fenêtre de journal, vérifiable hors ligne.
  • Télémétrie de confiance (telemetry) : le flux de confiance sous forme de métriques Prometheus, d'événements SIEM et d'OpenTelemetry facultatif.
  • Flux de formation (nmea_synth) : NMEA de passerelle synthétiques avec brouillage et leurrage scénarisés et un journal d'instructeur. Texte seulement ; jamais pour les systèmes de navigation réels d'un navire.
  • Carte des interférences (interference_map) : cartes agrégées de navigation dégradée et exposition des itinéraires.
  • Test bench et mise en correspondance de compliance (interop::testbench, compliance) : le mouvement du véhicule et les événements d'un scénario pour un simulateur GNSS de laboratoire, et le rapprochement avec les cadres publics rempli à partir des documents de résultat.
  • Laboratoire IQ GNSS (iq) : scènes, acquisition, poursuite, moniteurs et campagnes sur IQ enregistrés et synthétiques.

Architecture#

Un moteur ouvert au centre, kshana 0.40.0, avec une répartition typée sur 75 types de scénario ; autour de lui, la ligne de commande, la bibliothèque Rust, Python, WebAssembly et Kshana Studio, le serveur MCP, l'image Docker et le greffon JetBrains ; en dessous, Kshana Pro, une surcouche propriétaire qui dépend du moteur ouvert et ne le fork jamaisUn moteur ouvert au centre, kshana 0.40.0, avec une répartition typée sur 75 types de scénario ; autour de lui, la ligne de commande, la bibliothèque Rust, Python, WebAssembly et Kshana Studio, le serveur MCP, l'image Docker et le greffon JetBrains ; en dessous, Kshana Pro, une surcouche propriétaire qui dépend du moteur ouvert et ne le fork jamais

Le même fichier de scénario donne les mêmes octets sur chaque interface. MCP est le Model Context Protocol : kshana-mcp permet à un assistant d'IA (intelligence artificielle) d'exécuter le moteur.

Recherche#

Six articles sur arXiv reposent sur le moteur ouvert, chacun avec la commande qui le sous-tend : arXiv:2606,22054 (l'écart d'optimisme des détecteurs d'interférence), arXiv:2606,24210 (un niveau de protection conditionnel de la synchronisation temporelle), arXiv:2607,05415 (la stabilité d'un score de résilience PNT), arXiv:2607,02566 (l'observabilité des stations de surface lunaire par interférométrie à très longue base), arXiv:2607,06212 (géométrie polaire sud lunaire et balises de surface) et arXiv:2610,23871 (la navigation cislunaire comme problème d'observabilité : longueur d'arc, conditionnement du gramien et effet de levier Doppler). Voir Recherche.

Éditions#

Tout le moteur est libre sous l'AGPL-3.0. Kshana Pro, une surcouche propriétaire qui dépend du moteur ouvert et ne le fork jamais, et des études sur mesure sont disponibles sous contrat auprès d'Ashforde® OÜ : contact@ashforde.org. Il n'y a pas de tarifs ; voir docs/PRO.md.

En savoir plus#

Licence#

Libre et open source sous la GNU AGPL-3.0-only (la GNU Affero General Public License, version 3 seulement). Une licence commerciale est disponible auprès d'Ashforde® OÜ (une société estonienne à responsabilité limitée ; OÜ = osaühing) pour une intégration fermée ; voir LICENSING.md. Développé et maintenu de façon professionnelle par Ashforde® OÜ.