Typhoon HIL Forum - Recent questions in Knowledge Base

Why are the currents on my interleaved converter not balanced?

Mon, 25 Aug 2025 07:32:07 +0000

I have an interleaved buck converter with 4 legs. Same duty cycle is provided to all the converter legs and I make sure to have a proper phase shift between carriers. I use one PWM Modulator component to generate all the PWMs and then I use the VHIL digital IO loopback to send the PWMs to the digital inputs. I use switch-level GDS oversampling.

When running a VHIL simulation, I get the expected results.

But when I run the real-time simulation, with physical IO loopback, the currents are very unbalanced. Why does this happen?

Does Typhoon HIL support XCP protocol?

Tue, 05 Aug 2025 13:50:02 +0000

Yes. Typhoon HIL supports XCP over CAN and ETH.

Note: XCP over ETH and CAN is supported from version THCC 2025.4. While on previous THCC versions only XCP over CAN is supported.

XCP in the Typhoon HIL toolchain

XCP master is supported in the Typhoon HIL toolchain in HIL SCADA, via the Python library pyxcp, while the parsing and importing of the a2l file is supported via the Python library pya2l. XCP slave is not supported in the Typhoon HIL toolchain.

Attached below is an example HIL SCADA panel file, where you can open the widget properties and write the Python code you want to execute. For creating properly configurations, you should use xcp-profile utility to convert a legacy .json/.toml file:

xcp-profile convert -c <YOUR_FILE_NAME>.json -o pyxcp_conf.py

Then you can import the libraries and modules for XCP communication and other libraries.

import sys 
from time import sleep 
from pyxcp.cmdline import ArgumentParser 
from pyxcp.daq_stim import DaqToCsv, DaqList, DaqRecorder

To access additional Python scripts in your simulation, you will need to append the path for the script to the system path.

sys.path.append(“d:/path/to/python/file”)
from xcp_script import XCPclass, open_db_session, create_measurement_list, parse_csv

In order to parse the a2l file to retrieve the necessary information, the a2l file must be imported into an opened database. That database need to be open just once and you can do that by calling open_db_session() function before initializing anything:

db, session = open_db_session(a2l_file_path)

The general idea is to acquire data from a device (ECU or simulator), process the data (either online or offline), and then store it or handle it in different formats. A DAQ list is a collection of measurements and data points to be recorded during the DAQ process. The allocation and optimization of ODTs is done automatically by pyXCP. For demonstration, we initialize DAQ list as follows:

daq_list = [DaqList(
    name="test",
    event_num=2,
    stim=False,
    enable_timestamps=False,
    measurements=daq_measurements,
    priority=0,
    prescaler=1
)]

The data acquired can be stored in different formats:

CSV: For simple tabular data XMRAW:
A proprietary format for pyXCP to record raw DAQ data
Parquet, MDF, SQLite: Other formats available for processing and storing data

The measurement parameter should contain a list of the desired measurements for your DAQ process. To construct this list, you can simply create a list of measurement name and then call the create_measurement_list function. This function will automatically generate the compatible list of measurements that can be used in the measurements parameter.

measurement_names = ["channel_d", "TestDWord_501", "TestDWord_502", "TestWord_992", "TestWord_991", "TestWord_989"]
daq_measurements = create_measurement_list(measurement_names, session)

The flexible callback mechanism in pyXCP allows users to interact with the DAQ process in a more modular and customizable way using policies. This flexibility makes it easier for users to integrate DAQ functionality into their workflow according to their specific needs. Before initializing the master, first we need to initialize policy that we will use:

daq_parser = DaqToCsv(daq_list)

Then, we need to make an instance of ArgumentParser class which is used to set up the environment for running the DAQ process. Crete a master as follows:

ap = ArgumentParser()
with ap.run(policy=daq_parser) as xm:
    xcp = XCPclass(master=xm)

After that, you can use the functions defined in the pyxcp library (connect, disconnect, upload, download) to connect and get additional info about the slave device. For unlocking a slave resource, you can implement your own function as it is done in the XCP script attached below if you know the algorithm. Another option is to provide the DLL file for unlocking after calling the get_seed_and_unlock function.

Important note: If you wish to use the DLL method for unlocking the resource, you will need to modify the pyxcp_conf.py file, where you need to uncomment and set the custom_dll_loader parameter.

