# Analisi Comparativa: Codice Albertook vs Nostro Codice

**Data:** 2026-02-04  
**Versione Albertook:** Funzionante e testata su hardware reale  
**Nostra Versione:** Riorganizzata con verifiche tellback e step sequenziali

---

## 🔍 FLUSSO DEL CODICE ALBERTOOK (Funzionante)

### Sequenza dopo Power ON:
```python
# 1. Power ON radar
power_grifo_on(1.5)  # Wait 1.5 secondi

# 2. Setup IMMEDIATO (senza attese o verifiche):
setValue(theGrifo1553, 127, "A1_MsgRdrSettingsAndParameters",
    "settings_RDROperationalSettings_rdr_symbology_intensity", commitChanges=True)
setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand","rdr_mode_command_RdrModeCommandWord_silence")

setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand","param1_RdrFunAndParam1_azimuth_scan_width_selection")      
setValue(theGrifo1553, 2, "A2_MsgRdrOperationCommand","param1_RdrFunAndParam1_range_scale_selection")      
setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand","param1_RdrFunAndParam1_number_of_bars_selection")      

setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand","rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)      

setValue(theGrifo1553, 1060, "A4_MsgNavDataAndCursor","z_acceleration_Acceleration_raw")      
setValue(theGrifo1553, 2500, "A4_MsgNavDataAndCursor","corrected_baro_altitude_BaroAltitude_raw")      
setValue(theGrifo1553, 2500, "A4_MsgNavDataAndCursor","radio_altitude_RadioAltitude_raw", commitChanges=True)      

setValue(theGrifo1553, 0xAA54, "A5_MsgInuHighSpeed","mode_word", commitChanges=True)

# 3. Inizia SUBITO loop PBIT (senza attese)
while remaining_time > 0:
    # ... aspetta bit_report_available
```

### Test Target (Molto Semplice):
```python
# 1. Rimuove STANDBY
setValue(theGrifo1553, 0, "A2_MsgRdrOperationCommand",
    "rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)

# 2. Esegue tgt_gen()
tgt_passed = tgt_gen(interface)

# 3. Rimette STANDBY
setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand",
    "rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
```

---

## 🔴 DIFFERENZE CRITICHE CHE POTREBBERO CAUSARE PROBLEMI

### 1. **NESSUNA VERIFICA TELLBACK** 🔴🔴🔴
**Albertook:**
- NON verifica che STANDBY/SILENCE siano attivi
- NON controlla B7 per i tellback
- Procede "alla cieca" assumendo che i comandi siano stati accettati

**Noi:**
- Verifichiamo tellback STANDBY/SILENCE su B7
- Aspettiamo fino a 5 secondi per conferma
- **PROBLEMA:** Se il radar non risponde subito al tellback, andiamo in timeout!

**Impatto:** Il nostro codice potrebbe bloccarsi in attesa di tellback che il radar impiega tempo a settare.

---

### 2. **TIMING E ATTESE** 🔴🔴
**Albertook:**
```python
power_grifo_on(1.5)  # Solo 1.5 secondi
# Setup immediato senza altre attese
# Inizia PBIT subito
```

**Noi:**
```python
power_grifo_on(wait_after=0.100)
time.sleep(2.0)  # Attesa stabilizzazione
# ... setup comandi ...
time.sleep(TELLBACK_POST_SET_DELAY_SEC)  # 2 secondi
# ... verifica tellback (fino a 5 secondi) ...
time.sleep(2.0)  # Altri 2 secondi prima PBIT
```

**Totale attese:**
- Albertook: ~1.5 secondi
- Noi: 0.1 + 2.0 + 2.0 + (fino a 5.0) + 2.0 = **~11 secondi minimo**

**Impatto:** Troppa attesa potrebbe causare:
- Timeout radar
- Messaggi 1553 persi
- Stato radar inconsistente

---

### 3. **STRATEGIA commitChanges** 🔴
**Albertook:**
```python
# Imposta SILENCE senza commit
setValue(..., "silence")

# Imposta 3 param1 senza commit
setValue(..., "azimuth_scan_width_selection")
setValue(..., "range_scale_selection")
setValue(..., "number_of_bars_selection")

# Imposta STBY con commit (invia tutto insieme)
setValue(..., "stby", commitChanges=True)
```

**Noi:**
```python
# Ogni comando con commit immediato
setValue(..., "silence", commitChanges=True)
setValue(..., "stby", commitChanges=True)
# ... poi dopo ...
setValue(..., "azimuth_scan_width_selection", commitChanges=True)
setValue(..., "range_scale_selection", commitChanges=True)
setValue(..., "number_of_bars_selection", commitChanges=True)
```

