ls2tp/docs/TEST_PROGRAMS.md

# Programmes de test pour rétro-ingénierie du format TP

> Liste des programmes à créer sur le robot (R-30iB Mate Plus V9.30) pour
> obtenir des paires `.LS`/`.TP` permettant de décoder le format binaire.

## 🔑 Principe

Chaque programme doit isoler **UNE seule fonctionnalité** pour qu'on puisse,
en comparant les binaires, identifier précisément à quoi correspond chaque
octet. On progresse du plus simple au plus complexe.

**Important** : pour chaque programme, fournir **les deux fichiers** (`.LS` et `.TP`)
compilés avec WinOLPC ou Roboguide, et **noter la version logicielle du contrôleur**.

---

## 🥇 TIER 1 — Essentiel (décode le cœur du format)

### P01 — `EMPTY` — programme vide
Programme sans aucune instruction, juste un `END`.
```
/PROG EMPTY
/MN
   1:  END ;
/POS
/END
```
**Révèle** : header minimal, opcode `END`, structure du footer.

### P02 — `MOVE_J` — 1 mouvement articulaire
```
/MN
   1:  J P[1] 100% FINE ;
```
**Révèle** : opcode `J`, encodage vitesse en `%`, terminaison `FINE`.

### P03 — `MOVE_L` — 1 mouvement linéaire
```
/MN
   1:  L P[1] 2000mm/sec FINE ;
```
**Révèle** : opcode `L`, encodage vitesse en `mm/sec`.

### P04 — `MOVE_C` — 1 mouvement circulaire
```
/MN
   1:  C P[1] P[2] 2000mm/sec FINE ;
```
**Révèle** : opcode `C`, double position (via + point).

### P05 — `POS_JOINT` — positions en angles articulaires
Un programme avec 2-3 positions **définies en J1-J6** (angles).
```
/POS
P[1]{
   GP1:
	J1 = 0.0 deg, J2 = 0.0 deg, J3 = 0.0 deg,
	J4 = 0.0 deg, J5 = 0.0 deg, J6 = 0.0 deg
};
P[2]{
   GP1:
	J1 = 10.5 deg, J2 = -20.25 deg, J3 = 45.0 deg,
	J4 = 0.0 deg, J5 = -90.0 deg, J6 = 15.75 deg
};
/END
```
**Révèle** : encodage des positions articulaires (float32, ordre des axes).

### P06 — `POS_CART` — positions en coordonnées cartésiennes
```
/POS
P[1]{
   GP1:
	UF : 0, UT : 1, CONFIG : 'N U T, 0, 0, 0',
	X = 100.0 mm, Y = 200.0 mm, Z = 300.0 mm,
	W = 0.0 deg, P = 90.0 deg, R = 0.0 deg
};
P[2]{
   GP1:
	UF : 2, UT : 3, CONFIG : 'F D B, 1, -1, 0',
	X = -150.5 mm, Y = 75.25 mm, Z = 40.0 mm,
	W = 45.0 deg, P = -30.0 deg, R = 180.0 deg
};
/END
```
**Révèle** : encodage cartésien XYZWPR + configuration (F/N, U/D, T/B + tournants).

---

## 🥈 TIER 2 — Instructions (pour le compilateur complet)

### P07 — `REG` — assignations de registres
```
/MN
   1:  R[1] = 5 ;
   2:  R[2] = -10 ;
   3:  R[3] = 3.14 ;
   4:  R[4] = R[1] ;
   5:  R[5] = R[1] + R[2] ;
```
**Révèle** : encodage des registres R[n], des entiers, réels, négatifs, opérateurs.

### P08 — `CTRL` — contrôle de flux
```
/MN
   1:  LBL[1] ;
   2:  IF R[1]=1, JMP LBL[1] ;
   3:  IF R[1]>5, JMP LBL[2] ;
   4:  JMP LBL[1] ;
   5:  LBL[2] ;
   6:  SELECT R[1]=1, JMP LBL[1] ;
   7:         ELSE, JMP LBL[2] ;
```
**Révèle** : opcodes LBL, JMP, IF, comparaisons, SELECT.

### P09 — `LOOP` — boucles
```
/MN
   1:  FOR R[1] = 1 TO 10 ;
   2:  ENDFOR ;
   3:  FOR R[2] = 10 DOWNTO 1 ;
   4:  ENDFOR ;
```
**Révèle** : opcodes FOR/ENDFOR, TO/DOWNTO.

