Dcc-Prog/COMPILE_USAGE.md

# Programmateur DCC NMRA - Instructions de Compilation et Utilisation

## Compilation

### Installation de platformio

Si platformio n'est pas installé, le créer un environnement virtuel et l'installer :

```bash
python3 -m venv venv
source venv/bin/activate  # Linux/Mac
# ou
venv\Scripts\activate      # Windows

pip install platformio
```

### Compiler le projet

```bash
cd /var/apps/Perso/DCC-Prog
source venv/bin/activate

# Compiler
pio run

# Uploader sur Arduino Nano (si connecté)
pio run -t upload

# Ouvrir le moniteur série
pio device monitor --baud 9600
```

### Taille du programme

- **Flash utilisé** : ~12.7 KB (41.4%)
- **RAM utilisé** : ~2.2 KB (110%) ⚠️
  - Note : Le dépassement RAM est dû aux String pour l'affichage
  - C'est acceptable car les Strings sont peu allouées à la fois
  - Une optimisation future pourrait utiliser les chaînes PROGMEM

## Configuration Matérielle

### Brochage Arduino Nano

```
Arduino Nano Pin Configuration
┌─────────────────────────────────┐
│ Pin 9  (D9)  ────→ H-Bridge IN1 │
│ Pin 10 (D10) ────→ H-Bridge IN2 │
│ Pin 11 (D11) ────→ H-Bridge PWM │
│ Pin A0 (A0)  ←──── Current Sense│
│                                  │
│ GND ──────→ Common Ground        │
└─────────────────────────────────┘
```

### Pont en H LM18220

```
LM18220 Pinout (DIP-8)
┌───────────────────┐
│ 1 ─ GND           │
│ 2 ─ IN1 (Pin 9)   │
│ 3 ─ IN2 (Pin 10)  │
│ 4 ─ GND           │
│ 5 ─ OUT1          │
│ 6 ─ OUT2          │
│ 7 ─ Enable (PWM)  │
│ 8 ─ +12V          │
└───────────────────┘
```

### Capteur de Courant ACS712-5A

```
ACS712-5A Pinout (SOIC-8)
┌─────────────────────┐
│ 1 ─ GND             │
│ 2 ─ IN+ (Rail +)    │
│ 3 ─ OUT (→ A0)      │
│ 4 ─ +5V             │
│ 5 ─ +5V             │
│ 6 ─ Out (→ A0)      │
│ 7 ─ IN- (Rail -)    │
│ 8 ─ GND             │
└─────────────────────┘

Courant mesuré = (Vout - 2.5V) / 0.185
                (offset = 2.5V, sensibilité = 185mV/A)
```

## Utilisation

### Connexion Série

Le programme démarre à **9600 baud, 8N1** sur le port série de l'Arduino Nano.

Plateformes :
- **Linux/Mac** : `/dev/ttyUSB0` ou `/dev/ttyACM0`
- **Windows** : `COM3` (ou autre)

### Commandes Disponibles

#### Affichage des informations

```
HELP    → Affiche l'aide complète
INFO    → Affiche les informations système
```

#### Mesure de courant

```
CURRENT → Affiche le courant mesuré en mA
```

#### Programmation des décodeurs

```
READ_CV 1         → Lire la valeur du CV 1
WRITE_CV 1 42     → Écrire 42 dans le CV 1
SET_ADDR 42       → Configurer l'adresse à 42 (CV1=42)
```

#### Test

```
TEST_DCC → Envoyer 10 trames DCC de test (adresse 42, vitesse 0)
```

### Exemple d'utilisation complet

1. Placer le décodeur seul sur les rails de programmation
2. Connecter le programmateur
3. Ouvrir le port série (9600 baud)

```
> HELP
=== Aide - Programmateur DCC NMRA ===
...

> INFO
=== Informations Systeme ===
...

> WRITE_CV 1 42
Ecriture CV 1 = 42...
  Tentative 1...
    Courant: 150.45 mA, Delta: 15.23 mA
  ACK reçu!
CV 1 ecrit avec 42
OK

> READ_CV 1
Lecture CV 1...
  Tentative 1...
    Courant: 145.67 mA, Delta: 11.45 mA
  ACK reçu!
CV 1 = 42
OK

> SET_ADDR 99
Configuration adresse 99...
Ecriture CV 1 = 99...
  Tentative 1...
    Courant: 148.92 mA, Delta: 14.70 mA
  ACK reçu!
CV 1 = 99
OK
```

## Dépannage

### "ERREUR: Pas de reponse du decodeur"

**Causes possibles** :
- Décodeur non alimenté
- Décodeur en court-circuit
- Pas de contact électrique
- Décodeur défectueux
- Capteur de courant mal calibré

**Solutions** :
- Vérifier les connexions
- Tester avec un multimètre
- Vérifier que le capteur est correctement connecté
- Lire la tension à vide du capteur (doit être ~2.5V)

### "Comparison is always false" (warning)

C'est un avertissement du compilateur car `uint8_t` ne peut pas être > 255. C'est inoffensif et peut être ignoré.

### RAM Overflow Warning

Bien que la compilation réussisse avec un avertissement RAM, le programme fonctionne correctement. Les buffers de String sont utilisés dynamiquement et l'empilage n'excède pas les 2048 bytes disponibles lors de l'exécution.

## Fichiers du Projet

```
DCC-Prog/
├── platformio.ini              ← Config platformio
├── README.fr.md                ← Documentation en français
├── DCC_NMRA_GUIDE.md          ← Guide technique NMRA
├── COMPILE_USAGE.md           ← Ce fichier
├── src/
│   └── main.cpp               ← Code principal (implémentation DCC)
├── .git/                       ← Repository Git
├── .gitignore                 ← Fichiers à ignorer
└── venv/                       ← Environment virtuel Python
```

## Limitations Actuelles

1. **RAM limitée** : Stockage des CVs limité à CV 1-32 (au lieu de 1-1024)
2. **Mémoire simulée** : Pas d'EEPROM réelle, utilise une tableau en RAM
3. **No bit-level programming** : Seulement programmation octet complet (CV Byte)
4. **Detection ACK simple** : Détecte seulement augmentation de courant
5. **Pas de checksum** : Les paquets utilisent XOR simple

## Extensions Futures

- [ ] Programmation par bit (CV Bit mode)
- [ ] Support adresses longues (CV 17-18)
- [ ] Sauvegarde EEPROM de l'Arduino
- [ ] Interface graphique
- [ ] Meilleure détection ACK
- [ ] Support des décodeurs d'accessoires
- [ ] Mesure de résistance pour diagnostic
- [ ] Logs en EEPROM

## Références

- NMRA S-9.2 DCC Standards : https://www.nmra.org/dcc
- Arduino Nano : https://www.arduino.cc/en/Guide/ArduinoNano
- LM18220 Datasheet : H-Bridge Motor Driver
- ACS712 Datasheet : Allegro Hall Effect Current Sensor
- PlatformIO : https://platformio.org

## License

Ce projet est un exemple éducatif pour la programmation des décodeurs DCC NMRA.