538 lines
17 KiB
Markdown
538 lines
17 KiB
Markdown
# Analisi Comparativa: Target1 (Versione Intermedia) vs Versione Corrente
|
|
|
|
**Data Analisi**: 2026-02-02
|
|
**Analista**: AI Assistant
|
|
**Scopo**: Identificare modifiche implementate dal collega in target1 e valutare se adottarle nella versione corrente
|
|
|
|
---
|
|
|
|
## 1. Executive Summary
|
|
|
|
### Contesto
|
|
La cartella **target1** contiene una versione intermedia sviluppata da un collega che ha cercato di portare alcune modifiche su target. Questa versione **non funziona correttamente** ma contiene alcune idee interessanti.
|
|
|
|
### Raccomandazione Finale
|
|
**✅ MANTENERE LA VERSIONE CORRENTE** con le seguenti integrazioni selettive da target1:
|
|
1. ✅ **Adottare**: Meccanismo di rilevamento perdita comunicazione 1553
|
|
2. ❌ **Non adottare**: Modifica indentazione errata in `leo_grifo_terminal.py`
|
|
3. ⚠️ **Valutare**: Rimozione commenti B8 (già presente nella nostra versione)
|
|
|
|
---
|
|
|
|
## 2. Confronto Strutturale
|
|
|
|
### 2.1 File Modificati in Target1
|
|
|
|
| File | Stato in Target1 | File .bak Presente |
|
|
|------|------------------|-------------------|
|
|
| `GRIFO_M_PBIT.py` | Modificato (1125 righe) | ✅ Sì |
|
|
| `test_common_function.py` | Modificato | ✅ Sì |
|
|
| `leo_grifo_terminal.py` | Modificato | ✅ Sì |
|
|
| `brainbox_interface.py` | Modificato | ✅ Sì |
|
|
|
|
**Nota**: I file `.bak` indicano versioni pre-modifica salvate dal collega.
|
|
|
|
---
|
|
|
|
## 3. Analisi Dettagliata delle Modifiche
|
|
|
|
### 3.1 GRIFO_M_PBIT.py - Differenze Chiave
|
|
|
|
#### A) Configurazione Parametri
|
|
|
|
**Target1**:
|
|
```python
|
|
NUMBER_OF_REPETITIONS = 2 # Total test cycles to execute (4 perfect runs = 40%)
|
|
PBIT_SEC_TIME = 180 # BIT completion timeout in seconds
|
|
EXPORT_STATISTICS_CSV = True
|
|
```
|
|
|
|
**Versione Corrente**:
|
|
```python
|
|
NUMBER_OF_REPETITIONS = 10 # Total test cycles to execute
|
|
PBIT_SEC_TIME = 182 # BIT completion timeout (aligned with target2)
|
|
EXPORT_STATISTICS_CSV = True
|
|
FORCE_B8_DRILL_DOWN = False # NEW: conditional B8 execution
|
|
```
|
|
|
|
**Differenza Critica**:
|
|
- ✅ **Nostra versione SUPERIORE**: `PBIT_SEC_TIME = 182` (allineato a target2)
|
|
- ✅ **Nostra versione SUPERIORE**: Flag `FORCE_B8_DRILL_DOWN` per flessibilità
|
|
- ⚠️ Target1 ha `NUMBER_OF_REPETITIONS = 2` (probabilmente per debug veloce)
|
|
|
|
---
|
|
|
|
#### B) Known Failures Implementation
|
|
|
|
**Target1**:
|
|
```python
|
|
KNOWN_FAILURES = [
|
|
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_pedestal_status",
|
|
# Add more known HW setup limitations here as needed
|
|
]
|
|
```
|
|
|
|
**Versione Corrente**:
|
|
```python
|
|
KNOWN_FAILURES = {
|
|
"radar_health_status_and_bit_report_valid_RdrHealthStatusAndBitReport_pedestal_status":
|
|
"Pedestal subsystem not present in test HW setup",
|
|
}
|
|
```
|
|
|
|
**Differenza**:
|
|
- ✅ **Nostra versione SUPERIORE**: Usa dict con descrizioni esplicative (più manutenibile)
|
|
- ⚠️ Target1 usa lista semplice (meno informativa)
|
|
|
|
---
|
|
|
|
#### C) ⭐ MECCANISMO RILEVAMENTO PERDITA 1553 (IDEA INTERESSANTE)
|
|
|
|
**Target1 - Righe 810-830**:
|
|
```python
|
|
max_counter_1553_msg = 20
|
|
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(...)
|
|
ret_rep_is_avail = value == "true"
|
|
if ret_rep_is_avail is True:
|
|
break
|
|
time.sleep(0.05)
|
|
|
|
# ⭐ CHECK COMUNICAZIONE 1553 ⭐
|
|
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
|
|
```
|
|
|
|
**Versione Corrente**:
|
|
```python
|
|
# NON PRESENTE - polling semplice senza rilevamento perdita comunicazione
|
|
for i in range(100):
|
|
cnt = interface.getSingleMessageReceivedSz("B6_MsgRdrSettingsAndParametersTellback")
|
|
value = interface.getMessageFieldValue(...)
|
|
ret_rep_is_avail = value == "true"
|
|
if ret_rep_is_avail:
|
|
break
|
|
time.sleep(0.05)
|
|
```
|
|
|
|
**Valutazione**:
|
|
- ✅ **IDEA UTILE**: Rileva se il contatore di messaggi 1553 si blocca (indica perdita bus)
|
|
- ✅ **VANTAGGIO**: Evita attese inutili di 180s se il bus è morto
|
|
- ⚠️ **IMPLEMENTAZIONE**: Necessita test su hardware reale per validare la soglia (20 iterazioni)
|
|
- 📊 **RACCOMANDAZIONE**: **DA INTEGRARE NELLA NOSTRA VERSIONE** con parametro configurabile
|
|
|
|
---
|
|
|
|
#### D) Commenti nei Campi B8
|
|
|
|
**Target1**:
|
|
```python
|
|
bit_fields = (
|
|
# ===== B8: Degradation Conditions =====
|
|
#"degradation_conditions_w1_DegradationConditionsW1_bcn_fail", # COMMENTATI
|
|
#"degradation_conditions_w1_DegradationConditionsW1_gm_rbm_sea1_ta_wa_fail",
|
|
# ... altri commentati ...
|
|
|
|
# ===== B8: SRU Failure Locations =====
|
|
#"failure_location_pedestal_FailureLocationPedestal_sru1_gimbal", # COMMENTATO
|
|
"failure_location_pedestal_FailureLocationPedestal_sru2_waveguide", # ATTIVO
|
|
# ... mix di commentati e attivi ...
|
|
```
|
|
|
|
**Versione Corrente**:
|
|
```python
|
|
# B8 fields: tutti definiti e categorizzati in bit_fields_categories
|
|
bit_fields_categories = {
|
|
'B6_LRU_Status': [...], # 12 fields
|
|
'B8_Degradation': [...], # 12 fields - TUTTI ATTIVI
|
|
'B8_SRU_Locations': [...], # 43 fields - TUTTI ATTIVI
|
|
'B8_AGC_Tests': [...], # etc.
|
|
}
|
|
```
|
|
|
|
**Differenza**:
|
|
- ✅ **Nostra versione SUPERIORE**: Tutti i campi B8 attivi e categorizzati per report strutturato
|
|
- ⚠️ Target1 ha campi commentati (probabilmente per debugging incrementale)
|
|
- ✅ **Nostra versione**: Drill-down condizionale tramite `FORCE_B8_DRILL_DOWN` (più flessibile)
|
|
|
|
---
|
|
|
|
### 3.2 test_common_function.py - Power Control
|
|
|
|
#### Implementazione wait_before
|
|
|
|
**Target1**:
|
|
```python
|
|
def power_grifo_on(wait_after=0, wait_before=0):
|
|
time.sleep(wait_before)
|
|
setValue(theBrainBox, True, 'MAIN_POWER')
|
|
ret, err = check(theBrainBox, 1, 'MAIN_POWER')
|
|
time.sleep(wait_after)
|
|
return ret
|
|
|
|
def power_grifo_off(wait_after=0, wait_before=0):
|
|
time.sleep(wait_before)
|
|
setValue(theBrainBox, False, 'MAIN_POWER')
|
|
ret, err = check(theBrainBox, 0, 'MAIN_POWER', timeout=0.1)
|
|
time.sleep(wait_after)
|
|
return ret
|
|
```
|
|
|
|
**Versione Corrente**: **IDENTICA** ✅
|
|
|
|
**Conclusione**: Questa modifica è già presente nella nostra versione (implementata durante l'integrazione target2).
|
|
|
|
---
|
|
|
|
### 3.3 leo_grifo_terminal.py - ⚠️ BUG CRITICO
|
|
|
|
#### Indentazione Errata in Target1
|
|
|
|
**Target1 - Righe 66-69**:
|
|
```python
|
|
elif '%%F' in dummy:
|
|
self._serial_stats['fatal_messages'] += 1
|
|
self._serial_stats['fatal_details'].append((timestamp, dummy))
|
|
|
|
# ⚠️ INDENTAZIONE ERRATA - check RECYCLE dentro elif %%F ⚠️
|
|
if 'RECYCLE' in dummy.upper():
|
|
self._serial_stats['recycle_count'] += 1
|
|
self._serial_stats['recycle_details'].append((timestamp, dummy))
|
|
```
|
|
|
|
**Problema**: Il check `RECYCLE` è indentato dentro `elif '%%F'`, quindi viene eseguito SOLO per messaggi `%%F`, non per messaggi `%%E`!
|
|
|
|
**Versione Corrente (CORRETTA)**:
|
|
```python
|
|
if '%%E' in dummy:
|
|
self._serial_stats['error_messages'] += 1
|
|
self._serial_stats['error_details'].append((timestamp, dummy))
|
|
elif '%%F' in dummy:
|
|
self._serial_stats['fatal_messages'] += 1
|
|
self._serial_stats['fatal_details'].append((timestamp, dummy))
|
|
|
|
# ✅ INDENTAZIONE CORRETTA - check RECYCLE fuori da if/elif ✅
|
|
if 'RECYCLE' in dummy.upper():
|
|
self._serial_stats['recycle_count'] += 1
|
|
self._serial_stats['recycle_details'].append((timestamp, dummy))
|
|
```
|
|
|
|
**Valutazione**:
|
|
- ❌ **Target1 ha BUG**: RECYCLE non viene rilevato nei messaggi `%%E`
|
|
- ✅ **Nostra versione CORRETTA**: RECYCLE rilevato in TUTTI i messaggi di errore
|
|
- 🚫 **NON ADOTTARE** questa modifica da target1
|
|
|
|
---
|
|
|
|
### 3.4 brainbox_interface.py - Modifiche Socket
|
|
|
|
**Target1**:
|
|
```python
|
|
def send_data(self, message: str) -> (bool, AnyStr):
|
|
try:
|
|
if self.__client_socket is None:
|
|
self.__connect()
|
|
|
|
self.__client_socket.sendall(message.encode())
|
|
except Exception as e:
|
|
return False, None, f'BrainboxInterface EXCEPTION: {e}'
|
|
|
|
self.__client_socket.settimeout(self.timeout)
|
|
data_raw = self.__client_socket.recv(1024)
|
|
data = data_raw.decode()
|
|
error = None
|
|
|
|
self.__disconnect() # ⭐ CHIUDE SOCKET DOPO OGNI COMANDO
|
|
|
|
# ... gestione risposte ...
|
|
```
|
|
|
|
**Versione Corrente**:
|
|
- Non disponibile per confronto diretto (probabilmente identica alla versione target2)
|
|
|
|
**Valutazione**:
|
|
- ⚠️ La chiusura socket dopo ogni comando è **corretta** per protocollo request-response
|
|
- ✅ Probabilmente già presente nella nostra versione (da verificare)
|
|
|
|
---
|
|
|
|
## 4. Statistiche e Report CSV
|
|
|
|
### 4.1 Export CSV Strutturato
|
|
|
|
**Target1** - Righe 204-400:
|
|
```python
|
|
def export_statistics_to_csv(custom_statistics, test_name, output_folder):
|
|
"""
|
|
Export test statistics to CSV file for external analysis (Excel, etc.).
|
|
|
|
Creates a CSV file with three sections:
|
|
1. Per-Run Statistics: Detailed results for each run
|
|
2. Aggregate Statistics: Overall summary metrics
|
|
3. Problem Distribution: Analysis of failure types
|
|
"""
|
|
# ... implementazione completa con JSON per dettagli ...
|
|
|
|
# Section 4: Problem Distribution Analysis
|
|
problem_counts = {}
|
|
for run in custom_statistics['repetitions']:
|
|
if not run['success']:
|
|
for field, value in run['failures']:
|
|
# Extract clean field names
|
|
test_name_clean = field.split('RdrHealthStatusAndBitReport_')[-1]
|
|
problem_counts[test_name_clean] = problem_counts.get(test_name_clean, 0) + 1
|
|
```
|
|
|
|
**Versione Corrente**: **IDENTICA** (già implementata) ✅
|
|
|
|
**Conclusione**: Export CSV già presente nella nostra versione con stessa struttura.
|
|
|
|
---
|
|
|
|
## 5. GUI Monitor Integration
|
|
|
|
### 5.1 Integrazione GUI Real-time
|
|
|
|
**Target1** ha integrazione GUI estesa:
|
|
```python
|
|
# Update GUI - power on
|
|
if gui_monitor:
|
|
gui_monitor.update_status(power_on=True)
|
|
gui_monitor.log_event('info', 'Power ON - waiting for BIT...')
|
|
|
|
# Update GUI with B6 progress
|
|
if gui_monitor and run_stats['b6_total'] % 3 == 0:
|
|
gui_monitor.update_statistics(
|
|
b6_total=run_stats['b6_total'],
|
|
b6_pass=run_stats['b6_pass'],
|
|
b6_fail=run_stats['b6_fail'],
|
|
b6_known=run_stats['b6_known_fail']
|
|
)
|
|
```
|
|
|
|
**Versione Corrente**: **IDENTICA** (già implementata) ✅
|
|
|
|
**Conclusione**: Integrazione GUI già presente e funzionante nella nostra versione.
|
|
|
|
---
|
|
|
|
## 6. Tabella Comparativa Sintetica
|
|
|
|
| Feature | Target1 | Versione Corrente | Vincitore |
|
|
|---------|---------|------------------|-----------|
|
|
| `PBIT_SEC_TIME` | 180s | 182s (aligned target2) | ✅ **Corrente** |
|
|
| `wait_before` parameter | ✅ Presente | ✅ Presente | ⚖️ Pari |
|
|
| Known Failures | Lista semplice | Dict con descrizioni | ✅ **Corrente** |
|
|
| `FORCE_B8_DRILL_DOWN` | ❌ Assente | ✅ Presente | ✅ **Corrente** |
|
|
| Campi B8 completi | ❌ Parziali (commentati) | ✅ Tutti attivi | ✅ **Corrente** |
|
|
| Rilevamento perdita 1553 | ✅ **Presente** | ❌ Assente | ⚠️ **Target1** |
|
|
| Check RECYCLE | ❌ **Bug indentazione** | ✅ Corretto | ✅ **Corrente** |
|
|
| Export CSV | ✅ Presente | ✅ Presente | ⚖️ Pari |
|
|
| GUI Integration | ✅ Presente | ✅ Presente | ⚖️ Pari |
|
|
| Serial logging completo | ❌ Solo DEBUG | ✅ INFO (appena implementato) | ✅ **Corrente** |
|
|
|
|
---
|
|
|
|
## 7. Problemi Identificati in Target1
|
|
|
|
### 7.1 Bug Critici
|
|
|
|
1. **❌ Indentazione RECYCLE** (leo_grifo_terminal.py:66-69)
|
|
- **Impatto**: RECYCLE non rilevato in messaggi `%%E`
|
|
- **Soluzione**: Già corretto nella nostra versione
|
|
|
|
2. **❌ Campi B8 commentati** (GRIFO_M_PBIT.py:515-530)
|
|
- **Impatto**: Copertura incompleta test B8
|
|
- **Soluzione**: Nostra versione ha tutti i campi attivi
|
|
|
|
### 7.2 Configurazioni Subottimali
|
|
|
|
1. **⚠️ `PBIT_SEC_TIME = 180s`**
|
|
- **Problema**: Non allineato a target2 (182s)
|
|
- **Rischio**: Timeout prematuro su hardware lento
|
|
- **Soluzione**: Già corretto nella nostra versione (182s)
|
|
|
|
2. **⚠️ `NUMBER_OF_REPETITIONS = 2`**
|
|
- **Problema**: Troppo basso per statistica robusta
|
|
- **Soluzione**: Nostra versione usa 10 (configurabile)
|
|
|
|
---
|
|
|
|
## 8. Modifiche Consigliate per Versione Corrente
|
|
|
|
### 8.1 DA INTEGRARE ✅
|
|
|
|
#### 1. Meccanismo Rilevamento Perdita Comunicazione 1553
|
|
|
|
**Priorità**: ALTA
|
|
**File**: `GRIFO_M_PBIT.py`
|
|
**Linee**: ~940-960 (polling loop BIT)
|
|
|
|
**Implementazione Consigliata**:
|
|
```python
|
|
# In GRIFO_M_PBIT.py, aggiungere parametro configurabile
|
|
COMM_LOSS_THRESHOLD = 20 # iterations without msg count increase = comm lost
|
|
|
|
# Nel polling loop:
|
|
max_counter_1553_msg = COMM_LOSS_THRESHOLD
|
|
msg_cnt = 0
|
|
mil1553_error_flag = max_counter_1553_msg
|
|
|
|
for i in range(100):
|
|
cnt = interface.getSingleMessageReceivedSz("B6_MsgRdrSettingsAndParametersTellback")
|
|
|
|
# Check communication health
|
|
if cnt > msg_cnt:
|
|
mil1553_error_flag = max_counter_1553_msg # Reset counter
|
|
else:
|
|
mil1553_error_flag -= 1
|
|
|
|
msg_cnt = cnt
|
|
|
|
if mil1553_error_flag == 0:
|
|
logging.critical("1553 communication lost - message counter stalled")
|
|
report.add_comment("CRITICAL: 1553 bus communication lost", False)
|
|
return False
|
|
|
|
value = interface.getMessageFieldValue(...)
|
|
ret_rep_is_avail = value == "true"
|
|
if ret_rep_is_avail:
|
|
break
|
|
time.sleep(0.05)
|
|
```
|
|
|
|
**Vantaggi**:
|
|
- ✅ Rileva freeze del bus 1553 (HW issue o disconnessione)
|
|
- ✅ Evita attese inutili di 180s quando il bus è morto
|
|
- ✅ Fornisce diagnostica chiara dell'errore
|
|
- ✅ Parametro configurabile per tuning su HW reale
|
|
|
|
**Test richiesti**:
|
|
- Validare soglia `COMM_LOSS_THRESHOLD = 20` su hardware target
|
|
- Test di disconnessione bus durante PBIT
|
|
- Verificare comportamento con messaggi 1553 sporadici
|
|
|
|
---
|
|
|
|
### 8.2 DA NON INTEGRARE ❌
|
|
|
|
1. **❌ Indentazione RECYCLE errata** (leo_grifo_terminal.py)
|
|
- Nostra versione già corretta
|
|
|
|
2. **❌ Campi B8 commentati** (GRIFO_M_PBIT.py)
|
|
- Nostra versione ha copertura completa
|
|
|
|
3. **❌ `PBIT_SEC_TIME = 180s`**
|
|
- Nostra versione già aggiornata a 182s
|
|
|
|
4. **❌ Known Failures come lista**
|
|
- Nostra versione usa dict con descrizioni (migliore)
|
|
|
|
---
|
|
|
|
## 9. Conclusioni e Raccomandazioni Finali
|
|
|
|
### 9.1 Decisione Strategica
|
|
|
|
**✅ MANTENERE VERSIONE CORRENTE COME BASE**
|
|
|
|
La nostra versione è **superiore** in quasi tutti gli aspetti:
|
|
- ✅ Timeout PBIT corretto (182s vs 180s)
|
|
- ✅ Flag `FORCE_B8_DRILL_DOWN` per flessibilità
|
|
- ✅ Known failures con descrizioni esplicative
|
|
- ✅ Tutti i campi B8 attivi e categorizzati
|
|
- ✅ Check RECYCLE corretto
|
|
- ✅ Serial logging completo (INFO level)
|
|
|
|
### 9.2 Unica Modifica Utile da Target1
|
|
|
|
**⭐ Integrare meccanismo rilevamento perdita comunicazione 1553**
|
|
|
|
- **Priorità**: ALTA
|
|
- **Tempo Implementazione**: ~30 minuti
|
|
- **Testing**: Necessario su hardware reale
|
|
- **Rischio**: BASSO (fail-safe: timeout esistente rimane come backup)
|
|
|
|
### 9.3 Piano di Azione Consigliato
|
|
|
|
#### Step 1: Integrazione Meccanismo 1553 (OPZIONALE)
|
|
```bash
|
|
# 1. Aggiungere parametro configurabile in GRIFO_M_PBIT.py
|
|
COMM_LOSS_THRESHOLD = 20 # default, tunable
|
|
|
|
# 2. Implementare logica rilevamento nel polling loop
|
|
# 3. Test in simulazione
|
|
python TestEnvironment\scripts\GRIFO_M_PBIT.py --simulate
|
|
|
|
# 4. Test su hardware reale (quando disponibile)
|
|
python TestEnvironment\scripts\GRIFO_M_PBIT.py
|
|
```
|
|
|
|
#### Step 2: Validazione Finale
|
|
- ✅ Test simulazione: verificare che non impatti funzionalità esistenti
|
|
- ✅ Test hardware: validare soglia 20 iterazioni è appropriata
|
|
- ✅ Test disconnessione: simulare perdita bus 1553 durante PBIT
|
|
|
|
#### Step 3: Deploy su Target
|
|
- Usare versione corrente con/senza meccanismo 1553 (a scelta)
|
|
- Verificare tutti i test passano correttamente
|
|
- Monitorare log per eventuali false positive "communication lost"
|
|
|
|
---
|
|
|
|
## 10. Appendice: File Log Target1
|
|
|
|
**Log Presenti** (target1/GrifoAutomaticTestEnv/TestEnvironment/scripts/):
|
|
```
|
|
Grifo 1553 Interface__2026_01_28_16_37_03.log
|
|
Grifo 1553 Interface__2026_01_28_16_50_56.log
|
|
Grifo 1553 Interface__2026_01_28_16_52_12.log
|
|
Grifo 1553 Interface__2026_01_28_16_58_18.log
|
|
Grifo 1553 Interface__2026_01_28_17_12_54.log
|
|
```
|
|
|
|
**Osservazione**: Presenza di 5 log in una finestra temporale ristretta (21 minuti) suggerisce:
|
|
- ⚠️ Tentativi multipli di debug
|
|
- ⚠️ Possibili crash o errori ripetuti
|
|
- ⚠️ Test non completati con successo
|
|
|
|
Questo conferma che **target1 non funziona correttamente** come dichiarato dall'utente.
|
|
|
|
---
|
|
|
|
## 11. Riepilogo Esecutivo (TL;DR)
|
|
|
|
### ✅ Cosa Fare
|
|
1. **MANTENERE** versione corrente come base definitiva
|
|
2. **INTEGRARE** (opzionale) meccanismo rilevamento perdita 1553
|
|
3. **PROCEDERE** con test su hardware reale usando versione corrente
|
|
|
|
### ❌ Cosa NON Fare
|
|
1. **NON adottare** indentazione RECYCLE errata da target1
|
|
2. **NON adottare** campi B8 commentati da target1
|
|
3. **NON regredire** timeout PBIT a 180s
|
|
4. **NON rimuovere** flag `FORCE_B8_DRILL_DOWN` o known failures dict
|
|
|
|
### 📊 Confidence Score
|
|
- **Versione Corrente Superiority**: 95%
|
|
- **Target1 Ideas Worth Adopting**: 5% (solo meccanismo 1553)
|
|
- **Risk of Regression**: LOW (con attenzione a non adottare bug)
|
|
|
|
---
|
|
|
|
**Fine Documento**
|
|
**Prossimo Step**: Decidere se integrare meccanismo 1553 o procedere con versione corrente as-is per test hardware.
|