382 lines
11 KiB
Markdown
382 lines
11 KiB
Markdown
# 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.
|