# IoToS — Internet of Things Operating System

```
╔══════════════════════════════════════════════════════════════════════════════╗
║  [ IoToS ]  Internet of Things OS                                            ║
║  Arduino UNO R4 Minima · Renesas RA4M1 · ARM Cortex-M4                       ║
║  Licence : GNU LGPL v2.1                                                     ║
╚══════════════════════════════════════════════════════════════════════════════╝
```

**IoToS** est un micro-système d'exploitation embarqué multi-services pour Arduino UNO R4 Minima
équipé du Shield Ethernet 2 (W5500). Il expose simultanément une CLI réseau Serial/Telnet,
un serveur WEB AJAX avec pages HTML stockées sur MicroSD, un serveur FTP, une synchronisation NTP,
un datalogger CSV horodaté, un afficheur LCD et une persistance EEPROM — le tout sur un ARM
Cortex-M4 sans système d'exploitation temps réel, selon un modèle de **noyau coopératif**.

Développé à l'Institution Saint-Jean, école d'Électronique, Informatique et Réseau de Colmar.

---

## Pourquoi un « Micro OS » ?

Sur un Arduino, il est impossible de lancer un exécutable à la volée comme sous Windows ou Linux.
L'Arduino est câblé en permanence sur un système physique (prise IP, alarme, capteurs…) et le
firmware **est** le programme : il n'y a pas de processus à démarrer ou à arrêter.

IoToS adopte l'analogie système d'exploitation pour structurer ce firmware :

| Concept OS classique | Équivalent IoToS                                    |
| -------------------- | --------------------------------------------------- |
| Load Firmware        | `avant setup()` — déclarations, `#include`, macros  |
| Boot Loader          | `setup()` — initialisation séquentielle des modules |
| Noyau coopératif     | `loop()` — tour de rôle des handle*() non-bloquants |
| Shell / /bin/        | CmdLine (Serial + Telnet) + fichiers .h             |
| Drivers              | Bibliothèques (SdFat, U8g2, Ethernet…)              |
| Système de fichiers  | Micro SD FAT32 + EEPROM interne                     |
| -------------------- | --------------------------------------------------- |

La différence fondamentale avec un vrai OS : **pas de préemption, pas d'exécutable lancé à chaud**.
Chaque service est implanté directement dans le code ; `loop()` joue le rôle du scheduler coopératif,
exactement comme Windows 3.x ou MS-DOS multitâche.

---

## Versions du projet

Trois variantes du firmware selon l'équipement matériel disponible :

```
PriseIP_UNOR4_jsWEB_SD_FTP_LogCmdLine_IDE2_v72           ← sans écran
PriseIP_UNOR4_jsWEB_SD_FTP_LogCmdLine_LCDBlack_IDE2_v72  ← écran I²C, affichage messages
PriseIP_UNOR4_jsWEB_SD_FTP_LogCmdLine_LCDiMenu_IDE2_v72  ← écran I²C + menu 3 boutons
```

| Fonctionnalité           |  v72 base | v72 LCDBlack  | v72 LCDiMenu  |
| ------------------------ | --------- | ------------- | ------------  |
| Serveur WEB AJAX         | ✅        | ✅            | ✅            |
| Serveur FTP              | ✅        | ✅            | ✅            |
| CLI Serial + Telnet      | ✅        | ✅            | ✅            |
| Datalogger NTP CSV       | ✅        | ✅            | ✅            |
| Ping / Tracert / Netstat | ✅        | ✅            | ✅            |
| Écran LCD ST7567S        | ❌        | ✅ affichage  | ✅ affichage  |
| Menu 3 boutons LCD       | ❌        | ❌            | ✅            |
| Watchdog matériel        | ❌        | ❌            | ❌            |
| OTA Ethernet             | ❌        | ❌            | ❌            |
| Envoi Mail SMTP          | ❌        | ❌            | ❌            |

---

## Résumé des modules

