316 lines
10 KiB
Python
316 lines
10 KiB
Python
"""
|
|
10BASE-T1S Settings Configuration Example
|
|
Demonstrates interactive T1S network configuration
|
|
"""
|
|
|
|
import icsneopy
|
|
|
|
|
|
def get_user_confirmation(prompt):
|
|
"""Get yes/no confirmation from user."""
|
|
response = input(f"{prompt} (y/n): ").strip().lower()
|
|
return response == 'y'
|
|
|
|
|
|
def select_networks(available_networks):
|
|
"""Let user select which networks to configure."""
|
|
print("\n" + "=" * 70)
|
|
print("Select T1S Networks to Configure")
|
|
print("=" * 70)
|
|
|
|
for i, net_id in enumerate(available_networks, 1):
|
|
print(f" [{i}] {net_id}")
|
|
|
|
response = input("\nEnter network numbers to configure (e.g., '1,3' or '1-3' or 'all'): ").strip().lower()
|
|
|
|
if not response:
|
|
return []
|
|
|
|
if response == 'all':
|
|
return available_networks
|
|
|
|
selected = []
|
|
tokens = response.split(',')
|
|
|
|
for token in tokens:
|
|
token = token.strip()
|
|
|
|
if '-' in token:
|
|
try:
|
|
parts = token.split('-')
|
|
start = int(parts[0])
|
|
end = int(parts[1])
|
|
for i in range(start, end + 1):
|
|
if 1 <= i <= len(available_networks):
|
|
selected.append(available_networks[i - 1])
|
|
except (ValueError, IndexError):
|
|
pass
|
|
else:
|
|
try:
|
|
num = int(token)
|
|
if 1 <= num <= len(available_networks):
|
|
selected.append(available_networks[num - 1])
|
|
except ValueError:
|
|
pass
|
|
|
|
return selected
|
|
|
|
|
|
def get_uint8_input(prompt, default_value):
|
|
"""Get uint8 input from user with default."""
|
|
response = input(f"{prompt} [{default_value}]: ").strip()
|
|
if not response:
|
|
return default_value
|
|
try:
|
|
val = int(response)
|
|
if 0 <= val <= 255:
|
|
return val
|
|
except ValueError:
|
|
pass
|
|
return default_value
|
|
|
|
|
|
def get_uint16_input(prompt, default_value):
|
|
"""Get uint16 input from user with default."""
|
|
response = input(f"{prompt} [{default_value}]: ").strip()
|
|
if not response:
|
|
return default_value
|
|
try:
|
|
val = int(response)
|
|
if 0 <= val <= 65535:
|
|
return val
|
|
except ValueError:
|
|
pass
|
|
return default_value
|
|
|
|
|
|
def opt_to_string(opt):
|
|
"""Convert optional value to string for display."""
|
|
if opt is None:
|
|
return "N/A"
|
|
if isinstance(opt, bool):
|
|
return "true" if opt else "false"
|
|
return str(opt)
|
|
|
|
|
|
def display_t1s_settings(device, network):
|
|
"""Display T1S settings for a network."""
|
|
print(f"\t{network} T1S Settings:")
|
|
|
|
settings = device.settings
|
|
if not settings:
|
|
print("\t Unable to read settings")
|
|
return
|
|
|
|
print(f"\t PLCA Enabled: {opt_to_string(settings.is_t1s_plca_enabled(network))}")
|
|
print(f"\t Local ID: {opt_to_string(settings.get_t1s_local_id(network))}")
|
|
print(f"\t Max Nodes: {opt_to_string(settings.get_t1s_max_nodes(network))}")
|
|
print(f"\t TX Opp Timer: {opt_to_string(settings.get_t1s_tx_opp_timer(network))}")
|
|
print(f"\t Max Burst: {opt_to_string(settings.get_t1s_max_burst(network))}")
|
|
print(f"\t Burst Timer: {opt_to_string(settings.get_t1s_burst_timer(network))}")
|
|
|
|
term_enabled = settings.is_t1s_termination_enabled(network)
|
|
if term_enabled is not None:
|
|
print(f"\t Termination: {opt_to_string(term_enabled)}")
|
|
|
|
local_id_alt = settings.get_t1s_local_id_alternate(network)
|
|
if local_id_alt is not None:
|
|
print(f"\t Local ID Alternate: {opt_to_string(local_id_alt)}")
|
|
print(f"\t Bus Dec Beacons: {opt_to_string(settings.is_t1s_bus_decoding_beacons_enabled(network))}")
|
|
print(f"\t Bus Dec All: {opt_to_string(settings.is_t1s_bus_decoding_all_enabled(network))}")
|
|
|
|
multi_id_mask = settings.get_t1s_multi_id_enable_mask(network)
|
|
if multi_id_mask is not None:
|
|
print(f"\t Multi-ID Mask: 0x{multi_id_mask:02X}")
|
|
print("\t Multi-IDs: ", end="")
|
|
multi_ids = []
|
|
for i in range(7):
|
|
multi_id = settings.get_t1s_multi_id(network, i)
|
|
multi_ids.append(f"[{i}]={opt_to_string(multi_id)}")
|
|
print(", ".join(multi_ids))
|
|
|
|
print()
|
|
|
|
|
|
def configure_t1s_network(device, network):
|
|
"""Interactively configure T1S settings for a network."""
|
|
print("\n" + "=" * 70)
|
|
print(f"Configuring T1S Network: {network}")
|
|
print("=" * 70)
|
|
|
|
settings = device.settings
|
|
if not settings:
|
|
print("Unable to read settings")
|
|
return
|
|
|
|
print("\n--- Basic PLCA Settings ---")
|
|
plca_enabled = get_user_confirmation("Enable PLCA")
|
|
settings.set_t1s_plca(network, plca_enabled)
|
|
|
|
local_id = get_uint8_input("Local ID (0-255)", 1)
|
|
settings.set_t1s_local_id(network, local_id)
|
|
|
|
max_nodes = get_uint8_input("Max Nodes (0-255)", 8)
|
|
settings.set_t1s_max_nodes(network, max_nodes)
|
|
|
|
tx_opp_timer = get_uint8_input("TX Opportunity Timer (0-255)", 20)
|
|
settings.set_t1s_tx_opp_timer(network, tx_opp_timer)
|
|
|
|
max_burst = get_uint16_input("Max Burst (0-65535)", 128)
|
|
settings.set_t1s_max_burst(network, max_burst)
|
|
|
|
burst_timer = get_uint16_input("Burst Timer (0-65535)", 64)
|
|
settings.set_t1s_burst_timer(network, burst_timer)
|
|
|
|
if settings.is_t1s_termination_enabled(network) is not None:
|
|
print("\n--- Termination Settings ---")
|
|
term_enabled = get_user_confirmation("Enable Termination")
|
|
settings.set_t1s_termination(network, term_enabled)
|
|
|
|
if settings.get_t1s_local_id_alternate(network) is not None:
|
|
print("\n--- Extended Settings ---")
|
|
local_id_alt = get_uint8_input("Local ID Alternate (0-255)", 0)
|
|
settings.set_t1s_local_id_alternate(network, local_id_alt)
|
|
|
|
bus_dec_beacons = get_user_confirmation("Enable Bus Decoding (Beacons)")
|
|
settings.set_t1s_bus_decoding_beacons(network, bus_dec_beacons)
|
|
|
|
bus_dec_all = get_user_confirmation("Enable Bus Decoding (All Symbols)")
|
|
settings.set_t1s_bus_decoding_all(network, bus_dec_all)
|
|
|
|
if get_user_confirmation("Configure Multi-ID settings?"):
|
|
multi_id_mask = get_uint8_input("Multi-ID Enable Mask (0x00-0xFF, hex)", 0x00)
|
|
settings.set_t1s_multi_id_enable_mask(network, multi_id_mask)
|
|
|
|
print("Configure Multi-IDs (7 slots):")
|
|
for i in range(7):
|
|
multi_id = get_uint8_input(f" Multi-ID [{i}]", 0)
|
|
settings.set_t1s_multi_id(network, i, multi_id)
|
|
|
|
print(f"\n[OK] Configuration staged for {network}")
|
|
|
|
|
|
def main():
|
|
"""Main T1S settings configuration example."""
|
|
device = None
|
|
|
|
try:
|
|
print("\n" + "=" * 70)
|
|
print("10BASE-T1S SETTINGS CONFIGURATION EXAMPLE")
|
|
print("=" * 70)
|
|
print(f"libicsneo {icsneopy.get_version()}")
|
|
print("=" * 70)
|
|
|
|
print("\nFinding devices... ", end="", flush=True)
|
|
devices = icsneopy.find_all_devices()
|
|
print(f"OK, {len(devices)} device{'s' if len(devices) != 1 else ''} found")
|
|
|
|
if not devices:
|
|
print("No devices found!")
|
|
return 1
|
|
|
|
for d in devices:
|
|
print(f" {d}")
|
|
|
|
device = None
|
|
for d in devices:
|
|
if d.get_type().get_device_type() == icsneopy.DeviceType.Enum.RADComet3:
|
|
device = d
|
|
break
|
|
|
|
if not device and devices:
|
|
device = devices[0]
|
|
|
|
if not device:
|
|
print("No suitable device found!")
|
|
return 1
|
|
|
|
print(f"\nSelected device: {device}")
|
|
print(f"Serial: {device.get_serial()}")
|
|
|
|
print("\nOpening device... ", end="", flush=True)
|
|
if not device.open():
|
|
print("FAIL")
|
|
return 1
|
|
print("OK")
|
|
|
|
settings = device.settings
|
|
t1s_networks = []
|
|
for net in device.get_supported_tx_networks():
|
|
if net.get_type() != icsneopy.Network.Type.AutomotiveEthernet:
|
|
continue
|
|
if settings.get_t1s_local_id(net) is not None:
|
|
t1s_networks.append(net)
|
|
|
|
if not t1s_networks:
|
|
print("No T1S networks found on this device")
|
|
device.close()
|
|
return 1
|
|
|
|
print(f"\nFound {len(t1s_networks)} T1S network{'s' if len(t1s_networks) != 1 else ''}:")
|
|
for i, net_id in enumerate(t1s_networks, 1):
|
|
print(f" [{i}] {net_id}")
|
|
|
|
print("\n" + "-" * 70)
|
|
print("Current T1S Settings:")
|
|
print("-" * 70)
|
|
for net_id in t1s_networks:
|
|
display_t1s_settings(device, net_id)
|
|
|
|
networks_to_config = select_networks(t1s_networks)
|
|
|
|
if not networks_to_config:
|
|
print("\nNo networks selected for configuration.")
|
|
print("Closing device... ", end="", flush=True)
|
|
device.close()
|
|
print("OK")
|
|
return 0
|
|
|
|
print(f"\nConfiguring {len(networks_to_config)} network{'s' if len(networks_to_config) != 1 else ''}...")
|
|
|
|
for net_id in networks_to_config:
|
|
configure_t1s_network(device, net_id)
|
|
|
|
print("\n" + "=" * 70)
|
|
save_to_eeprom = get_user_confirmation("Save settings to EEPROM (permanent)?")
|
|
print("=" * 70)
|
|
|
|
settings = device.settings
|
|
print(f"\nApplying settings{' to EEPROM' if save_to_eeprom else ' temporarily'}... ", end="", flush=True)
|
|
success = settings.apply(not save_to_eeprom)
|
|
if not success:
|
|
print("FAIL")
|
|
device.close()
|
|
return 1
|
|
print("OK")
|
|
|
|
print("\n" + "-" * 70)
|
|
print("Updated T1S Settings:")
|
|
print("-" * 70)
|
|
for net_id in t1s_networks:
|
|
display_t1s_settings(device, net_id)
|
|
|
|
print("Closing device... ", end="", flush=True)
|
|
device.close()
|
|
print("OK")
|
|
|
|
except KeyboardInterrupt:
|
|
print("\n\nInterrupted by user")
|
|
return 1
|
|
|
|
except Exception as e:
|
|
print(f"\nError: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return 1
|
|
|
|
finally:
|
|
if device and device.is_open():
|
|
device.close()
|
|
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
exit(main())
|