This part of code is an example of how to use the functions defined in pyxcp and implement the xcp_script. The function get_seed_and_unlock gets the XCP seed key and unlocks the specified resource.

xcp = XCPclass(master=xm)
timestamp_enable = False
conn = xm.connect()
mode_info = xm.getCommModeInfo()
gid = xm.getId(0x1)
status = xm.getStatus()
xm.synch()

xcp.get_seed_and_unlock(xm, 0x04, dll_path)
DAQ_proc_info = xm.getDaqProcessorInfo()
DAQ_res_info = xm.getDaqResolutionInfo()
DAQ_info = xm.getDaqInfo()
for i in range(0, len(DAQ_info["channels"])):
    DAQ_event_info = xm.getDaqEventInfo(i)
    upload_rcv = xm.upload(DAQ_event_info.eventChannelNameLength)

xcp.get_seed_and_unlock(xm, 0x01, dll_path)
scp = xm.setCalPage(0x83, 0, 0)

xcp.build_checksum_for_slave(xm, session)
xcp.set_mta_and_build_checksum(xm, session)
for i in range(0, DAQ_proc_info.maxEventChannel - 1):
    DAQ_event_info = xm.getDaqEventInfo(i)
    upload_rcv = xm.upload(DAQ_event_info.eventChannelNameLength)
pwm = xcp.get_measurement(xm, "PWM", session)
print(pwm)
pwm_filter = xcp.get_measurement(xm, "PWMFiltered", session)
print(pwm_filter)

value = 5
PWM_Level = xcp.get_characteristic_value(xm, "PWM_Level", session)
print(PWM_Level)

xcp.set_characteristic_value(xm, value, "PWM_Level", session)

PWM_Level = xcp.get_characteristic_value(xm, "PWM_Level", session)
print(PWM_Level)

daq_parser.setup()
daq_parser.start()
sleep(1)
daq_parser.stop()
session.close()
xm.disconnect()

get_measurement uploads the specified measurement value from slave to master. set_characteristic_value downloads the specified characteristic value from master to slave. get_characteristic_value uploads the specified characteristic value from slave to master.

Once the DAQ sequence is started, the results are stored in the .csv file in our example. You can parse that file using our custom function as follows:

data_dict = parse_csv("test.csv")
for i in range(len(data_dict)):
    print(data_dict[measurement_names[i]])

Example XCP scripts are attached. Feel free to adapt the scripts provided to your needs.

Example HIL SCADA panel file: SCADA_example

Example of config file: config_file_with_dll

Does Typhoon HIL support UDS on CAN protocol?

Tue, 05 Aug 2025 06:47:52 +0000

Yes, Typhoon HIL supports UDS on CAN protocol.

1. Introduction

The Unified Diagnostic Services (UDS) communication protocol is a standardized diagnostic protocol used in the automotive industry for communicating with and diagnosing electronic control units (ECUs) in vehicles. It can operate over Controller Area Network (CAN) bus, a widely-used communication network in modern vehicles.

Unified Diagnostic Services (UDS) is a client-server protocol commonly used in the automotive industry for diagnostic communication between a client (usually a diagnostic tool or tester) and a server (an electronic control unit or ECU within a vehicle). In this context:

Client: The client, typically a diagnostic tool or software application, initiates communication with the ECU by sending diagnostic requests and commands.
Server: The server, which is the ECU within the vehicle, responds to the client's requests, providing diagnostic information, performing actions requested by the client, and managing the internal functions of the ECU.

2. UDS in Typhoon HIL toolchain

UDS Client is supported in the Typhoon HIL toolchain in HIL SCADA, via the Python library udsoncan. Parsing and importing of CDD files is done with the Python library cantools. UDS Server is not supported in the Typhoon HIL toolchain.

Attached below is an example HIL SCADA panel file, where you can open the widget properties and write the Python code you want to execute.

First, import the libraries and modules for UDS communication and other libraries.

import isotp
import cantools
from udsoncan.connections import *
from udsoncan.client import Client
from udsoncan import DataIdentifier, IOValues
from udsoncan.configs import default_client_config
import os.path, os

To access additional Python scripts in your simulation, you will need to append the path for the script to the system path.

sys.path.append("d:/path/to/python/file")
from uds_script import UDSclass, create_config_dict