```
┌───────────┬──────────────────────────────────────────────────────────────────────────────────┐
│ [ IoToS ] │ Internet of Things OS          Arduino UNO R4 Minima · Renesas RA4M1             │
├───────────┼──────────────────────────────────────────────────────────────────────────────────┤
│   [CLI]   │ Shell cmdLine : Serial / Telnet          │ TAB : Autocomplétion                  │
│           │ Flèches Haut/Bas : Historique            │ Login / password Serial & Telnet      │
│           │ (Mini MS-DOS)                            │ dir · rename · del · type · copy      │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [SD]    │ Gestion fichiers Micro SD                │ Ethernet Shield V2 · port SD          │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [NET]   │ Config : ip · subnet · gateway · mac     │ Ping complet · tracert · netstat      │
│           │ dhcp · port WEB (80)                     │ Horloge NTP (synchro Internet)        │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [WEB]   │ Serveur HTTP AJAX (port 80)              │ Auth Login/Password Base64 ON/OFF     │
│           │ Pages htm/css stockées sur Micro SD      │ Configuration IP par page WEB         │
│           │ Commande LED Arduino par CSS             │ base64encode.org                      │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [FTP]   │ Serveur FTP (port 21)                    │ Accès Micro SD (site WEB + log)       │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [LOG]   │ Datalogger Excel (csv) sur Micro SD      │ Horodatage NTP · État · Événements    │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [EEP]   │ Sauvegarde des paramètres EEPROM         │ save · reload · defaults reset        │
├───────────┼──────────────────────────────────────────┼───────────────────────────────────────┤
│   [LCD]   │ Écran I²C 128×64 GM12864-59N ST7567S     │ Menu 5 lignes rotatif                 │
│ (option)  │                                          │ 3 boutons : OK · (+) · (−)            │
└───────────┴──────────────────────────────────────────┴───────────────────────────────────────┘
```

---

## Matériel requis

### Version de base — sans écran

| Composant       | Référence                                             |
| --------------- | ----------------------------------------------------- |
| Microcontrôleur | Arduino UNO R4 Minima — Renesas RA4M1 / ARM Cortex-M4 |
| Shield Ethernet | Arduino Ethernet Shield 2 — W5500 (A000024)           |
| Carte SD        | Micro SD FAT32 — noms de fichiers longs (MS-DOS)      |

### Version LCDBlack — écran I²C affichage messages

| Composant       | Référence                                             |
| --------------- | ----------------------------------------------------- |
| Microcontrôleur | Arduino UNO R4 Minima — Renesas RA4M1 / ARM Cortex-M4 |
| Shield Ethernet | Arduino Ethernet Shield 2 — W5500 (A000024)           |
| Carte SD        | Micro SD FAT32 — noms de fichiers longs (MS-DOS)      |
| Écran LCD       | GM12864-59N VER2.0 · ST7567S · 128×64 · I²C           |

### Version LCDiMenu — écran I²C + menu 3 boutons

| Composant       | Référence                                             |
| --------------- | ----------------------------------------------------- |
| Microcontrôleur | Arduino UNO R4 Minima — Renesas RA4M1 / ARM Cortex-M4 |
| Shield Ethernet | Arduino Ethernet Shield 2 — W5500 (A000024)           |
| Carte SD        | Micro SD FAT32 — noms de fichiers longs (MS-DOS)      |
| Écran LCD       | GM12864-59N VER2.0 · ST7567S · 128×64 · I²C           |
| Boutons         | D8 = OK · D2 = (+) · D3 = (−) sur interruptions       |

### Paramètres de l'écran LCD (versions LCDBlack et LCDiMenu)

| Paramètre    | Valeur                       |
| ------------ | ---------------------------- |
| Modèle       | GM12864-59N VER2.0           |
| Contrôleur   | ST7567S                      |
| Résolution   | 128 × 64 px                  |
| Interface    | I²C · adresse 0x3F · 400 kHz |
| Bibliothèque | U8g2 v2.35.30                |

- Menu **5 lignes rotatif** (version LCDiMenu uniquement)
- Logo IoToS en `PROGMEM` affiché au boot
- `U8G2_ST7567_ENH_DG128064I_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);`

> L'écran LCD est optionnel. Sans lui, IoToS fonctionne intégralement via Serial ou Telnet.

---

## Câblage