**Impatto:** Inviare comandi separatamente potrebbe:
- Causare stati intermedi instabili
- Sovraccaricare il bus 1553
- Generare race condition

---

### 4. **ORDINE DI SETUP** 🔴
**Albertook:**
1. INTENSITY (A1)
2. SILENCE (A2) - senza commit
3. Scan params (A2)
4. STANDBY (A2) - con commit
5. Nav data (A4)
6. INU mode (A5)

**Noi:**
1. SILENCE (A2) - con commit
2. STANDBY (A2) - con commit
3. Verifica tellback (B7)
4. Scan params (A2)
5. Nav data (A4)
6. INU mode (A5)
7. INTENSITY (A1)

**Impatto:** L'ordine potrebbe essere importante per lo stato interno del radar.

---

### 5. **GESTIONE MESSAGGIO B6 vs B7** 🔴
**Albertook:**
- Usa solo B6 per bit_report_available ✅
- NON legge mai B7 ✅
- Non ha bisogno dei tellback

**Noi:**
- Leggiamo B7 per tellback (corretto per ICD)
- Ma questo richiede che il radar invii B7 attivamente
- **PROBLEMA:** Se B7 non arriva o è in ritardo, siamo bloccati

---

### 6. **TEST TARGET - SEMPLICITÀ** 🔴
**Albertook:**
```python
# Rimuove STANDBY
setValue(..., stby=0, commitChanges=True)
# Esegue test
tgt_gen(interface)
# Rimette STANDBY
setValue(..., stby=1, commitChanges=True)
```

**Noi:**
```python
# Rimuove STANDBY
setValue(..., stby=0, commitChanges=True)
time.sleep(STBY_POST_UNSET_DELAY_SEC)  # 2 secondi
# Verifica rimozione (B7, fino a 5 secondi)
# Attende 1 secondo
time.sleep(1.0)
# Esegue test
tgt_gen(...)
# Rimette STANDBY
setValue(..., stby=1, commitChanges=True)
time.sleep(TELLBACK_POST_SET_DELAY_SEC)  # 2 secondi
```

**Impatto:** Troppa attesa tra rimozione STANDBY e inizio test potrebbe far andare il radar in uno stato diverso da quello atteso.

---

### 7. **FUNZIONE tgt_gen() - PARAMETRI** 🔴
**Albertook:**
```python
def tgt_gen(interface):
    # Usa variabile globale only_bc
    if only_bc:
        setValue(theGrifo1553, 0, "A2...", "stby", commitChanges=True)
    # ... stimola A4/A5 ...
    # Monitora B9
```

**Noi:**
```python
def tgt_gen(interface, timeout_sec=..., expected_range=..., 
            range_tolerance=..., hit_threshold=..., 
            only_bc=True, enable_stim=True):
    # Logica più complessa
    # Rimuove STANDBY internamente se only_bc=True
```

**Impatto:** Il nostro tgt_gen rimuove STANDBY internamente, ma noi lo facciamo già prima! Possibile doppia rimozione.

---

### 8. **NESSUNA prepare_radar_for_target_test()** 🔴🔴
**Albertook:**
- NON chiama prepare_radar_for_target_test()
- Fa solo: rimuovi STBY → test → rimetti STBY

**Noi:**
- Chiamiamo prepare_radar_for_target_test() che:
  - Imposta SILENCE/STANDBY (già fatto!)
  - Configura scan params (già fatto!)
  - Verifica tellback (già fatto!)
- **PROBLEMA:** Stiamo duplicando tutto!

---

## 🎯 PROBLEMI PRINCIPALI NELLA NOSTRA VERSIONE

### PROBLEMA 1: Troppa Verifica Tellback
- Il radar potrebbe non rispondere subito ai tellback su B7
- Andiamo in timeout aspettando conferme non necessarie
- Albertook NON verifica e funziona!

### PROBLEMA 2: Troppa Attesa
- ~11 secondi di attese vs 1.5 secondi di Albertook
- Il radar potrebbe andare in timeout interno
- Il PBIT potrebbe non partire correttamente

### PROBLEMA 3: commitChanges Frammentato
- Albertook raggruppa i comandi A2 in un unico commit
- Noi committiamo ogni comando separatamente
- Possibili stati intermedi instabili