The CDD file plays a crucial role in defining the communication parameters and structure for diagnostic communication between a diagnostic tool (such as a scan tool or diagnostic tester) and the electronic control unit (ECU) within a vehicle. To load this file, we use the cantools library and the create_config_dict function:

database_uds_example = cantools.db.load_file(uds_example_path)
config = dict(default_client_config)
config = create_config_dict(database=database_uds_example, config=config)

To initialize the UDS Client we need to define the link layer, network layer, transport layer, and the interface between the application and transport layer:

bus = VectorBus(channel=0, bitrate=500000, app_name="UDSsim") - Link Layer (CAN protocol)
tp_addr = isotp.Address(isotp.AddressingMode.Normal_11bits, txid=0x700, rxid=0x600)- Network layer
stack = isotp.CanStack(bus=bus, address=tp_addr, params=isotp_params) - Network/Transport layer (IsoTP protocol)
conn = PythonIsoTpConnection(stack) - interface between Application and Transport layer

After we have created the connection layers and config parameters, we can create the UDS Client:

with Client(conn=conn, request_timeout=3, config=config) as client:

After that, we can use the functions defined in the udsoncan library (open, close, tester_present) to communicate with the server and get additional information.

Here is an example how to communcate with the server:

# Read and write data example for did = "Windows"
 uds.read_data(client=client, database=database_uds_example, did_ident=0x81)

 uds.write_data(client, database_uds_example, name="Windows", value=(0x04, 0x03, 0x02, 0x01))

 uds.read_data(client, database_uds_example, did_ident=0x81)

 uds.io_control_write(client, database_uds_example, name="Windows", values=(0x08, 0x07, 0x06, 0x05))

The read_data function reads the data from a specific ECU data identifier, while the write_data function writes data to a specific ECU data identifier.

An example UDS script is attached. Feel free to adapt the scripts provided to your needs.uds_script

uds_example

Merging of "Advanced C function" with "C function"

Wed, 21 May 2025 15:19:07 +0000

When the Advanced C function component was merged with the C function component in THCC, did it inherit all of the functionalities that made it distinct from the C function component in previous software versions?

Also, in which release version did this change happen?

Importing Functional Mock-up Interface (FMU) in Typhoon that doesn't contain source code?

Fri, 10 Jan 2025 13:22:42 +0000

Hi!

Can I import an FMU file that doesn't contain the source code and run it on Typhoon HIL?

If I want to share an FMU with another organization, I would like for a code inside of it to be protected.

Thanks,

How to quickly check if my license includes technical support?

Wed, 06 Nov 2024 10:10:31 +0000

Can I simulate the parasitic properties of my MOSFETs?

Wed, 23 Oct 2024 07:42:18 +0000

When simulating my power electronics converter, I would like to have a more detailed MOSFET model, so I can observe the effects such as zero-voltage switching (ZVS) and switch-node ringing. Can I do this in Typhoon?

Error message "Serial link is down"

Tue, 22 Oct 2024 14:54:42 +0000

Hi, we have a model that should run on 2x HIL 404 devices. The compilation successfully completes, but after starting the simulation, I obtain an error message: 'Serial link is down'. Can you help me?

I need to measure Short/Long-Term Flicker Severity for the 50 Hz grid, how can I do it?

Tue, 22 Oct 2024 13:06:49 +0000

How can I import C code that I previously exported from Typhoon HIL Schematic Editor?

Wed, 16 Oct 2024 13:45:33 +0000

Hi!

I want to import C code in Typhoon HIL Schematic Editor C function code block, that I previously exported from Typhoon HIL. However, I am not sure how to properly call the functions from the C code I imported in the C function block, can you help me?

Can I simulate Three Phase A-NPC RB-IGBT in Typhoon HIL?

Tue, 24 Sep 2024 11:28:28 +0000

Is it possible to simulate a Three Phase A-NPC (Active - Neutral Point Clamped) RB-IGBT (Reverse Blocking) converter in Typhoon HIL? Converter topology is presented below:

I get the following error: Core Coupling 1.cpl1 sides are connected. Compilation process interrupted. What should I do?

Mon, 09 Sep 2024 13:13:58 +0000

When I compile the model presented below, I get the following error:

Core coupling: Core Coupling 1.cpl1 sides are connected.

Please, make the needed corrections and restart the compilation.
Compilation process interrupted.