def publish_signals(stub): source = common_pb2.ClientId(id="app_identifier") namespace = common_pb2.NameSpace(name="VirtualCanInterface") signal = common_pb2.SignalId(name="BenchC_c_5", namespace=namespace) signal_with_payload = network_api_pb2.Signal(id=signal) signal_with_payload.integer = 4 signal2 = common_pb2.SignalId(name="BenchC_c_2", namespace=namespace) signal_with_payload_2 = network_api_pb2.Signal(id=signal2) signal_with_payload_2.double = 3.4 signal3 = common_pb2.SignalId(name="BenchC_d_2", namespace=namespace) signal_with_payload_3 = network_api_pb2.Signal(id=signal3) signal_with_payload_3.arbitration = True publisher_info = network_api_pb2.PublisherConfig( clientId=source, signals=network_api_pb2.Signals( signal=[signal_with_payload, signal_with_payload_2]), frequency=0) try: stub.PublishSignals(publisher_info) time.sleep(1) except grpc._channel._Rendezvous as err: print(err)
def ecu_A(stub, pause): while True: global increasing_counter namespace = "ecu_A" clientId = common_pb2.ClientId(id="id_ecu_A") # counter counter = common_pb2.SignalId(name="counter", namespace=common_pb2.NameSpace(name = namespace)) counter_with_payload = network_api_pb2.Signal(id = counter, integer = increasing_counter) # TestFr06_Child02 - another signal testFr06_Child02 = common_pb2.SignalId(name="TestFr06_Child02", namespace=common_pb2.NameSpace(name = namespace)) testFr06_Child02_with_payload = network_api_pb2.Signal(id = testFr06_Child02, integer = increasing_counter+1) # TestFr04 - now a frame testFr04 = common_pb2.SignalId(name="TestFr04", namespace=common_pb2.NameSpace(name = namespace)) testFr04_with_payload = network_api_pb2.Signal(id = testFr04, integer = increasing_counter+2) print("\necu_A, seed is ", increasing_counter) publish_signals(clientId, stub, [counter_with_payload, testFr06_Child02_with_payload, testFr04_with_payload]) time.sleep(pause) # read the other value and output result counter_times_2 = common_pb2.SignalId(name="counter_times_2", namespace=common_pb2.NameSpace(name = namespace)) read_counter_times_2 = read_signal(stub, counter_times_2) print("ecu_A, (result) counter_times_2 is ", read_counter_times_2.signal[0].integer) increasing_counter = (increasing_counter + 1) % 10
def publish_signals(client_id, stub, diag_frame_resp): signal_with_payload = network_api_pb2.Signal(id=diag_frame_resp) signal_with_payload.raw = b'\x01\x02\x03\x04\x05\x06\x07\x08' # signal_with_payload.raw = binascii.unhexlify("0102030405060708") publisher_info = network_api_pb2.PublisherConfig( clientId=client_id, signals=network_api_pb2.Signals(signal=[signal_with_payload]), frequency=0) try: stub.PublishSignals(publisher_info) except grpc._channel._Rendezvous as err: print(err)
def ecu_B_subscribe(stub): namespace = "ecu_B" client_id = common_pb2.ClientId(id="id_ecu_B") counter = common_pb2.SignalId(name="counter", namespace=common_pb2.NameSpace(name = namespace)) sub_info = network_api_pb2.SubscriberConfig(clientId=client_id, signals=network_api_pb2.SignalIds(signalId=[counter]), onChange=False) try: for subs_counter in stub.SubscribeToSignals(sub_info): print("ecu_B, (subscribe) counter is ", subs_counter.signal[0].integer) counter_times_2 = common_pb2.SignalId(name="counter_times_2", namespace=common_pb2.NameSpace(name = namespace)) signal_with_payload = network_api_pb2.Signal(id = counter_times_2, integer = subs_counter.signal[0].integer * 2) publish_signals(client_id, stub, [signal_with_payload]) except grpc._channel._Rendezvous as err: print(err)
def signal_with_payload(self, name, namespace_name, value_pair, allow_malformed=False): signal = self.signal(name, namespace_name) key, value = value_pair types = ["integer", "double", "raw", "arbitration"] if key not in types: raise Exception(f"type must be one of: {types}") if key is "raw" and allow_malformed is False: assert len(value) * 8 == self._sinfos[( namespace_name, name )].size, f"payload size missmatch, expected {self._sinfos[(namespace_name, name)].size/8} bytes" params = {"id": signal, key: value} return network_api_pb2.Signal(**params)
def ecu_B_subscribe(stub): """Subscribe to a value published by ecu_A and publish doubled value back to ecu_A Parameters ---------- stub : NetworkServiceStub Object instance of class """ namespace = "ecu_B" client_id = common_pb2.ClientId(id="id_ecu_B") # Subscribe to value 'counter' counter = common_pb2.SignalId( name="counter", namespace=common_pb2.NameSpace(name=namespace) ) sub_info = network_api_pb2.SubscriberConfig( clientId=client_id, signals=network_api_pb2.SignalIds(signalId=[counter]), onChange=True, ) # Publish doubled value as 'counter_times_2' try: for subs_counter in stub.SubscribeToSignals(sub_info): print("ecu_B, (subscribe) counter is ", subs_counter.signal[0].integer) counter_times_2 = common_pb2.SignalId( name="counter_times_2", namespace=common_pb2.NameSpace(name=namespace) ) signal_with_payload = network_api_pb2.Signal( id=counter_times_2, integer=subs_counter.signal[0].integer * 2 ) publish_signals(client_id, stub, [signal_with_payload]) except grpc._channel._Rendezvous as err: print(err)
def ecu_A(stub, pause): """Publishes a value, read other value (published by ecu_B) Parameters ---------- stub : NetworkServiceStub Object instance of class pause : int Amount of time to pause, in seconds """ while True: global increasing_counter namespace = "ecu_A" clientId = common_pb2.ClientId(id="id_ecu_A") # Publishes value 'counter' counter = common_pb2.SignalId( name="counter", namespace=common_pb2.NameSpace(name=namespace)) counter_with_payload = network_api_pb2.Signal( id=counter, integer=increasing_counter) publish_signals(clientId, stub, [counter_with_payload]) print("\necu_A, seed is ", increasing_counter) time.sleep(pause) # Read the other value 'counter_times_2' and output result counter_times_2 = common_pb2.SignalId( name="counter_times_2", namespace=common_pb2.NameSpace(name=namespace)) read_counter_times_2 = read_signal(stub, counter_times_2) print( "ecu_A, (result) counter_times_2 is ", read_counter_times_2.signal[0].integer, ) increasing_counter = (increasing_counter + 1) % 4
reload_configuration(system_stub) # create the identifier of *this* client client_id = common_pb2.ClientId(id="virtual_example_pub") # For 10 messages for _ in range(10): input_value = input("Enter a number: ") try: signal_value = int(input_value) except ValueError: print(f"{input_value} is not a number. Only numbers are allowed") else: # Create a signal namespace = common_pb2.NameSpace(name="VirtualInterface") signal = common_pb2.SignalId(name="my_madeup_virtual_signal", namespace=namespace) # Add payload to the signal signal_with_payload = network_api_pb2.Signal(id=signal) # 20 bytes chosen as an arbitrary number signal_with_payload.raw = signal_value.to_bytes(20, 'big') # long vectors are valid on virtual networks! # signal_with_payload.integer = signal_value # Create a publisher config signals = network_api_pb2.Signals(signal=(signal_with_payload, )) publisher_info = network_api_pb2.PublisherConfig( clientId=client_id, signals=signals, frequency=0) # Publish try: network_stub.PublishSignals(publisher_info) except grpc._channel._Rendezvous as err: print(err)
def run(argv): """Main function, checking arguments passed to script, setting up stubs, configuration and starting Threads. Parameters ---------- argv : list Arguments passed when starting script """ # Checks argument passed to script, ecu.py will use below ip-address if no argument is passed to the script ip = "127.0.0.1" # Keep this port port = ":50051" try: opts, args = getopt.getopt(argv, "h", ["ip="]) except getopt.GetoptError: print("Usage: ecu.py --ip <ip_address>") sys.exit(2) for opt, arg in opts: if opt == "-h": print("Usage: ecu.py --ip <ip_address>") sys.exit(2) elif opt == "--ip": ip = arg # Setting up stubs and configuration channel = grpc.insecure_channel(ip + port) network_stub = network_api_pb2_grpc.NetworkServiceStub(channel) system_stub = system_api_pb2_grpc.SystemServiceStub(channel) # check_license(system_stub) upload_folder(system_stub, "configuration_lin") reload_configuration(system_stub) # grace period to let clients time to pull their configuration time.sleep(5) clientId = common_pb2.ClientId(id="this_python_app_identifier") # slave, prepare to answer to diag request, this gets loaded pening in the transiever (waiting for aribitration) namespace_slave = "ecu_B" signal = common_pb2.SignalId( name="SlaveResp", namespace=common_pb2.NameSpace(name=namespace_slave)) signal_with_payload = network_api_pb2.Signal( id=signal, raw=b"\x81\x09\x0a\x0b\x0c\x0d\x0e\x0f") publish_signals(network_stub, clientId, [signal_with_payload], 0) print("Slave is ready to reply to diag request %s" % (signal_with_payload)) # master, subscribe to answer from client (just listen) namespace_master = "ecu_A" frame = common_pb2.SignalId( name="SlaveResp", namespace=common_pb2.NameSpace(name=namespace_master)) # frame = common_pb2.SignalId(name="counter_times_2", namespace=common_pb2.NameSpace(name = namespace_master)) ecu_m_subscribe = Thread(target=ecu_master_subscribe, args=(network_stub, clientId, [frame], False)) ecu_m_subscribe.daemon = True # allow this thread to be automatically stopped on exit. ecu_m_subscribe.start() # Just listen from slave, for debug purposes # frame2 = common_pb2.SignalId(name="MasterReq", namespace=common_pb2.NameSpace(name = namespace_slave)) # ecu_s_subscribe = Thread(target = ecu_slave_subscribe, args = (network_stub, clientId, [frame, frame2], False)) # ecu_s_subscribe.start() # # send arbitration from master (not needed arbitration is enabled inte inderfaces.json), expect nothing back! (send arbitration) # # signal = common_pb2.SignalId(name="SlaveResp", namespace=common_pb2.NameSpace(name = namespace_master)) # signal_with_payload = network_api_pb2.Signal(id = signal, arbitration = True) # publish_signals(network_stub, clientId, [signal_with_payload], 0) # print("sent %s from master expect nothing back" % (signal_with_payload)) # time.sleep(3) # send master request, now with propriate NAD, DEVS2 has NAD 0x81 (which is the fist byte below) signal = common_pb2.SignalId( name="MasterReq", namespace=common_pb2.NameSpace(name=namespace_master)) signal_with_payload = network_api_pb2.Signal( id=signal, raw=b"\x81\x02\x03\x04\x05\x06\x07\x08") publish_signals(network_stub, clientId, [signal_with_payload], 0) print("sent %s from master expect ANSWER" % (signal_with_payload)) time.sleep(3) # # send arbitration from master, expect answer since nad is matching # signal = common_pb2.SignalId(name="SlaveResp", namespace=common_pb2.NameSpace(name = namespace_master)) # signal_with_payload = network_api_pb2.Signal(id = signal, arbitration = True) # publish_signals(network_stub, clientId, [signal_with_payload], 0) # print("sent %s from master expect ANSWER" % (signal_with_payload)) # time.sleep(3) # send master request, now with another NAD, make sure client doesn't (which is the fist byte below) signal = common_pb2.SignalId( name="MasterReq", namespace=common_pb2.NameSpace(name=namespace_master)) signal_with_payload = network_api_pb2.Signal( id=signal, raw=b"\x82\x02\x03\x04\x05\x06\x07\x08") publish_signals(network_stub, clientId, [signal_with_payload], 0) # send arbitration from master, expect nothing back (nad is not matching)! # signal = common_pb2.SignalId(name="SlaveResp", namespace=common_pb2.NameSpace(name = namespace_master)) # signal_with_payload = network_api_pb2.Signal(id = signal, arbitration = True) # publish_signals(network_stub, clientId, [signal_with_payload], 0) print("sent %s from master NOT expecting ANSWER" % (signal_with_payload)) time.sleep(3) print("still quiet.... done")