### PROBLEMA 4: Ordine Setup
- Albertook imposta INTENSITY per primo
- Noi lo impostiamo per ultimo
- Potrebbe essere importante per inizializzazione radar

### PROBLEMA 5: Doppia Configurazione Target Test
- Configuriamo tutto all'inizio
- Poi richiamiamo prepare_radar_for_target_test() che rifà tutto
- Chiamiamo tgt_gen() con only_bc=False ma lui vuole rimuovere STANDBY internamente

### PROBLEMA 6: Messaggio B7 Non Disponibile?
- Albertook non usa mai B7
- Noi lo usiamo per tellback
- Se B7 non arriva, siamo bloccati

---

## ✅ RACCOMANDAZIONI CORRETTIVE

### 1. **ELIMINARE VERIFICA TELLBACK** (CRITICO)
```python
# RIMUOVERE:
# - Verifica tellback STANDBY/SILENCE su B7
# - Attese per conferma tellback
# - Loop di polling B7

# LASCIARE:
# - Comandi setup
# - Attesa minima (1-2 secondi) per stabilizzazione HW
```

### 2. **RIDURRE ATTESE**
```python
# PRIMA:
power_grifo_on(wait_after=0.100)
time.sleep(2.0)  # stabilizzazione
# ... comandi ...
time.sleep(2.0)  # post-set
# ... verifica tellback 5s ...
time.sleep(2.0)  # pre-PBIT

# DOPO:
power_grifo_on(wait_after=1.5)  # come Albertook
# ... comandi immediati ...
# NESSUNA attesa aggiuntiva
# PBIT subito
```

### 3. **RAGGRUPPARE commitChanges**
```python
# Impostare tutti i comandi A2 insieme
setValue(..., "silence")  # NO commit
setValue(..., "azimuth_scan_width_selection")  # NO commit
setValue(..., "range_scale_selection")  # NO commit
setValue(..., "number_of_bars_selection")  # NO commit
setValue(..., "stby", commitChanges=True)  # commit TUTTO insieme
```

### 4. **RIORDINARE SETUP COME ALBERTOOK**
```python
# 1. INTENSITY per primo
setValue(..., "rdr_symbology_intensity", commitChanges=True)

# 2. SILENCE + scan params + STANDBY insieme
setValue(..., "silence")
setValue(..., "azimuth_scan_width_selection")
setValue(..., "range_scale_selection")
setValue(..., "number_of_bars_selection")
setValue(..., "stby", commitChanges=True)

# 3. Nav data
setValue(..., "z_acceleration_Acceleration_raw")
setValue(..., "corrected_baro_altitude_BaroAltitude_raw")
setValue(..., "radio_altitude_RadioAltitude_raw", commitChanges=True)

# 4. INU mode
setValue(..., "mode_word", commitChanges=True)
```

### 5. **SEMPLIFICARE TEST TARGET**
```python
# RIMUOVERE prepare_radar_for_target_test() prima del test

# Rimuovere STANDBY
setValue(..., stby=0, commitChanges=True)

# Eseguire test (senza attese)
tgt_result = tgt_gen(theGrifo1553, only_bc=False, enable_stim=True, ...)

# Rimettere STANDBY
setValue(..., stby=1, commitChanges=True)
```

### 6. **NON USARE B7**
- Non leggere B7_MsgRdrStatusTellback
- Fidarsi che i comandi siano accettati
- Come fa Albertook

---

## 📊 CONFRONTO TEMPORALE

| Fase | Albertook | Nostra Versione | Differenza |
|------|-----------|-----------------|------------|
| Power ON | 1.5s | 0.1s | -1.4s |
| Stabilizzazione | 0s | 2.0s | +2.0s |
| Setup comandi | ~0s | ~0s | 0s |
| Post-set delay | 0s | 2.0s | +2.0s |
| Verifica tellback | 0s | 0-5.0s | +0-5.0s |
| Pre-PBIT delay | 0s | 2.0s | +2.0s |
| **TOTALE** | **1.5s** | **6.1-11.1s** | **+4.6-9.6s** |

---

## 🎯 CONCLUSIONE

Il codice di Albertook funziona perché è **minimale e diretto**:
1. Nessuna verifica tellback
2. Attese minime
3. Comandi raggruppati
4. Nessuna duplicazione

La nostra versione ha **troppe precauzioni** che potrebbero causare:
- Timeout radar
- Stati inconsistenti
- Messaggi persi
- Configurazione duplicata

**Azione raccomandata:** Tornare ad un approccio più simile ad Albertook, eliminando le verifiche tellback e riducendo le attese.