```
Arduino UNO R4 Minima
│
├── D2  ──  Bouton (+)      [interruption]           ← LCDiMenu uniquement
├── D3  ──  Bouton (−)      [interruption]           ← LCDiMenu uniquement
├── D4  ──  CS Micro SD     (Ethernet Shield V2)
├── D5  ──  Module LED Grove (prise IP)
├── D8  ──  Bouton OK       [interruption]           ← LCDiMenu uniquement
├── D10 ──  CS W5500        (Ethernet Shield V2)
│
├── SPI (D11 MOSI / D12 MISO / D13 SCK)
│    └── Bus partagé : W5500 + Micro SD Card (SHARED_SPI)
│
└── I²C (A4 SDA / A5 SCL)
     └── LCD GM12864-59N [0x3F]                      ← LCDBlack et LCDiMenu
```

Allocation des sockets W5500 :

| Socket | Service                          |
| ------ | -------------------------------- |
| 0      | NTP (UDP)                        |
| 1      | Telnet CLI (port 23)             |
| 2      | Serveur WEB (port 80)            |
| 3      | Serveur FTP commande (port 21)   |
| 4      | Serveur FTP données (port 50009) |
| 5-7    | Libres                           |

> ⚠️ Le SPI est partagé entre le W5500 (CS=D10) et la MicroSD (CS=D4) via `SHARED_SPI`.
> Ordre d'initialisation obligatoire : `SPI.begin()` → SD → Wire → LCD → Ethernet.

---

## Installation

```
IDE 2.3.8  (IDE 1.x.x : bug Ethernet IP fixe — ne pas utiliser)
Carte    : Outils → Type de carte → Arduino UNO R4 Minima
SD       : Micro SD FAT32 système MS-DOS, noms de fichiers longs activés
Ethernet : Librairie Ethernet 1.5.3 — Ethernet@2.0.2
Libs     : Copier les bibliothèques modifiées dans \Mes Documents\Arduino\libraries\
           Attention : certaines bibliothèques ont été adaptées pour le RA4M1
```

### Bibliothèques

| Bibliothèque       | Version | Licence           | Modifiée | Dépôt                                   |
| ------------------ | ------- | ----------------- | -------- | --------------------------------------- |
| Arduino-MemoryFree | —       | Beerware          | Non      | github.com/sudar/MemoryFree             |
| EthernetICMP       | —       | LGPL v2.1 (*)     | **OUI**  | Bluebird-Software/Arduino-Ethernet-Icmp |
| NTPClient2         | —       | MIT               | **OUI**  | arduino-libraries/NTPClient             |
| SdFat              | v2.x    | MIT (**)          | Non      | github.com/greiman/SdFat                |
| SimpleFTPServer    | 3.0.2   | MIT               | **OUI**  | github.com/xreef/SimpleFTPServer        |
| U8g2 (code)        | 2.35.30 | BSD 2-Clause      | Non      | github.com/olikraus/U8g2_Arduino        |
| U8g2 (polices)     | 2.35.30 | OFL/MIT/BSD/Adobe | Non      | olikraus/u8g2/wiki/fntgrp               |

> ⚠️ Ne pas remplacer les bibliothèques modifiées par les versions du gestionnaire Arduino.
> Elles contiennent des adaptations spécifiques au RA4M1 et au W5500.

(*) EthernetICMP : licence duale GPL v2 / LGPL v2.1 — IoToS choisit LGPL v2.1.
(**) SdFat v1.x était GPL v3 — utiliser **exclusivement v2.x** (MIT).

**Modifications apportées aux bibliothèques :**
- **EthernetICMP** : ping W5500 · TRACERT TTL 1–30 · timeout ARM Cortex-M4 · socket AVR→EthernetUDP
- **NTPClient2** : `getFormattedDateTime()` JJ/MM/AAAA HH:MM:SS · `getDayOfWeek()` FR · backend EthernetUDP W5500 · offset UTC+1/+2
- **SimpleFTPServer** : fix `DEBUG_PRINT` (`#ifndef` guard) · `SPI_SD_ON/OFF` autour des accès SD
- **U8g2** : boot I²C après SPI (SPI > SD > Wire > LCD > ETH) · adresse `0x3F×2` · logo `PROGMEM`

### Configuration SdFat

Dans `SdFatConfig.h` :

