Typhoon HIL Forum - Recent questions and answers in Knowledge Base

Answered: Why are the currents on my interleaved converter not balanced?

Mon, 25 Aug 2025 07:50:06 +0000

Let's consider an interleaved buck converter, consisting of two legs A and B. We want to understand the origin and estimate the value of a current imbalance that can occur.

In order to analyze the circuit, we can assume a continuous conduction mode. In such operation, the average output voltages at the switch node are given with va = Da*Vin, vb = Db*Vin. Current unbalance will occur if there is some difference in duty cycles. If we express this difference in terms of duration, we can derive a generalized equation to calculate the current, as shown in the image.

In a real-world system, even if PWM modulator is programmed perfectly, the uncertainty will always exist with regards to signal propagation in the system due to the multiple reasons. Imperfection of passive components that are incorporated into the digital output/digital input circuit design will inevitably change the time constants of input/output impedances. There is also always uncertainty with regards to IO voltage levels - We specify that the minimum voltage value at which logic-high is detected is 2V, while maximum logic-low level is 0.8V, but we cannot be certain when exactly will the logic level change be detected. This will reflect into uncertainty of pulse duration as well.

In order to estimate the impact of the pulse length difference, let's assume that all the uncertainties add up to a single sample of a difference in pulse lengths of two legs - 3.5ns. If input voltage is 650V, fsw is 200kHz and RL is 10mOhm, the formula yields 45.5A of current unbalance between two legs! This means that even a very small difference in pulse length will cause a significant current unbalance. Therefore, we shall not expect the current to be perfectly balanced when using HIL IO loopback, or the external controller in open-loop.

Interestingly, HIL will be able to capture even 1ns of pulse length difference if the external controller is used, even though the DI sampling rate is 3.5ns. Since the controller isn't synchronized with HIL in any way, duty cycle that's measured will not be constant between multiple switching periods. The average value of detected duty cycle will reflect the 1ns difference, which will be reflected in the simulation results, yielding 13A of current unbalance. This can be confirmed by using PWM Analyzer to measure the average duty cycle over long time span.

Finally, when running on the actual power hardware, uncertainties will be increased due to the fact that turn on/turn off delays on real power MOSFETs have ranges that are often 10s of nanoseconds. For this reason, one should always make sure to actively balance the currents.

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

Answered: Merging of "Advanced C function" with "C function"

Thu, 22 May 2025 08:08:55 +0000

Hi Ognjen,

Yes, the Advanced C Function has been merged into the C Function component. This means that all functionalities previously available in the Advanced C Function are now available in the C Function.

For information about the exact software version in which this (and other) change was introduced, I suggest checking the Typhoon HIL Control Center release notes. You’ll see that this merge was introduced in the 2023.4 software version.

Best regards,
Dusan

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

Fri, 10 Jan 2025 13:39:58 +0000

Greetings,

There is an option to precompile the FMU, which would make a new precompiled FMU zip file. Source files are compiled and linked into a static library while all source and header files from the original FMU zip are deleted.

You can do this by using our Schematic API function:

precompile_fmu() - link

Example of usage of this function is in the attachment. Make sure to put the FMU and script in the same folder, and to adjust the path variable in the script (link to download the script).

When running the script, use the command:

typhoon-python script.py

When you execute it, another FMU should appear with _precompiled appended. This FMU won't contain source code.

When you import it into the Typhoon FMU component, the Platforms parameter should list "typhoon", as it is presented in the figure below:

Hope this helps!

Best regards,

Answered: How to quickly check if my license includes technical support?

Wed, 06 Nov 2024 10:20:04 +0000

1. Log into MyTyphoon subscription portal.

2. Check if your company/university name is listed under "Customer Site".

If the customer site field states any of the following: Virtual HIL demo, Virtual Microgrid Testbed, TyphoonSim Beta then you are not entitled to subscription-based technical support and should seek community help here on the forum.

You can gain access to support service by obtaining the proper activation key supplied with the purchase of your HIL testbed.

Answered: Can I simulate the parasitic properties of my MOSFETs?

Wed, 23 Oct 2024 12:11:10 +0000

Unfortunately, simulating parasitics is not practically feasible to be determined on real-time simulation platforms simply because the simulation needs to be very fast to simulate such dynamics, which will not be currently possible with existing FPGA's. However, simulating losses can be efficiently done in Typhoon HIL.

