954 lines
35 KiB
Markdown
954 lines
35 KiB
Markdown
# Analisi Differenze: Target3 vs Codice Corrente
|
||
|
||
**Data Analisi:** 3 Febbraio 2026
|
||
**Autore:** GitHub Copilot (AI Agent)
|
||
|
||
---
|
||
|
||
## 1. EXECUTIVE SUMMARY
|
||
|
||
La configurazione presente nella cartella **target3** implementa una versione **semplificata e focalizzata** del test GRIFO che si concentra principalmente sul **rilevamento target dal radar** tramite messaggi **B9** (Target Report). A differenza del nostro codice corrente che è un framework completo di test PBIT con power cycling, drill-down B8 e statistiche approfondite, target3 è **orientato alla validazione operativa** del radar in modalità target detection.
|
||
|
||
### Differenze Principali:
|
||
1. **Focus primario**: Target detection (B9) invece di PBIT completo
|
||
2. **Architettura**: Test loop semplificato senza power cycling automatico
|
||
3. **ICD**: Verifica di subset ridotto di campi LRU (solo 6 invece di 12)
|
||
4. **Mancanza funzionalità**: Nessun supporto per B8 drill-down, statistiche CSV, GUI
|
||
5. **Target generation**: Implementazione attiva di stimolazione target via bus 1553
|
||
|
||
---
|
||
|
||
## 2. STRUTTURA E ARCHITETTURA
|
||
|
||
### 2.1 Target3 - Caratteristiche
|
||
```
|
||
target3/GrifoAutomaticTestEnv/
|
||
├── TestEnvironment/
|
||
│ ├── env/ # Moduli supporto (identici)
|
||
│ ├── scripts/
|
||
│ │ ├── GRIFO_M_PBIT.py # Script principale (450 righe)
|
||
│ │ ├── GRIFO_test_debug.py
|
||
│ │ └── ... (varianti e log)
|
||
│ └── json/
|
||
│ └── GRIFO_M_PBIT.json # Metadata test base
|
||
└── Documents/
|
||
└── ICD7033158 Rev. D.pdf
|
||
```
|
||
|
||
**Dimensione script principale**: ~450 righe (vs 1919 righe corrente)
|
||
|
||
### 2.2 Codice Corrente - Caratteristiche
|
||
```
|
||
GrifoAutomaticTestEnv/
|
||
├── TestEnvironment/
|
||
│ ├── env/ # Moduli supporto completi
|
||
│ ├── scripts/
|
||
│ │ ├── GRIFO_M_PBIT.py # Script principale (1919 righe)
|
||
│ │ ├── GRIFO_M_PBIT_mock.py # Simulazione completa
|
||
│ │ ├── GRIFO_M_PBIT_gui.py # GUI wrapper
|
||
│ │ └── power_on/off helpers
|
||
│ └── json/
|
||
│ └── GRIFO_M_PBIT.json # Template report esteso
|
||
├── python_simulate_wrapper.py
|
||
├── run_simulate.bat
|
||
└── Documentation estesa (5+ file MD)
|
||
```
|
||
|
||
**Dimensione script principale**: ~1919 righe con supporto completo
|
||
|
||
---
|
||
|
||
## 3. ANALISI FUNZIONALE TARGET3
|
||
|
||
### 3.1 Funzione Principale: `tgt_gen(interface)`
|
||
|
||
**Scopo**: Generare messaggi 1553 per simulare dati di navigazione e inertiali, quindi monitorare il messaggio **B9** (Target Report) per rilevare la presenza del target nel radar.
|
||
|
||
**Implementazione (target3)**:
|
||
```python
|
||
def tgt_gen(interface):
|
||
logging.info('tgt_gen()')
|
||
time.sleep(5)
|
||
period=10 #ms
|
||
tt=0
|
||
|
||
if only_bc: # Broadcasting mode
|
||
setValue(theGrifo1553, 0, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
|
||
# Phase 1: Send initial A5 messages (INU High Speed)
|
||
for i in range(10):
|
||
time.sleep(0.020)
|
||
if only_bc:
|
||
setValue(theGrifo1553, tt, "A5_MsgInuHighSpeed",
|
||
"timetag_RelativeTimetag_raw", commitChanges=True)
|
||
tt+=150
|
||
|
||
# Phase 2: Main loop - stimulate A4 (Nav Data) and monitor B9 (Target Report)
|
||
p_tt=0
|
||
hit=0
|
||
for i in range(1000):
|
||
time.sleep(0.010)
|
||
|
||
if only_bc:
|
||
setValue(theGrifo1553, tt, "A4_MsgNavDataAndCursor",
|
||
"timetag_RelativeTimetag_raw", commitChanges=True)
|
||
tt+=150
|
||
if tt>0x70ff:
|
||
tt=10
|
||
|
||
# Monitor B9 message
|
||
cnt = interface.getSingleMessageReceivedSz("B9")
|
||
t_num=interface.getMessageFieldValue("B9", "b9_t_num")
|
||
t_rng=interface.getMessageFieldValue("B9", "b9_t1_rng")
|
||
t_tt=interface.getMessageFieldValue("B9", "b9_w12")
|
||
|
||
if (p_tt==0):
|
||
p_tt=t_tt
|
||
continue
|
||
|
||
if (i % 10)==0:
|
||
dcnt=cnt-pcnt
|
||
pcnt=cnt
|
||
logging.info(f'TgtMsg: {cnt} {dcnt}')
|
||
|
||
# Check if target detected
|
||
if (t_num>0) or (p_tt!=t_tt):
|
||
logging.info(f'Tgt: {t_num} @ {t_rng} tt={t_tt}')
|
||
tgt_expected=2536
|
||
ret_proc_sts, err=check(theGrifo1553,
|
||
(tgt_expected-1000, tgt_expected+200), "B9", "b9_t1_rng")
|
||
if (ret_proc_sts is True):
|
||
logging.info(f'TgtMsg hit {hit}')
|
||
hit=hit+1
|
||
if (hit>10): # Exit after 10 successful detections
|
||
logging.info(f'TgtMsg hit {hit}')
|
||
return
|
||
p_tt=t_tt
|
||
if interruptRequest is True:
|
||
break
|
||
```
|
||
|
||
**Parametri chiave**:
|
||
- **tgt_expected**: 2536 (range atteso del target - in unità ICD)
|
||
- **Tolleranza**: ±1000 a ±200 unità (range: 1536-2736)
|
||
- **Successo**: 10 rilevamenti consecutivi
|
||
- **Timeout implicito**: ~10 secondi (1000 iterazioni × 10ms)
|
||
|
||
### 3.2 Funzione Wrapper: `tgt_gen_alone(interface)`
|
||
|
||
**Scopo**: Eseguire ripetutamente `tgt_gen()` in modalità standalone con logging 1553.
|
||
|
||
```python
|
||
def tgt_gen_alone(interface):
|
||
interface.logStart(3, os.path.dirname(sys.argv[0]))
|
||
for n in range(10*1000): # 10K iterations
|
||
logging.info(f'tgt_gen_alone(): {n}')
|
||
tgt_gen(interface)
|
||
if interruptRequest is True:
|
||
break
|
||
interface.logStop()
|
||
return True
|
||
```
|
||
|
||
**Caratteristiche**:
|
||
- Logging 1553 attivo (livello 3)
|
||
- Loop infinito (10K iterazioni)
|
||
- Supporto Ctrl-C per interruzione
|
||
|
||
---
|
||
|
||
## 4. FLOW DI TEST TARGET3
|
||
|
||
### 4.1 Sequenza di Test Principale
|
||
|
||
```python
|
||
def test_proc():
|
||
# 1. Setup iniziale
|
||
logger_setup('GRIFO_M_PBIT.log')
|
||
report = testReport(sys.argv[0])
|
||
interface = theGrifo1553.getInterface()
|
||
terminal = leo_grifo_terminal.GrifoSerialTerminal()
|
||
terminal.connect()
|
||
|
||
# 2. Configurazione iniziale radar
|
||
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)
|
||
|
||
# 3. Configurazione dati navigazione (A4)
|
||
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)
|
||
|
||
# 4. Configurazione INU (A5)
|
||
setValue(theGrifo1553, 0xAA54, "A5_MsgInuHighSpeed",
|
||
"mode_word", commitChanges=True)
|
||
|
||
# 5. Loop ripetizioni
|
||
for repetition in range(NUMBER_OF_REPETITIONS):
|
||
report.open_session(f'Repetition {1 + repetition} of {NUMBER_OF_REPETITIONS}')
|
||
|
||
if only_bc:
|
||
setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_silence")
|
||
setValue(theGrifo1553, 1, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
setValue(theGrifo1553, 127, "A1_MsgRdrSettingsAndParameters",
|
||
"settings_RDROperationalSettings_rdr_symbology_intensity", commitChanges=True)
|
||
|
||
# 5a. Esegui target generation test
|
||
tgt_gen_alone(interface)
|
||
|
||
# 5b. Power cycling test (opzionale)
|
||
for onoff_rep in range(1):
|
||
report.add_comment("Switch off target and wait 3 seconds.")
|
||
power_grifo_off(4, 1)
|
||
if interruptRequest is True:
|
||
break
|
||
report.add_comment("Switch on target.")
|
||
power_grifo_on(0.100)
|
||
|
||
# 5c. Wait for BIT completion
|
||
remaining_time = PBIT_SEC_TIME
|
||
max_counter_1553_msg = 20
|
||
|
||
setValue(theGrifo1553, 100, "A1_MsgRdrSettingsAndParameters",
|
||
"settings_RDROperationalSettings_rdr_symbology_intensity", commitChanges=True)
|
||
|
||
while remaining_time > 0:
|
||
start = time.perf_counter()
|
||
ret_rep_is_avail = False
|
||
msg_cnt = 0
|
||
mil1553_error_flag = max_counter_1553_msg
|
||
|
||
for i in range(100):
|
||
cnt = interface.getSingleMessageReceivedSz("B6_MsgRdrSettingsAndParametersTellback")
|
||
value = interface.getMessageFieldValue("B6_MsgRdrSettingsAndParametersTellback",
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_bit_report_available")
|
||
ret_rep_is_avail = value == "true"
|
||
if ret_rep_is_avail is True:
|
||
break
|
||
time.sleep(0.05)
|
||
|
||
# 1553 comm loss detection
|
||
if cnt > msg_cnt:
|
||
mil1553_error_flag = max_counter_1553_msg
|
||
else:
|
||
mil1553_error_flag -=1
|
||
msg_cnt = cnt
|
||
|
||
if mil1553_error_flag == 0:
|
||
logging.critical("1553 communication lost")
|
||
return False
|
||
|
||
# 5d. Check LRU status (B6)
|
||
if ret_rep_is_avail is True:
|
||
time.sleep(0.02)
|
||
report.add_comment("bit report avail occurred..")
|
||
logging.info("Check health status...")
|
||
|
||
no_fail=True
|
||
for lru in lru_fields: # Only 6 LRU fields
|
||
ret_proc_sts, err = check(theGrifo1553,"false",
|
||
"B6_MsgRdrSettingsAndParametersTellback", lru)
|
||
if ret_proc_sts is False:
|
||
no_fail=False
|
||
|
||
# 5e. Force B8 drill-down (unconditional)
|
||
no_fail=False # Force check to verify SW requirements
|
||
if no_fail is False:
|
||
logging.info("Check BIT Report...")
|
||
for f in bit_fields: # Subset di campi B8
|
||
ret_error_field, err = check(theGrifo1553,"false","B8_MsgBitReport",f)
|
||
test_return = (test_return and ret_error_field)
|
||
|
||
time_passed = time.perf_counter() - start
|
||
remaining_time -= time_passed
|
||
if ret_rep_is_avail is True:
|
||
remaining_time = 0
|
||
logging.info(f'{remaining_time:.1f}s remaining ...')
|
||
|
||
report.close_session()
|
||
|
||
if interruptRequest is True:
|
||
report.add_comment("Test interrupted by user (Ctrl-C)")
|
||
break
|
||
|
||
# 5f. Return to STBY
|
||
setValue(theGrifo1553, 0, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
|
||
# 6. Cleanup
|
||
report.add_comment("Repetitions terminated.")
|
||
power_grifo_off()
|
||
if terminal is not None:
|
||
terminal.disconnect()
|
||
report.generate_pdf()
|
||
|
||
return test_return
|
||
```
|
||
|
||
---
|
||
|
||
## 5. CONFRONTO: TARGET3 VS CORRENTE
|
||
|
||
### 5.1 Messaggi 1553 Utilizzati
|
||
|
||
| Messaggio | Target3 | Corrente | Scopo |
|
||
|-----------|---------|----------|-------|
|
||
| **A1** | ✓ Intensity | ✓ Completo | Settings & Parameters |
|
||
| **A2** | ✓ Basic | ✓ Completo | Operation Command |
|
||
| **A4** | ✓ Nav Data | ✓ Completo | Navigation Data & Cursor |
|
||
| **A5** | ✓ Timetag | ✓ Completo | INU High Speed |
|
||
| **B6** | ✓ 6 LRU | ✓ 12 LRU | Settings Tellback & Status |
|
||
| **B8** | ✓ Subset | ✓ Completo | BIT Report (185 fields) |
|
||
| **B9** | ✓ FOCUS | ✗ ASSENTE | Target Report |
|
||
|
||
**❗ DIFFERENZA CRITICA**: Target3 usa **B9** per rilevamento target, **assente nel nostro codice ICD**.
|
||
|
||
### 5.2 Campi B6 (LRU Status)
|
||
|
||
**Target3** - Solo 6 campi:
|
||
```python
|
||
lru_fields = (
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_processor_status",
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_trasmitter_status",
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_receiver_status",
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_rx_front_end_status",
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_servoloop_status",
|
||
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_array_status"
|
||
)
|
||
```
|
||
|
||
**Corrente** - 12 campi completi (include anche pedestal, radar_fail_status, ecc.)
|
||
|
||
**⚠️ Note**: Target3 **esclude**:
|
||
- `radar_fail_status` (campo aggregato)
|
||
- `pedestal_status` (commentato - HW non disponibile)
|
||
|
||
### 5.3 Campi B8 (BIT Report)
|
||
|
||
**Target3** - Subset ridotto:
|
||
- **Degradation**: Tutti commentati (non verificati)
|
||
- **SRU Failures**: ~40 campi (vs 43 corrente)
|
||
- **Test Results**: ~115 campi (vs 118 corrente)
|
||
|
||
**Esclusioni principali**:
|
||
```python
|
||
# Target3 - Commentati/esclusi:
|
||
# "degradation_conditions_w1_..." (tutti i 12 campi degradation)
|
||
# "failure_location_pedestal_FailureLocationPedestal_sru1_gimbal"
|
||
# "integrated_system_test_results_..._pedestal_status"
|
||
# "servoloop_test_results_..._test_sl15_pedestal_centre_scan_location"
|
||
```
|
||
|
||
**Corrente** - Set completo con gestione `KNOWN_FAILURES` per HW non disponibile.
|
||
|
||
### 5.4 Gestione Power Cycling
|
||
|
||
| Feature | Target3 | Corrente |
|
||
|---------|---------|----------|
|
||
| Auto power off before test | ✗ | ✓ |
|
||
| Auto power on before test | ✗ | ✓ |
|
||
| Power off between reps | ✓ Manual | ✓ Auto |
|
||
| Wait times configurabili | ✗ | ✓ |
|
||
| Timing aligned with target2 | ✗ | ✓ |
|
||
|
||
**Target3**: Power cycling manuale richiesto dall'operatore con prompts.
|
||
**Corrente**: Power cycling automatico con timing configurabili (wait_before, wait_after).
|
||
|
||
### 5.5 Statistiche e Report
|
||
|
||
| Feature | Target3 | Corrente |
|
||
|---------|---------|----------|
|
||
| PDF Report | ✓ Basic | ✓ Completo |
|
||
| CSV Export | ✗ | ✓ |
|
||
| JSON Statistics | ✗ | ✓ |
|
||
| Per-run timing | ✗ | ✓ |
|
||
| B6/B8 counters | ✗ | ✓ |
|
||
| Serial statistics | ✗ | ✓ |
|
||
| Failure drill-down | ✗ | ✓ |
|
||
| Known failures tracking | ✗ | ✓ |
|
||
| Target detection stats | ✗ | ✓ Placeholder |
|
||
|
||
**Corrente** ha sistema statistiche avanzato con export CSV/JSON e tracking granulare.
|
||
|
||
### 5.6 Modalità Simulazione
|
||
|
||
| Feature | Target3 | Corrente |
|
||
|---------|---------|----------|
|
||
| Mock mode | ✗ | ✓ |
|
||
| --simulate flag | ✗ | ✓ |
|
||
| Mock objects | ✗ | ✓ |
|
||
| Replay scenarios | ✗ | ✓ |
|
||
| GUI wrapper | ✗ | ✓ |
|
||
|
||
**Corrente** supporta modalità simulazione completa senza HW (`GRIFO_M_PBIT_mock.py`).
|
||
|
||
---
|
||
|
||
## 6. MESSAGGI B9 - ANALISI DETTAGLIATA
|
||
|
||
### 6.1 Struttura Messaggio B9 (Target Report)
|
||
|
||
**Campi utilizzati in target3**:
|
||
```python
|
||
# B9 message fields (da codice target3)
|
||
cnt = interface.getSingleMessageReceivedSz("B9") # Message counter
|
||
t_num = interface.getMessageFieldValue("B9", "b9_t_num") # Number of targets
|
||
t_rng = interface.getMessageFieldValue("B9", "b9_t1_rng") # Target 1 range
|
||
t_tt = interface.getMessageFieldValue("B9", "b9_w12") # Word 12 (timetag?)
|
||
```
|
||
|
||
**Campi ICD B9 (presunti da utilizzo)**:
|
||
- `b9_t_num`: Number of detected targets (0-N)
|
||
- `b9_t1_rng`: Target 1 range (unità da ICD - presumibilmente meters o yards)
|
||
- `b9_w12`: Word 12 - Timetag o altro campo temporale
|
||
|
||
**Range atteso**: 2536 ± (1000 to 200) unità ICD
|
||
|
||
### 6.2 Correlazione con Messaggi A4/A5
|
||
|
||
**Target3 stimola**:
|
||
- **A4** (`MsgNavDataAndCursor`): Dati navigazione (altitudine, accelerazione)
|
||
- **A5** (`MsgInuHighSpeed`): Dati inerziali ad alta frequenza (timetag)
|
||
|
||
**Ipotesi**: Il radar utilizza A4/A5 per:
|
||
1. Stabilizzazione antenna (A4: accelerazioni)
|
||
2. Riferimento temporale (A5: timetag)
|
||
3. Generazione tracce target sintetiche interne per test
|
||
|
||
**Il nostro codice corrente**:
|
||
- Ha stub `tgt_gen()` ma **non stimola attivamente A4/A5**
|
||
- **Manca supporto ICD per B9** (messaggio non definito)
|
||
|
||
---
|
||
|
||
## 7. COSA MANCA AL NOSTRO CODICE
|
||
|
||
### 7.1 ICD - Definizione Messaggio B9
|
||
|
||
**✅ AGGIORNAMENTO (2026-02-03)**: Il messaggio B9 **È GIÀ PRESENTE** nel nostro ICD XML!
|
||
|
||
**Verifica completata**:
|
||
1. ✓ B9 definito in `icd_1553_bus_controller.xml` (Message Id="19", 512 bit, RX, periodic 20ms)
|
||
2. ✓ Tutti i campi chiave presenti:
|
||
- `b9_t_num` (offset 176) - numero target rilevati
|
||
- `b9_t1_rng` (offset 224) - range target 1
|
||
- `b9_w12` (offset 192) - word 12 (timetag)
|
||
- `b9_t1_az` (offset 304) - azimuth target 1
|
||
- `b9_t2_rng` (offset 384) - range target 2
|
||
- `b9_t2_az` (offset 464) - azimuth target 2
|
||
3. ✓ B9 già mappato nel simulator (Map Id="19")
|
||
4. ✓ Mock completo già implementato in `GRIFO_M_PBIT_mock.py`
|
||
|
||
**Conclusione**: Non serve modificare l'ICD o i bindings SWIG. B9 è accessibile e pronto all'uso.
|
||
|
||
### 7.2 Funzione tgt_gen() Operativa
|
||
|
||
**Corrente**: Stub placeholder (righe 619-667) con:
|
||
- Logging basic
|
||
- Timeout configurabile
|
||
- Check B9 fields (ma B9 non disponibile)
|
||
- Return True/False per detection
|
||
|
||
**Mancante rispetto target3**:
|
||
```python
|
||
# 1. Stimolazione attiva A4/A5 con timetag
|
||
setValue(theGrifo1553, tt, "A4_MsgNavDataAndCursor",
|
||
"timetag_RelativeTimetag_raw", commitChanges=True)
|
||
setValue(theGrifo1553, tt, "A5_MsgInuHighSpeed",
|
||
"timetag_RelativeTimetag_raw", commitChanges=True)
|
||
|
||
# 2. Loop incremento timetag con wrap
|
||
tt += 150
|
||
if tt > 0x70ff:
|
||
tt = 10
|
||
|
||
# 3. Monitoring continuo B9 con contatori
|
||
cnt = interface.getSingleMessageReceivedSz("B9")
|
||
dcnt = cnt - pcnt # Delta count
|
||
|
||
# 4. Detection basata su t_num>0 oppure cambiamento timetag
|
||
if (t_num>0) or (p_tt!=t_tt):
|
||
# Target found!
|
||
```
|
||
|
||
**Azioni richieste**:
|
||
1. ✗ Implementare stimolazione attiva A4/A5 in `tgt_gen()`
|
||
2. ✗ Aggiungere logica incremento timetag con wrap
|
||
3. ✗ Implementare monitoring B9 con delta counting
|
||
4. ✗ Aggiungere check range atteso (configurabile)
|
||
|
||
### 7.3 Configurazione Radar Pre-Test
|
||
|
||
**Target3 configura esplicitamente**:
|
||
```python
|
||
# Range scale, scan width, bars
|
||
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")
|
||
|
||
# Nav data values
|
||
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)
|
||
|
||
# INU mode
|
||
setValue(theGrifo1553, 0xAA54, "A5_MsgInuHighSpeed",
|
||
"mode_word", commitChanges=True)
|
||
```
|
||
|
||
**Corrente**: Ha `set_radar_operational()` ma **non configura questi valori specifici**.
|
||
|
||
**Azioni richieste**:
|
||
1. ✗ Aggiungere configurazione scan width/range/bars in `set_radar_operational()`
|
||
2. ✗ Aggiungere settaggio valori nav data (altitude, accel)
|
||
3. ✗ Aggiungere settaggio INU mode word
|
||
|
||
### 7.4 Gestione STBY/SILENCE per Target Test
|
||
|
||
**Target3 workflow**:
|
||
```python
|
||
# 1. Set SILENCE
|
||
setValue(..., "rdr_mode_command_RdrModeCommandWord_silence")
|
||
|
||
# 2. Set STBY
|
||
setValue(..., "rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
|
||
# 3. Run target generation
|
||
tgt_gen_alone(interface)
|
||
|
||
# 4. Return to STBY only (unset both)
|
||
setValue(..., 0, "rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
```
|
||
|
||
**Corrente**: Ha helper `verify_tellback_stby()` ma **non sequence specifica per target test**.
|
||
|
||
**Azioni richieste**:
|
||
1. ✗ Creare helper `prepare_radar_for_target_test()` che sequenza SILENCE→STBY
|
||
2. ✗ Validare timing delays dopo ogni set
|
||
3. ✗ Aggiungere cleanup function per unset STBY dopo test
|
||
|
||
### 7.5 Integrazione in Test Flow
|
||
|
||
**Target3**: `tgt_gen_alone()` chiamato **prima** del power cycling e BIT check.
|
||
|
||
**Corrente**: Ha placeholder per target test ma **non integrato in main loop**.
|
||
|
||
**Azioni richieste**:
|
||
1. ✗ Decidere posizione target test nel flow (pre-PBIT? post-PBIT? separato?)
|
||
2. ✗ Aggiungere flag `ENABLE_TARGET_TEST` (default: False fino a B9 disponibile)
|
||
3. ✗ Integrare `tgt_gen()` in loop ripetizioni con statistiche
|
||
4. ✗ Aggiungere colonna "Target Detected" in CSV export
|
||
|
||
---
|
||
|
||
## 8. ROADMAP IMPLEMENTAZIONE
|
||
|
||
### 8.1 Phase 1: ~~ICD e Infrastruttura~~ (✅ COMPLETATO)
|
||
|
||
**✅ SCOPERTA**: B9 è già presente e completamente funzionante!
|
||
|
||
1. ✅ **ICD XML contiene B9** - Verificato in `icd_1553_bus_controller.xml`
|
||
2. ✅ **SWIG bindings includono B9** - `interpreter.py` già supporta B9
|
||
3. ✅ **Mock implementato** - `GRIFO_M_PBIT_mock.py` simula B9 completamente
|
||
4. ✅ **Mappatura 1553** - B9 mappato correttamente (Map Id="19")
|
||
|
||
**Phase 1 completata automaticamente** - Non serve nessuna azione!
|
||
|
||
~~**Tempo stimato**: 2-3 giorni (dipende da disponibilità ICD e toolchain SWIG)~~
|
||
**Tempo reale**: 0 giorni (già presente)
|
||
|
||
### 8.2 Phase 2: Implementazione tgt_gen() Base
|
||
|
||
1. **Aggiornare `tgt_gen()` in `GRIFO_M_PBIT.py`**
|
||
- Rimuovere placeholder corrente (righe 619-667)
|
||
- Port logica da target3 con miglioramenti:
|
||
```python
|
||
def tgt_gen(interface, timeout_sec=None, expected_range=2536, range_tolerance=(1000, 200)):
|
||
"""
|
||
Target generation and detection test.
|
||
|
||
Stimulates radar with A4/A5 nav data and monitors B9 for target detection.
|
||
|
||
Args:
|
||
interface: Grifo1553 interface object
|
||
timeout_sec: Max seconds to wait (default: TARGET_DETECTION_TIMEOUT_SEC)
|
||
expected_range: Expected target range in ICD units (default: 2536)
|
||
range_tolerance: (lower_tol, upper_tol) tuple (default: (1000, 200))
|
||
|
||
Returns:
|
||
dict: {'detected': bool, 'hits': int, 'range': float, 'iterations': int}
|
||
"""
|
||
# Implementation here
|
||
```
|
||
|
||
2. **Implementare stimolazione A4/A5**
|
||
- Settaggio timetag incrementale con wrap a 0x70ff
|
||
- Commit messages a ~10ms rate
|
||
- Logging delta counts ogni 10 iterazioni
|
||
|
||
3. **Implementare monitoring B9**
|
||
- Lettura continua `getSingleMessageReceivedSz("B9")`
|
||
- Parsing `b9_t_num`, `b9_t1_rng`, `b9_w12`
|
||
- Detection logic: `t_num>0` OR `timetag_changed`
|
||
- Range validation con tolerance configurabile
|
||
|
||
4. **Aggiungere return structured result**
|
||
```python
|
||
return {
|
||
'detected': bool,
|
||
'hits': int, # Successful range validations
|
||
'range': float, # Last detected range
|
||
'iterations': int, # Total loop iterations
|
||
'time_to_detect': float, # Seconds until first detection
|
||
'message_count': int # B9 messages received
|
||
}
|
||
```
|
||
|
||
**Tempo stimato**: 1-2 giorni
|
||
|
||
### 8.3 Phase 3: Configurazione Radar Pre-Test
|
||
|
||
1. **Estendere `set_radar_operational()`**
|
||
- Aggiungere parametri:
|
||
```python
|
||
def set_radar_operational(interface, range_nm=40.0, intensity=127,
|
||
master_mode='RWS', gm_submode=0,
|
||
# NEW:
|
||
azimuth_scan_width=1,
|
||
range_scale_selection=2,
|
||
number_of_bars=1,
|
||
altitude_ft=8202, # 2500m * 3.28
|
||
z_accel_g=1.08, # 1060 raw units
|
||
inu_mode_word=0xAA54):
|
||
```
|
||
|
||
2. **Implementare sequence SILENCE→STBY**
|
||
```python
|
||
def prepare_radar_for_target_test(interface):
|
||
"""Set radar in SILENCE+STBY mode before target generation test."""
|
||
setValue(interface, 1, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_silence", commitChanges=True)
|
||
time.sleep(TELLBACK_POST_SET_DELAY_SEC)
|
||
|
||
setValue(interface, 1, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
time.sleep(TELLBACK_POST_SET_DELAY_SEC)
|
||
|
||
# Verify tellbacks
|
||
return verify_tellback_stby(interface, timeout_sec=5.0)
|
||
```
|
||
|
||
3. **Implementare cleanup**
|
||
```python
|
||
def cleanup_radar_after_target_test(interface):
|
||
"""Unset STBY after target test."""
|
||
setValue(interface, 0, "A2_MsgRdrOperationCommand",
|
||
"rdr_mode_command_RdrModeCommandWord_stby", commitChanges=True)
|
||
time.sleep(STBY_POST_UNSET_DELAY_SEC)
|
||
```
|
||
|
||
**Tempo stimato**: 1 giorno
|
||
|
||
### 8.4 Phase 4: Integrazione in Test Loop
|
||
|
||
1. **Aggiungere flag configurazione**
|
||
```python
|
||
# Top of GRIFO_M_PBIT.py
|
||
ENABLE_TARGET_TEST = False # Set True when B9 available
|
||
TARGET_TEST_POSITION = 'pre-pbit' # 'pre-pbit' | 'post-pbit' | 'standalone'
|
||
```
|
||
|
||
2. **Integrare in `run_single_pbit_cycle()`**
|
||
```python
|
||
def run_single_pbit_cycle(...):
|
||
# ... existing power on ...
|
||
|
||
if ENABLE_TARGET_TEST and TARGET_TEST_POSITION == 'pre-pbit':
|
||
logging.info("=== TARGET DETECTION TEST ===")
|
||
report.open_session("Target Detection Pre-PBIT")
|
||
|
||
# Prepare radar
|
||
prepare_ok = prepare_radar_for_target_test(theGrifo1553.getInterface())
|
||
if not prepare_ok:
|
||
report.add_comment("WARN: Could not prepare radar for target test")
|
||
|
||
# Run target test
|
||
tgt_result = tgt_gen(theGrifo1553.getInterface())
|
||
|
||
# Record result
|
||
repetition_stats['target_detected'] = tgt_result.get('detected', False)
|
||
repetition_stats['target_hits'] = tgt_result.get('hits', 0)
|
||
repetition_stats['target_range'] = tgt_result.get('range', None)
|
||
|
||
if tgt_result['detected']:
|
||
report.add_comment(f"Target DETECTED after {tgt_result['time_to_detect']:.1f}s "
|
||
f"@ range {tgt_result['range']}")
|
||
else:
|
||
report.add_comment("Target NOT detected (timeout)")
|
||
|
||
# Cleanup
|
||
cleanup_radar_after_target_test(theGrifo1553.getInterface())
|
||
report.close_session()
|
||
|
||
# ... existing PBIT flow ...
|
||
```
|
||
|
||
3. **Aggiornare CSV export**
|
||
- Aggiungere colonne: `Target Detected`, `Target Hits`, `Target Range`
|
||
|
||
4. **Aggiornare statistiche aggregate**
|
||
```python
|
||
# In calculate_statistics()
|
||
target_tests = [r.get('target_detected', None) for r in stats['repetitions']]
|
||
target_detected_count = sum(1 for t in target_tests if t is True)
|
||
target_pass_rate = (target_detected_count / len(target_tests) * 100) if target_tests else 0.0
|
||
|
||
stats['aggregate']['target_detected_count'] = target_detected_count
|
||
stats['aggregate']['target_not_detected_count'] = len(target_tests) - target_detected_count
|
||
stats['aggregate']['target_pass_rate'] = target_pass_rate
|
||
```
|
||
|
||
**Tempo stimato**: 2 giorni
|
||
|
||
### 8.5 Phase 5: Testing e Validazione
|
||
|
||
1. **Test simulazione (mock)**
|
||
- Aggiornare `GRIFO_M_PBIT_mock.py` con mock B9 responses
|
||
- Testare `tgt_gen()` in modalità `--simulate`
|
||
- Validare statistiche e report
|
||
|
||
2. **Test HW (se disponibile)**
|
||
- Eseguire su setup reale con radar
|
||
- Validare range detection
|
||
- Tune timeout e tolerance parameters
|
||
|
||
3. **Documentazione**
|
||
- Aggiornare `IMPLEMENTATION_SUMMARY.md`
|
||
- Aggiungere sezione "Target Detection" in `GRIFO_Test_Environment_Analysis.md`
|
||
- Creare `TARGET_DETECTION_GUIDE.md` con:
|
||
- ICD B9 reference
|
||
- Configuration parameters
|
||
- Troubleshooting
|
||
|
||
**Tempo stimato**: 2-3 giorni
|
||
|
||
---
|
||
|
||
## 9. CONFIGURAZIONI DA COPIARE DA TARGET3
|
||
|
||
### 9.1 Valori Hardcoded da Preservare
|
||
|
||
```python
|
||
# From target3 - VALORI CRITICI PER TARGET DETECTION
|
||
|
||
# A2 - Radar Operation
|
||
AZIMUTH_SCAN_WIDTH_SELECTION = 1 # param1
|
||
RANGE_SCALE_SELECTION = 2 # param1 (range scale 40nm?)
|
||
NUMBER_OF_BARS_SELECTION = 1 # param1
|
||
|
||
# A4 - Navigation Data
|
||
Z_ACCELERATION_RAW = 1060 # ~1.08g
|
||
CORRECTED_BARO_ALTITUDE_RAW = 2500 # ~8202 ft (2500m)
|
||
RADIO_ALTITUDE_RAW = 2500 # Matching baro
|
||
|
||
# A5 - INU High Speed
|
||
INU_MODE_WORD = 0xAA54 # Mode/status word
|
||
|
||
# B9 - Target Detection
|
||
TARGET_EXPECTED_RANGE = 2536 # ICD units (meters? yards?)
|
||
TARGET_RANGE_TOLERANCE_LOW = 1000 # -1000 units
|
||
TARGET_RANGE_TOLERANCE_HIGH = 200 # +200 units
|
||
TARGET_HITS_THRESHOLD = 10 # Successful detections before exit
|
||
|
||
# Timing
|
||
TIMETAG_INCREMENT = 150 # Increment per iteration
|
||
TIMETAG_WRAP = 0x70ff # Wrap point
|
||
TIMETAG_RESET = 10 # Reset value after wrap
|
||
TARGET_GEN_PERIOD_MS = 10 # Loop period (ms)
|
||
TARGET_GEN_MAX_ITERATIONS = 1000 # ~10s timeout
|
||
```
|
||
|
||
### 9.2 Sequence Diagram - Target Detection
|
||
|
||
```
|
||
Operator Test Script Radar (via 1553) Result
|
||
| | | |
|
||
|-- Start Test -------->| | |
|
||
| |-- A2: SILENCE ----->| |
|
||
| |-- A2: STBY -------->| |
|
||
| | (wait 2s) | |
|
||
| | | |
|
||
| |-- A4: Nav Data ---->| |
|
||
| |-- A5: INU Mode ---->| |
|
||
| | (wait 5s) | |
|
||
| | | |
|
||
| |====== LOOP (1000 iterations) ====== |
|
||
| |-- A4: Timetag ----->| |
|
||
| | (tt+=150) | |
|
||
| |<--- B9: Target -----| |
|
||
| |-- Check t_num ----->| |
|
||
| |-- Check t_rng ----->| |
|
||
| | | |
|
||
| | [if t_num>0] | |
|
||
| |-- Validate range -->|-- ✓ HIT ------->|
|
||
| | [if 10 hits] | |
|
||
| |====== EXIT LOOP ================= |
|
||
| | | |
|
||
| |-- A2: Unset STBY -->| |
|
||
| | | |
|
||
| |====== Continue to PBIT ============== |
|
||
```
|
||
|
||
---
|
||
|
||
## 10. RACCOMANDAZIONI
|
||
|
||
### 10.1 Priorità Alta - Bloccanti
|
||
|
||
1. **Ottenere ICD Rev. D**
|
||
- Richiesta formale a team documentazione
|
||
- Verificare se già disponibile in `PlatformSimulator/` o archivi
|
||
|
||
2. **Validare esistenza B9 in simulator**
|
||
- Test manuale con `uPlatSim` per vedere se B9 è già supportato
|
||
- Potrebbe essere già nel simulator ma non esposto in Python bindings
|
||
|
||
3. **Decision: Dove integrare target test**
|
||
- **Opzione A**: Pre-PBIT (come target3) - validazione radar operativo prima di BIT
|
||
- **Opzione B**: Post-PBIT - validazione funzionale dopo BIT passed
|
||
- **Opzione C**: Standalone - test separato eseguibile indipendentemente
|
||
|
||
### 10.2 Priorità Media - Miglioramenti
|
||
|
||
1. **Configurazioni flessibili**
|
||
- Spostare valori hardcoded in `instrument_settings.json`
|
||
- Permettere override via CLI arguments
|
||
|
||
2. **Mock simulation**
|
||
- Estendere `GRIFO_M_PBIT_mock.py` con B9 synthetic responses
|
||
- Testare target detection senza HW
|
||
|
||
3. **Diagnostics**
|
||
- Aggiungere logging dettagliato timetag progression
|
||
- Plot range detections over time (matplotlib export)
|
||
|
||
### 10.3 Priorità Bassa - Nice to Have
|
||
|
||
1. **Multi-target support**
|
||
- Target3 check solo `b9_t1_rng` (target 1)
|
||
- Estendere per N targets se B9 supporta
|
||
|
||
2. **Range sweep test**
|
||
- Variare A4 altitude/accel per testare range variations
|
||
|
||
3. **Integration con GUI**
|
||
- Live plot target detections in `GRIFO_M_PBIT_gui.py`
|
||
|
||
---
|
||
|
||
## 11. RISCHI E MITIGAZIONI
|
||
|
||
| Rischio | Impatto | Probabilità | Mitigazione |
|
||
|---------|---------|-------------|-------------|
|
||
| B9 non disponibile in ICD corrente | 🔴 Alto | Media | Ottenere ICD Rev. D; verificare simulator |
|
||
| SWIG rebuild richiede toolchain non disponibile | 🔴 Alto | Bassa | Usare binaries pre-compilati da target3 |
|
||
| Range units non documentati | 🟡 Medio | Media | Reverse-engineer da test HW; validare con team radar |
|
||
| Target detection timeout su HW reale | 🟡 Medio | Alta | Parametri configurabili; increase timeout |
|
||
| Stimolazione A4/A5 interfere con PBIT | 🟡 Medio | Bassa | Separare target test con cleanup; testare sequenze |
|
||
|
||
---
|
||
|
||
## 12. CONCLUSIONI
|
||
|
||
### 12.1 Gap Summary
|
||
|
||
Il codice **target3** è una **variante specializzata** focalizzata su:
|
||
1. **Validazione operativa radar** (target detection)
|
||
2. **Test manuale con operatore** (power cycling, visual checks)
|
||
3. **Subset ridotto di verifiche** (6 LRU, subset B8)
|
||
|
||
Il nostro codice **corrente** è un **framework completo** ma **manca**:
|
||
1. ❌ **Supporto ICD per B9** (messaggio target report)
|
||
2. ❌ **Stimolazione attiva A4/A5** per target generation
|
||
3. ❌ **Workflow target detection** integrato nel flow
|
||
|
||
### 12.2 Next Steps
|
||
|
||
**IMMEDIATO**:
|
||
1. Analizzare `target3/Documents/ICD7033158 Rev. D.pdf` per definizione B9
|
||
2. Verificare se B9 è già nel simulator (test manuale)
|
||
3. Decidere architecture target test (pre/post/standalone PBIT)
|
||
|
||
**SHORT-TERM (1-2 settimane)**:
|
||
4. Implementare Phase 1-2 della roadmap (ICD + tgt_gen base)
|
||
5. Testing in modalità simulazione
|
||
6. Documentazione
|
||
|
||
**MEDIUM-TERM (3-4 settimane)**:
|
||
7. Integrazione completa nel test loop
|
||
8. Validazione su HW
|
||
9. Statistiche e report estesi
|
||
|
||
---
|
||
|
||
## APPENDICE A: FILE DA ANALIZZARE
|
||
|
||
**Da target3**:
|
||
1. `target3/.../Documents/ICD7033158 Rev. D.pdf` - **PRIORITÀ 1**
|
||
2. `target3/.../scripts/GRIFO_M_PBIT.py` (righe 1-450)
|
||
3. `target3/.../env/leo_grifo_1553.py` (identico al nostro)
|
||
|
||
**Da corrente**:
|
||
1. `TestEnvironment/scripts/GRIFO_M_PBIT.py` (righe 619-667 - stub tgt_gen)
|
||
2. `TestEnvironment/env/leo_grifo_1553.py` (no B9 support)
|
||
3. `PlatformSimulator/bin/interpreter.py` (bindings SWIG)
|
||
|
||
---
|
||
|
||
## APPENDICE B: CONTATTI E RISORSE
|
||
|
||
**Domande da porre al team**:
|
||
1. È disponibile ICD7033158 Rev. D con definizione B9?
|
||
2. Il simulator uPlatSim già supporta B9 message?
|
||
3. Quali sono le unità di misura per `b9_t1_rng`? (meters? yards? feet?)
|
||
4. Esiste documentazione per target generation test procedure?
|
||
5. I valori hardcoded (2536 range, 0xAA54 INU mode) sono specifici per setup Genova?
|
||
|
||
**Risorse**:
|
||
- ICD: `ICD7033158 Rev. D.pdf` (in target3/Documents)
|
||
- Simulator: `PlatformSimulator/bin/uPlatSim.exe`
|
||
- SWIG source: (verificare se disponibile per rebuild)
|
||
|
||
---
|
||
|
||
**Fine Documento**
|
||
|
||
---
|
||
|
||
**Autore**: GitHub Copilot AI Agent
|
||
**Data**: 2026-02-03
|
||
**Versione**: 1.0
|
||
**Repository**: GrifoAutomaticTestEnv
|