```cpp
#define USE_LONG_FILE_NAMES  1
#define SDFAT_FILE_TYPE      1
```

### Configuration SimpleFTPServer

Dans `FtpServer.h` :

```cpp
#undef  DEFAULT_STORAGE_TYPE_ARDUINO
#define DEFAULT_STORAGE_TYPE_ARDUINO  STORAGE_SDFAT2
```

### Carte MicroSD

Formater en **FAT32** (système MS-DOS, noms longs). Copier à la racine :

```
index.htm        ← page principale du serveur WEB (boutons LED, polling AJAX)
ConfIP.htm       ← page de configuration IP Ethernet
datalogger.csv   ← créé automatiquement par la commande : create datalogger.csv
```

### Empreinte mémoire (v72 base, à titre indicatif)

```
Programme  : 161 972 octets / 262 144  (61 %)
RAM        :  16 020 octets /  32 768  (48 %)
RAM libre  :  16 748 octets (variables locales)
```

> Double appui rapide sur **RESET** pour activer le bootloader si nécessaire.

---

## Architecture logicielle

```
avant setup()  ──  Load Firmware   : #include · constantes · macros DBG()
                                     déclaration des objets (Ethernet, SD, LCD…)

setup()        ──  Boot Loader     : init SPI → SD → Wire → LCD → Ethernet → NTP
                                     chargement EEPROM · affichage splash screen

loop()         ──  Noyau coopératif (non-préemptif, non-bloquant) :
                     cmdLine.update()           ← CmdLine Serial USB
                     cmdLine.updateTelnet()     ← CmdLine Telnet port 23
                     ServeurWEB(client)         ← ServeurWEB.h  port 80
                     ftpSrv.handleFTP()         ← lib SimpleFTPServer port 21
                     PremiereConnexionTelnet()  ← banner Telnet
                     PremiereConnexionSerial()  ← banner Serial
```

### Structure des fichiers

```
PriseIP_UNOR4_jsWEB_SD_FTP_LogCmdLine_IDE2_v72/
│
├── PriseIP_UNOR4_..._v72.ino        Programme principal — setup(), loop(), déclarations
├── utils.h                          Fonctions communes — Datalogger, TestValidityIPadress,
│                                    PrintProgmem (ANSI+Telnet), banner Serial/Telnet
├── Shell_CmdLine_SD.h               Shell CLI — toutes les commandes (ip, dir, ping, save…)
│                                    Tableau commands[] : chaînes → pointeurs de fonctions
├── ServeurWEB.h                     Serveur HTTP AJAX — routeur pages, XML AJAX, boutons LED
└── Driver_Ethernet_Reseau.h         Init Ethernet W5500 — IP fixe/DHCP, DNS, NTP
```

---

## Utilisation

### Connexion Serial

```
Vitesse   : 115 200 bauds
PuTTY     : Connexion → Serial → Flow control : None
IDE Arduino : Outils → Moniteur série → Les deux NL et CR → 115 200
```

### Connexion Telnet

```
Port    : 23
PuTTY   : Connexion → Telnet → décocher "Return key sends Telnet New Line instead of ^M"
MobaXterm : taper  cli off  pour éviter le doublement des caractères
```

### Connexion FTP (FileZilla)

```
Hôte    : IP de l'Arduino
Port    : 21
Auth    : Type Compte — identifiant + mot de passe
Réglage : Fichier → Gestion de sites → Paramètre de Transfert → Limiter connexions à 1
```

### Accès WEB