Answered: Error message "Serial link is down"

Tue, 22 Oct 2024 14:56:20 +0000

This error message indicates that HIL devices parallelization is not established in a proper way.

To fix this issue, you should check documentation about HIL device paralleling process here, while this video presents the process itself.

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

Tue, 22 Oct 2024 13:08:39 +0000

Measuring flicker severity and other related parameters is possible using typhoon.test.IEC61000.flickermeter API function from the TyphoonTest Library. This function should be implemented on the provided(captured) voltage samples from the simulation.

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

Wed, 16 Oct 2024 14:21:32 +0000

Greetings,

Importing C function code, which was previously exported from Typhoon HIL Schematic editor, requires calling functions defined in the header file exported from Typhoon. Functions for initialization and execution of the code take structures as arguments, therefore it is also necessary to prepare these structures and initialize the structure members.

First, let’s look at the practical example, by exporting the code from the Typhoon HIL Boost converter example model, where the control part consists of the PID regulator, logical and mathematical blocks.

The part of the model we want to export, we will put inside a subsystem and rename all input and output ports. Afterward, C code export will be executed. If you want to learn more about C code export from Typhoon, please take a look at this link.

Now, when the C code is exported, let’s replace this subsystem with a new C code function block. In the General tab, all inputs and outputs should be defined.

In the additional sources tab, all exported files should be included (except backup files).

Now, let’s open the header file (boostcontrol.h) that we exported. There you can find declarations of model data structure that consist of inputs, outputs, sinks, and states. It is necessary to define these structures in the Typhoon Arbitrary variables section, so that Typhoon can access the ones provided in additional sources. Below you can see the structure declaration that we need to copy in the Arbitrary variable section:

When we are copying these declarations to the Arbitrary variable, it is necessary to delete the “extern” keyword.

Now, let’s focus on the init_fnc section. Back in the header file (boostcontrol.h), there is also an initialization function that needs to be run in the init_func of Functions tab:

However, before we call the init function, we have to assign the addresses of variables we defined in Variables arbitrary definitions to ModelData structure member pointers. When we finish, our init_fnc tab should look like this:

Lastly, we can focus on the output_fnc tab. At the beginning of each execution rate, we first have to assign inputs of the C function block to Model Data input structure members (boostcontrol_ExtIn). Afterward, we call the step function while passing the address of the Model Data structure, and in the end we feed our output variables from Model Data output structure members (boostcontrol_ExtOut).

After this step, you can finally compile the model and load the model to HIL device or run it in TyphoonSim.

Additionally, if you want to import dll file instead of a C code, please take a look at this Application note – How to import DLL file for C function, or this section of a C function block documentation – Library import tab.

If you have any additional questions, feel free to post them here.

Hope this helps!

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

Tue, 24 Sep 2024 11:57:49 +0000

Greetings,

Although there is no corresponding converter with exact topology as in the figure you attached available in Typhoon HIL, you can use a Three Phase T-Type converter instead. If controlled in the proposed manner, this converter should operate in the same way.

To operate the Three Phase T-Type converter in the same manner as NPC with RB-IGBT, gate drive signals would have to be assigned to the following switches:

NPC T-Type converter	NPC with RB-IGBT

GDS for NPC RB-IGBT T1 should be assigned to NPC T-Type S_1
GDS for NPC RB-IGBT T2 should be assigned to NPC T-Type S_4
GDS for NPC RB-IGBT T3 should be assigned to NPC T-Type S_3
GDS for NPC RB-IGBT T4 should be assigned to NPC T-Type S_2

Hope this helps!

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

Mon, 09 Sep 2024 13:43:08 +0000

Hello!

When core couplings divide the circuit, there should be no nodes in separate electrical circuits that are connected directly. Even though it seems that there are no nodes connected directly in your circuit, ground components are connected to the same node.

There are two ways to fix this issue, which are thoroughly explained in this FAQ: How to connect grounds in multi-core models?

For your particular case, you can either select the checkbox Set Ground component scope to core, in Circuit Solver settings of Model settings, or you can increase the number of phases in core coupling and then connect the ground nodes to an additional port of the core coupling.