swap to astro starlight

astro.config.mjs

@@ -5,23 +5,26 @@ import starlight from '@astrojs/starlight';
 export default defineConfig({
     integrations: [
         starlight({
-			title: 'My Docs',
-			social: {
-				github: 'https://github.com/withastro/starlight',
-			},
+            title: 'Documentation PLS5618',
             sidebar: [
                 {
-					label: 'Guides',
-					items: [
-						// Each item here is one entry in the navigation menu.
-						{ label: 'Example Guide', link: '/guides/example/' },
-					],
+                    label: 'Java',
+                    autogenerate: { directory: 'java' },
                 },
                 {
-					label: 'Reference',
-					autogenerate: { directory: 'reference' },
+                    label: 'Robot',
+                    items: [
+                        { label: "Débuter", autogenerate: { directory: "robot/debuter" } },
+                        { label: "Nouveau Projet", autogenerate: { directory: "robot/nouveau_projet" } }
+                    ],
                 },
             ],
+            locales: {
+                root: {
+                    label: "Français",
+                    lang: "fr",
+                },
+            }
         }),
     ],
 

src/content/docs/guides/example.md

@@ -1,11 +0,0 @@
----
-title: Example Guide
-description: A guide in my new Starlight docs site.
----
-
-Guides lead a user through a specific task they want to accomplish, often with a sequence of steps.
-Writing a good guide requires thinking about what your users are trying to do.
-
-## Further reading
-
-- Read [about how-to guides](https://diataxis.fr/how-to-guides/) in the Diátaxis framework

src/content/docs/index.md

@@ -0,0 +1,15 @@
+---
+title: Documentation PLS5618
+template: splash
+hero:
+    title: Documentation de PLS 5618
+    actions:
+        - text: Java
+          link: /java/
+          variant: primary
+        - text: Robot
+          link: /robot/
+          variant: primary
+---
+
+

src/content/docs/index.mdx

@@ -1,36 +1,9 @@
 ---
-title: Welcome to Starlight
-description: Get started building your docs site with Starlight.
+title: Documentation PLS 5618
 template: splash
 hero: 
-  tagline: Congrats on setting up a new Starlight project!
-  image:
-    file: ../../assets/houston.webp
-  actions:
-    - text: Example Guide
-      link: /guides/example/
-      icon: right-arrow
-      variant: primary
-    - text: Read the Starlight docs
-      link: https://starlight.astro.build
-      icon: external
 ---
 
-import { Card, CardGrid } from '@astrojs/starlight/components';
+[Java](/java)
+[Robot](/robot)
 
-## Next steps
-
-<CardGrid stagger>
-	<Card title="Update content" icon="pencil">
-		Edit `src/content/docs/index.mdx` to see this page change.
-	</Card>
-	<Card title="Add new content" icon="add-document">
-		Add Markdown or MDX files to `src/content/docs` to create new pages.
-	</Card>
-	<Card title="Configure your site" icon="setting">
-		Edit your `sidebar` and other config in `astro.config.mjs`.
-	</Card>
-	<Card title="Read the docs" icon="open-book">
-		Learn more in [the Starlight Docs](https://starlight.astro.build/).
-	</Card>
-</CardGrid>

src/content/docs/java/classes.md

@@ -0,0 +1,4 @@
+---
+title: Classes
+---
+

src/content/docs/java/index.md

@@ -0,0 +1,11 @@
+---
+title: Introduction
+sidebar:
+    order: 1
+lang: fr
+---
+
+
+
+Pour programmer le robot, nous utilisons le langage de programmation **Java**.
+Dans cette section, vous allez apprendre les bases de Java.

src/content/docs/java/syntaxe.md

@@ -0,0 +1,4 @@
+---
+title: Syntaxe
+lang: fr
+---

src/content/docs/java/try-catch.md

@@ -0,0 +1,3 @@
+---
+title: Try-Catch
+---

src/content/docs/java/variables.md

@@ -0,0 +1,63 @@
+---
+title: Variables et Types
+lang: fr
+sidebar:
+    order: 2
+---
+
+
+En Java, comme dans plusieurs langagues de programmation, l'information est stockée dans des [variables](#variables). Ces variables ont toutes un [type](#types), qui permet de déterminer ce qu'elles peuvent contenir.
+
+## Variables
+
+Une variable représente un espace en mémoire pour stocker de l'information.
+Chaque variable a un **nom**, un **type** et contient de l'information. Pour créer un variable, on l'écrit `type nom = valeur`. À savoir que la valeur est optionnelle, car elle peut être donnée plus tard.
+
+## Types
+
+Il existe plusieurs types pour les variables, certains viennent dans Java, mais il est aussi possible pour vous d'en créer. Certains types ne font que stocker une donnée, ils sont donc de types [primitifs](#primitifs). D'autres ont aussi de la fonctionnalité, ce sont des [classes](#classes).
+
+### Primitifs
+
+Les types primitifs ne font que stocker de la donnée. En Java, il existe 8 types primitifs qui permettes de stocker des **nombres**, **charactères** et **vrai/faux**.
+
+Voici les différents types primitifs
+
+| **Type**  | **Stockage**                                 |
+| --------- | -------------------------------------------- |
+| _int_     | _Nombre entier_                              |
+| byte      | Peut stocker n'importe quoi, mais très petit |
+| short     | Petit nombre entier                          |
+| long      | Très grand nombre entier                     |
+| float     | Nombre à virgule                             |
+| _double_  | _Nombre à virgule plus précis_               |
+| _boolean_ | _Vrai/Faux_                                  |
+| char      | Charactère                                   |
+
+:::note
+Les types en italique (_int_, _double_, _boolean_) sont les plus utiles.
+:::
+
+Voici comment créer un `double`:
+
+```java
+double nombre = 4.2;
+```
+
+### Classes
+
+Les classes permettent d'ajouter de la fonctionnalité à une variable. Elles permettent aussi de regrouper plusiers variables ensemble. On les reconnait par le fait que leur nom commence par une majuscule (les types primitifs commencent tous par une minuscule). Un exemple de classe qui vient avec Java est le `String`, qui contient une chaine de charactères (`char`). Ça permet donc de stocker des mots ou des phrases. Les string ajoute aussi quelques fonctionalités qui permettent de séparer une phrase en mots ou de savoir la longueur de la chaine de charactère par exemple.
+
+:::info
+Plus d'information sur les classes est donnée dans la section [classes](./classes).
+:::
+
+Voici comment créer un `String`:
+
+```java
+String phrase = "Hello World!";
+```
+
+:::note
+Vous remarquez que dans les exemples sur cette page, les lignes finissent toutes par `;`. Pour en savoir plus, lisez la page [syntaxe](./syntaxe)
+:::

src/content/docs/reference/example.md

@@ -1,11 +0,0 @@
----
-title: Example Reference
-description: A reference page in my new Starlight docs site.
----
-
-Reference pages are ideal for outlining how things work in terse and clear terms.
-Less concerned with telling a story or addressing a specific use case, they should give a comprehensive outline of what your documenting.
-
-## Further reading
-
-- Read [about reference](https://diataxis.fr/reference/) in the Diátaxis framework

src/content/docs/robot/debuter/creer_projet.md

@@ -0,0 +1,8 @@
+---
+title: Créer un projet
+lang: fr
+sidebar:
+    order: 2
+---
+
+

src/content/docs/robot/debuter/installation.md

@@ -0,0 +1,25 @@
+---
+title: Installation
+lang: fr
+sidebar:
+    order: 1
+---
+
+
+Pour programmer un robot _FRC_, nous avons plusieurs choses à installer:
+
+- Les [outils de développement](#outils-de-développement), qui permettent de programmer le robot et déployer le programme sur un robot
+- Les [outils de jeux](#outils-de-jeu), qui permettent de controler le robot
+- L'[outil de configuration de radio](#outil-de-configuration-de-radio) (optionnel), qui permet de configurer le routeur du robot
+
+## Outils de développement
+
+Les outils de développement sont les outils qui permettent de créer un programme pour le robot et de l'envoyer sur le robot. L'outil principal est l'éditeur [VSCode](https://code.visualstudio.com/) avec des extensions faites pour le développement d'un robot _FRC_.
+
+Pour télécharger les outils, vous pouvez aller sur leur [page GitHub](https://github.com/wpilibsuite/allwpilib/releases/), descendre et télécharger le fichier `WPILib_Windows-xxx.x.x.iso` pour la version la plus récente disponible.
+
+![page github](/img/installation/github.png)
+
+## Outils de jeu
+
+## Outil de configuration de Radio

src/content/docs/robot/index.md

@@ -0,0 +1,12 @@
+---
+title: Introduction
+lang: fr
+sidebar:
+    order: 1
+---
+
+
+Comme vous l'aurez compris avec la section [Java](../java/), un robot _FRC_ peut être programmé en Java.
+Il peut aussi être programmé en _C++_, _LabView_ ou _Python_, mais nous avons choisi _Java_ pour sa simplicité et sa robustesse.
+
+Dans cette section, vous apprendrez comment programmer un robot _FRC_ en _Java_ en utilisant la bibliothèque [WPILib](https://docs.wpilib.org/)

src/content/docs/robot/nouveau_projet/advantagekit.md

@@ -0,0 +1,79 @@
+---
+title: Installer AdvantageKit
+lang: fr
+sidebar:
+    order: 2
+---
+
+
+AdvantageKit permet de recevoir plus d'information du robot, ce qui nous aidera à debug.
+
+[Plus d'information](https://github.com/Mechanical-Advantage/AdvantageKit/blob/main/docs/INSTALLATION.md)
+
+## Ajouter le répertoire d'AdvantageKit
+
+Ajouter ce code à la fin du fichier `build.gradle` pour ajouter le repertoire d'AdvantageKit.
+
+```groovy
+repositories {
+    maven {
+        url = uri("https://maven.pkg.github.com/Mechanical-Advantage/AdvantageKit")
+        credentials {
+            username = "Mechanical-Advantage-Bot"
+            password = "\u0067\u0068\u0070\u005f\u006e\u0056\u0051\u006a\u0055\u004f\u004c\u0061\u0079\u0066\u006e\u0078\u006e\u0037\u0051\u0049\u0054\u0042\u0032\u004c\u004a\u006d\u0055\u0070\u0073\u0031\u006d\u0037\u004c\u005a\u0030\u0076\u0062\u0070\u0063\u0051"
+        }
+    }
+}
+```
+
+Il faut aussi ajouter ce code en dessous pour remplacer certaines fonctionalités de WPILib par celles de AdvantageKit.
+
+```groovy
+configurations.all {
+    exclude group: "edu.wpi.first.wpilibj"
+}
+```
+
+## Ajout dans le programme
+
+Il faut ensuite ajouter les bibliothèques qui permettent de choisir quoi enregistrer.
+
+### Bibliothèques
+
+Il faut utiliser la même technique que dans [Bibliothèques de composants](./vendor_libraries) avec le lien suivant:
+
+```
+https://github.com/Mechanical-Advantage/AdvantageKit/releases/latest/download/AdvantageKit.json
+```
+
+### Configuration du robot
+
+Il faut ensuite aller remplacer le type de robot pour celui de AdvantageKit dans `Robot.java`:
+
+```java
+public class Robot extends LoggedRobot {
+    ...
+}
+```
+
+Ensuite, dans `robotInit()` ajoutez les lignes suivantes:
+
+```java
+Logger.getInstance().recordMetadata("ProjectName", "5618BOT");
+if (isReal()) {
+    Logger.getInstance().addDataReceiver(new WPILOGWriter("/media/sda1/"));
+    new PowerDistribution(1, ModuleType.kCTRE);
+}
+Logger.getInstance().addDataReceiver(new NT4Publisher());
+Logger.getInstance().start();
+```
+
+:::caution
+Il faut importer le `Logger` de `org.littletonrobotics.junction.Logger`.
+:::
+
+:::note
+Remplacer le ModuleType du PowerDistribution par kREV selon le PDP utilisé.
+:::
+
+AdvantageKit est installé. Vous pouvez maintenant utiliser [AdvantageScope](https://github.com/Mechanical-Advantage/AdvantageScope).

src/content/docs/robot/nouveau_projet/vendor_libraries.md

@@ -0,0 +1,37 @@
+---
+title: Bibliothèques de composants
+lang: fr
+sidebar:
+    order: 1
+---
+
+
+NavX
+
+```
+https://dev.studica.com/releases/2023/NavX.json
+```
+
+Phoenix (CTRE)
+
+```
+https://maven.ctr-electronics.com/release/com/ctre/phoenix/Phoenix5-frc2023-latest.json
+```
+
+REV
+
+```
+https://software-metadata.revrobotics.com/REVLib-2023.json
+```
+
+AdvantageKit (voir [AdvantageKit](./advantagekit))
+
+```
+https://github.com/Mechanical-Advantage/AdvantageKit/releases/latest/download/AdvantageKit.json
+```
+
+YAGSL (Swerve, voir [YAGSL](./yagsl.md))
+
+```
+https://broncbotz3481.github.io/YAGSL-Lib/yagsl/yagsl.json
+```

src/content/docs/robot/nouveau_projet/yagsl.md

@@ -0,0 +1,46 @@
+---
+title: YAGSL (Swerve)
+lang: fr
+sidebar:
+    order: 3
+---
+
+
+[Yet Another Generic Swerve Library](https://github.com/BroncBotz3481/YAGSL) permet de facilement créer un sous-système swerve pour un robot.
+
+Plus d'information sera ajoutée, mais pour l'instant vous pouvez suivre la documentation [ici](https://github.com/BroncBotz3481/YAGSL)
+
+## Installation
+
+Installer les [bibliothèques](vendor_libraries.md) de NavX, Phoenix, REV et YAGSL.
+
+## Configuration
+
+Pour utiliser la bibliothèque, nous devons lui fournir des fichiers de configuration qui décrivent notre système swerve (les différents moteurs et leurs ID, entre autres).
+
+Vous pouvez donc aller chercher le dossier d'[exemple](https://github.com/BroncBotz3481/YAGSL/tree/main/deploy) ou le [créer vous-même](https://broncbotz3481.github.io/YAGSL-Example/). Vous devez mettre le dossier `swerve` dans le dossier `deploy` de votre projet.
+
+## Utilisation
+
+1. Créer un subsystem pour le swerve
+2. Créer une variable `SwerveDrive`
+3. Créer le `SwerveDrive` à partir de la configuration
+
+```java
+SwerveDrive swerveDrive;
+
+  /** Creates a new SwerveSubsystem. */
+  public SwerveSubsystem(File file) {
+    try {
+      this.swerveDrive = new SwerveParser(file).createSwerveDrive();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+```
+
+:::note
+Ici, on utilise un [try-catch](../../java/try-catch){target="\_blank"}, car il pourrait y avoir une erreur si les fichiers de configuration n'existent pas;
+:::
+
+Vous devrez ensuite ajouter vos méthodes pour intéragir avec le `SwerveDrive` dans le subsystem.