Ouvrir un navigateur à l'adresse IP de l'Arduino (port 80 par défaut).
Si l'authentification est activée, encoder les identifiants en Base64 sur
[base64encode.org](https://www.base64encode.org/) — format : `login:password`.

---

## Commandes du shell IoToS (CLI)

### Commandes système

```
print / info / p          Configuration complète (réseau, services, EEPROM, RAM, NTP)
name <nom>                Changer le nom du système
version                   Version, date de compilation, auteur
ram                       Mémoire RAM disponible
reset / reboot            Redémarrage immédiat (charge la config EEPROM)
```

### Services

```
WEB   on/off              Activer / désactiver le serveur WEB
FTP   on/off              Activer / désactiver le serveur FTP
LED   on/off              Commander la LED de la prise IP
```

### Outils réseau

```
ping    <IP ou URL>       Ping ICMP — 4 paquets, statistiques min/max/moy
tracert <IP ou URL>       Traceroute — TTL 1 à 30, 3 essais par hop
netstat                   État des 8 sockets du W5500
```

### Datalogger

```
datalogger on/off         Activer / désactiver l'enregistrement
create  <fichier.csv>     Créer un fichier CSV avec en-tête
select  <fichier.csv>     Sélectionner le fichier actif
```

### Gestion fichiers MicroSD (Mini MS-DOS)

```
dir / ls                  Lister les fichiers (date · heure · taille · nom)
type    <fichier>         Afficher le contenu d'un fichier texte
edit    <texte>           Ajouter du texte dans le fichier sélectionné
rename  <ancien> <nouveau> Renommer un fichier
del     <fichier>         Supprimer un fichier
copy    <src>  <dst>      Copier un fichier (blocs de 1 024 octets)
```

### Configuration réseau

```
ip        <xxx.xxx.xxx.xxx>    Adresse IP statique
subnet    <xxx.xxx.xxx.xxx>    Masque de sous-réseau
gateway   <xxx.xxx.xxx.xxx>    Passerelle
mac       <DE:AD:BE:EF:FE:ED>  Adresse MAC (unique par Arduino sur le réseau)
dhcp      on/off               Mode DHCP
port      <0-65535>            Port du serveur WEB (défaut 80)
```

### EEPROM

```
save                      Sauvegarder la configuration en EEPROM
reload                    Charger la configuration depuis l'EEPROM
defaults                  Restaurer la configuration usine (192.168.0.10)
SaveConf  <fichier>       Sauvegarder la config dans un fichier binaire SD
LoadConf  <fichier>       Charger la config depuis un fichier binaire SD
```

### Authentification CLI / Telnet

```
login   ON                Verrouiller le CLI et Telnet
login   OFF               Déverrouiller le CLI et Telnet
login   <motDePasse>      Se connecter (anti-brute-force : délai doublé à chaque erreur)
password <nouveauMdP>     Changer le mot de passe CLI/Telnet
exit                      Fermer la session (réactive le verrou)
CLI     on/off            Echo terminal (off = MobaXterm · on = PuTTY)
```

### Authentification WEB / FTP

```
loginWEB         on/off       Activer l'authentification du site WEB
login-passWEB    <base64>     Changer le Login:Password WEB (Base64)
loginFTP         <login>      Changer le login FTP
passwordFTP      <password>   Changer le mot de passe FTP
```

### Exemple — changer l'adresse IP

```
> ip 192.168.1.50
Commande confirmee : IP 192.168.1.50
> save
EEPROM Save : ......... OK !
> reset
Reboot Now .....
```

---

## Configuration par défaut

| Paramètre           | Valeur par défaut        |
| ------------------- | ------------------------ |
| IP                  | 192.168.0.10             |
| Masque              | 255.255.255.0            |
| Passerelle          | 192.168.0.254            |
| MAC                 | DE:AD:BE:EF:FE:B1        |
| DHCP                | OFF                      |
| Port WEB            | 80                       |
| Login WEB           | OFF                      |
| Login:Password WEB  | dXNlcjpwYXNz (user:pass) |
| Login FTP           | arduino                  |
| Password FTP        | arduino                  |
| Password CLI/Telnet | changerLeMotDePasse      |
| Datalogger          | OFF                      |
| Fichier datalogger  | datalogger.csv           |

> ⚠️ Changer l'adresse MAC si plusieurs Arduino sont sur le même réseau (risque de conflit ARP).

Identifiant de version EEPROM :

```cpp
#define VALID  100000066   // détecte une EEPROM incompatible entre deux versions du firmware
```

---

## Documentation des fonctions principales

### ServeurWEB.h

```
Entrée  : EthernetClient &client — client HTTP fourni par server.available()
          HTTP_req[] (global)    — buffer de la requête HTTP (512 octets)
Sortie  : client.print/write    — contenu HTTP/HTML/XML vers le navigateur
          Serial                — messages de debug
```

```cpp
void ServeurWEB(EthernetClient &client);
// Lecture requête · authentification Basic Auth (Base64) · timeout 5 s · → PageWEB()

void PageWEB(EthernetClient &client);
// Routeur HTTP — analyse HTTP_req[] et aiguille :
//   ajax_outputs           → décode IP/MSR/GAT via strtok → EEPROM → ResetNow()
//   ajax_inputs?led        → XML <LED>0|1</LED>
//   ajax_inputs            → XML config IP complète (DHCP/IP/MSR/GAT/LOG)
//   GET /?BoutonON         → conf.led=1 + digitalWrite(HIGH) + Datalogger()
//   GET /?BoutonOFF        → conf.led=0 + digitalWrite(LOW)  + Datalogger()
//   favicon.ico            → HTTP 404  (évite double envoi index.htm)
//   ConfIP.htm             → HTTP 200 + SendFile(ConfIP.htm)
//   GET / | index.htm | /? → HTTP 200 + SendFile(index.htm)

void SendFile(EthernetClient &client, const char *fichierSD);
// Entrée  : nom du fichier sur SD (ex: "index.htm")
// Sortie  : client.write() — blocs de 512 octets jusqu'à EOF
```

### utils.h

```cpp
void Datalogger();
// Entrée  : conf.fichierEnCours — nom du fichier CSV cible
// Sortie  : ligne CSV ajoutée — format : Date ; Heure ; État LED

boolean TestValidityIPadress(IPAddress ip, IPAddress subnet, IPAddress gateway);
// Entrée  : ip, subnet, gateway (IPAddress)
// Sortie  : 1 = configuration valide · 0 = incohérence réseau détectée
// Vérifie bit à bit que ip et gateway appartiennent au même sous-réseau

void PrintProgmem(const char* p);
// Entrée  : pointeur PROGMEM vers une raw string R"=====( )====="
// Sortie  : cmdLine (Serial + Telnet) — convertit \033[ → ESC ANSI · \n → \r\n (RFC 854)
```

### Shell_CmdLine_SD.h — convention des commandes

```cpp
void MaCommande(const char *arg);
// Entrée  : arg — chaîne après la commande (NULL si argument absent)
// Sortie  : cmdLine.print() / cmdLine.println() → Serial + Telnet simultanément
// Accès   : if (conf.login_cmdTelnetSwitch == 1) { cmdLine.println(F("Acces Refuse")); return; }
// Sécurité: if (arg == NULL || arg[0] == '\0') { cmdLine.println(F("Operande absent")); return; }
```

### Driver_Ethernet_Reseau.h

```cpp
void Initialisation_Ethernet();
// Entrée  : conf.dhcp, conf.ip, conf.subnet, conf.gateway, conf.mac (structure EEPROM)
// Sortie  : etatWAN  (0=KO / 1=OK) — résultat du test DNS google.com
//           dhcpEtat (0=IP fixe / 1=DHCP actif)
// Séquence: IP fixe ou DHCP → validation adresse → DNS → NTP → affichage statut
```

---

## Licence

```
IoToS — Internet of Things Operating System
Copyright (C) 2026 Jean-Marc Biechy — Institution Saint-Jean, Colmar, France
Licence : GNU LGPL v2.1
https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
```

| Droits accordés                              | Obligations (redistribution uniquement)        |
| -------------------------------------------- | ---------------------------------------------- |
| Usage libre y compris commercial             | Distribuer les sources IoToS modifiées         |
| Modification des fichiers IoToS              | Conserver les en-têtes de copyright            |
| Intégration dans un firmware propriétaire    | Mentionner l'usage d'IoToS et sa licence       |
| Code applicatif (.ino) reste votre propriété | Ne pas ajouter de restrictions supplémentaires |

**Bibliothèques tierces** — chacune conserve sa licence d'origine (voir tableau Bibliothèques).

*IoToS est fourni en l'état sans garantie. L'auteur n'est pas responsable des dommages résultants.*

---

## Auteur

**Jean-Marc Biechy**
École d'Électronique, Informatique et Réseau · Institution Saint-Jean — 68000 Colmar, France
radiobiechy@gmail.com — Date : 01/03/2026

---

*IoToS v72 — Institution Saint-Jean Colmar — 2026*