### P10 — `IO` — entrées/sorties
```
/MN
   1:  DO[1] = ON ;
   2:  DO[2] = OFF ;
   3:  F[1] = ON ;
   4:  DO[3] = PULSE, 0.5sec ;
   5:  WAIT DI[1] = ON ;
   6:  WAIT 2.00(sec) ;
```
**Révèle** : opcodes DO/F/DI, ON/OFF, PULSE, WAIT.

### P11 — `CALL` — appels de programmes
```
/MN
   1:  CALL PROG1 ;
   2:  CALL PROG2(1) ;
   3:  CALL PROG3(1, 2) ;
   4:  CALL PROG4('texte') ;
   5:  CALL PROG5(R[1]) ;
```
**Révèle** : opcode CALL, arguments (int, string, registre).

### P12 — `PR` — registres de position
```
/MN
   1:  PR[1] = P[1] ;
   2:  PR[2] = LPOS ;
   3:  PR[3] = JPOS ;
   4:  J PR[1] 100% FINE ;
```
**Révèle** : opcode PR, LPOS/JPOS, mouvement vers PR.

### P13 — `MOVE_MOD` — modificateurs de mouvement
```
/MN
   1:  L P[1] 2000mm/sec FINE OFFSET PR[1] ;
   2:  L P[1] 2000mm/sec FINE INC ;
   3:  L P[1] 2000mm/sec CNT50 ;
   4:  L P[1] 2000mm/sec CNT100 ;
   5:  L P[1] 2000mm/sec FINE ACC100 ;
   6:  L P[1] 2000mm/sec FINE Skip, LBL[1] ;
```
**Révèle** : OFFSET, INC, CNT, ACC, Skip.

### P14 — `SPEED` — toutes les unités de vitesse
```
/MN
   1:  J P[1] 50% FINE ;
   2:  J P[1] 100% FINE ;
   3:  L P[1] 500mm/sec FINE ;
   4:  L P[1] 5000mm/sec FINE ;
   5:  L P[1] 100cm/min FINE ;
   6:  L P[1] 5sec FINE ;
   7:  L P[1] 500msec FINE ;
   8:  J P[1] 90deg/sec FINE ;
```
**Révèle** : encodage des différentes unités de vitesse.

---

## 🥉 TIER 3 — Complet (validation globale)

### P15 — `COMMENTS` — commentaires et chaînes
```
/MN
   1:  ! ceci est un commentaire ;
   2:  R[1] = 5 ;
   3:  // remarque ;
```
**Révèle** : encodage des commentaires et remarques.

### P16 — `MATH` — expressions arithmétiques complètes
```
/MN
   1:  R[1] = 1 + 1 ;
   2:  R[2] = 10 - 5 ;
   3:  R[3] = 2 * 3 ;
   4:  R[4] = 10 / 2 ;
   5:  R[5] = (1 + 2) * 3 ;
```
**Révèle** : priorité des opérateurs, parenthèses.

### P17 — `SR` — registres de chaîne
```
/MN
   1:  SR[1] = 'Bonjour' ;
   2:  R[1] = STRLEN SR[1] ;
```
**Révèle** : encodage des chaînes et registres de chaîne.

### P18 — `MIXED` — programme réel complet
Un programme représentatif mélangeant mouvements, registres, contrôle de flux,
E/S et appels. **Révèle** : interaction de tous les éléments ensemble.

---

## 📋 Checklist de fourniture

Pour chaque programme, fournir :

- [ ] Le fichier `.LS` (source ASCII)
- [ ] Le fichier `.TP` (compilé binaire)
- [ ] Les deux avec le **même nom de programme**

### Version du contrôleur

Noter précisément :
- Modèle : R-30iB Mate Plus
- Version logicielle (ex: V9.30, V9.40...) — visible sur le teach pendant au démarrage
- Version de WinOLPC/Roboguide utilisée

### Ordre de priorité

1. **P01-P06** (Tier 1) — suffisent pour casser le cœur du format (header, mouvements, positions)
2. **P07-P14** (Tier 2) — nécessaires pour un compilateur complet
3. **P15-P18** (Tier 3) — validation et cas avancés

> 💡 Astuce : les programmes P01-P04 peuvent être créés en 5 minutes chacun
> sur le teach pendant. Ce sont eux qui débloquent le plus de choses.