winIDEA IDE

A reli­able Inte­grat­ed Develop­ment Envi­ron­ment (IDE) for debug­ging, ana­lyz­ing and test­ing embed­ded soft­ware.

When used in con­junc­tion with a TASKING Blue­Box debug­ger or vir­tu­al ECU sim­u­la­tor, winIDEA is a ver­sa­tile and inno­v­a­tive IDE for debug­ging, ana­lyz­ing, and test­ing embed­ded soft­ware. The winIDEA IDE includes a num­ber of inte­grat­ed tools like testIDEA, daqIDEA and winIDEA SDK. The com­bi­na­tion of these tools with winIDEA’s advanced debug­ging fea­tures, tim­ing analy­sis tools and wide range of micro­con­troller archi­tec­ture sup­port make it a must-have for embed­ded soft­ware engi­neers.

The user friend­ly inter­face with com­pre­hen­sive remote and auto­mat­ed APIs sup­ports a diverse range of develop­ment use-cas­es.

Prod­uct Brief
Down­load
Request Quote

Comprehensive
Debug Solution

Com­plete Flash pro­gram­ming, advanced debug and mul­ti­core debug sup­port.
Pro­vides Real time analy­sis, RTOS Aware debug­ging and data acqui­si­tion.
Mul­ti-SoC syn­chro­nous debug­ging and trac­ing.
Sup­port­ing Eclipse, CLion, Visu­al Stu­dio Code and oth­er third-par­ty IDEs.

Wide Range of MCU Support

Sup­ports a broad spec­trum of Micro­con­trollers.
Sup­port for RTOS, AUTOSAR, embed­ded Lin­ux and hyper­vi­sors.
Reg­u­lar updates to sup­port new devices and archi­tec­tures.
Sup­ports all major archi­tec­tures such as Arm, Tri­Core, RH850, RISC‑V and oth­ers with a sin­gle license.

Seamless
Integration

Get a head start on sys­tem develop­ment using vir­tu­al hard­ware.
Smooth tran­si­tion to real hard­ware from vir­tu­al per­spec­tive.
CI scripts can be used on both vir­tu­al and real hard­ware.

Debug IDE

Auto­mat­ed unit, inte­gra­tion and sys­tem test­ing with­out code instru­men­ta­tion with testIDEA.
Data acqui­si­tion and 2D graph­i­cal visu­al­iza­tion with daqIDEA.
Sup­port for Tim­ing, cov­er­age and net­work analy­sis with ‘MCU to Net­work’ event cor­re­la­tion.
Sup­ports SDK for automa­tion with indus­try lead­ing pro­gram­ming lan­guages.
vECU sup­ports ear­ly develop­ment and inte­gra­tion work with vir­tu­al hard­ware before real tar­get hard­ware is avail­able.

Third-Party IDEs

winIDEA sup­ports inte­gra­tion with var­i­ous third-par­ty IDEs, allow­ing devel­op­ers to lever­age their pow­er­ful debug­ging and test­ing capa­bil­i­ties.
winIDEA plug-ins bring advanced debug­ging capa­bil­i­ties to pop­u­lar IDEs like Visu­al Stu­dio Code, Eclipse, and CLion, improv­ing develop­ment effi­cien­cy.
Devel­op­ers can man­age code repos­i­to­ries, work across dif­fer­ent oper­at­ing sys­tems, and devel­op in C++ with­in their pre­ferred envi­ron­ments.

Virtual ECU’s (vECU)

winIDEA enables Vir­tu­al ECU sup­port pro­vid­ing the same fea­tures as tra­di­tion­al hard­ware debug­ging. 
These advanced sim­u­la­tors allow you to start prod­uct develop­ment before real hard­ware (SoCs) is avail­able.
winIDEA allows seam­less switch­ing between Vir­tu­al ECUs and real hard­ware, enabling flex­i­ble and effi­cient develop­ment work­flows.
Find out more about Vir­tu­al ECU sup­port.

Third Party Support Tools

winIDEA sup­ports third-par­ty debug probes like Infineon’s mini­Wig­gler, ST Micro’s ST-Link, Rene­sas E1/E2, PE-Micro, and XCP pro­to­col for extend­ed func­tion­al­i­ty.
winIDEA sup­ports third-par­ty Mea­sure­ment and Cal­i­bra­tion Hard­ware and Soft­ware from Vec­tor, ETAS, dSPACE and oth­ers.

winIDEA Console

The new winIDEA Con­sole can exe­cute winIDEA com­mands through an inter­ac­tive con­sole inter­face.
Avail­able in both winIDEA IDE and the VSCode winIDEA exten­sion.
Exten­sive user acces­si­bil­i­ty with inte­grat­ed help, command/argument auto­com­ple­tion and sup­port for abbre­vi­a­tions.

Complete Solution

winIDEA down­load includes five soft­ware prod­ucts: winIDEA, testIDEA, Ana­lyz­er, daqIDEA, winIDEA SDK for Python, and 100+ Exam­ple Work­spaces for a wide vari­ety of micro­con­troller archi­tec­tures. (All-in-One down­load)
winIDEA TQSP stream­lines qual­i­fi­ca­tion efforts in the cus­tomers envi­ron­ment, facil­i­tat­ing qual­i­fi­ca­tion up to ASIL D.  Please vis­it the prod­uct page for more infor­ma­tion.

winIDEA Analyzer — Profiling and Coverage Tool

winIDEA Ana­lyz­er is a com­pre­hen­sive tool for trac­ing, pro­fil­ing, and cov­er­age analy­sis in embed­ded sys­tems. It enables devel­op­ers to ana­lyze micro­con­troller activ­i­ty, mea­sure exe­cu­tion per­for­mance, and val­i­date com­pli­ance with safe­ty stan­dards.

winIDEA Ana­lyz­er records and out­puts sys­tem per­for­mance results on pro­gram exe­cu­tion, data traces, and tim­ing mea­sure­ments.
Improve debug­ging effi­cien­cy with real-time pro­gram flow trac­ing.
Iden­ti­fy unex­e­cut­ed code sec­tions and remove unnec­es­sary mem­o­ry over­head.
RTOS pro­fil­ing mea­sures exe­cu­tion time for tasks, ISRs, and func­tions to ensure tim­ing accu­ra­cy.
Event Chain and AUTOSAR Exe­cu­tion Order val­i­da­tion.
Inte­grat­ed with Blue­Box On-chip Ana­lyz­er and add-on mod­ules.
Mon­i­tor CPU uti­liza­tion over time to eval­u­ate real-time appli­ca­tion per­for­mance.
Code cov­er­age analy­sis for safe­ty com­pli­ance ver­i­fi­ca­tion.
Pro­file Run-Time Envi­ron­ment (RTE) inter­ac­tions for com­pre­hen­sive debug­ging.
Sup­port for ARTI-based AUTOSAR Trace/Profiling.

winIDEA SDK — Automation API

winIDEA SDK enables devel­op­ers to auto­mate test­ing pro­ce­dures with winIDEA func­tions using pro­gram­ming lan­guages such as Python, Java, C#, C++, MATLAB, and Lab­VIEW. It enables effi­cient inte­gra­tion with Con­tin­u­ous Inte­gra­tion (CI) sys­tems and enhances debug­ging automa­tion.

Cre­ate, load and mod­i­fy winIDEA work­spaces.
Pro­gram and ver­i­fy.
Set break­points, typ­i­cal­ly on error con­di­tions.
Con­fig­ure appli­ca­tion para­me­ters by writ­ing to appli­ca­tion mem­o­ry.
Run and mon­i­tor exe­cu­tion.
Observe appli­ca­tion states by read­ing their mem­o­ry.
Inject errors via write oper­a­tions.
Exe­cute indi­vid­ual func­tions in unit test sce­nar­ios.
Mea­sure appli­ca­tion per­for­mance with the Pro­fil­er
Mea­sure appli­ca­tion test cov­er­age with the Cov­er­age tool

testIDEA — Software Test Tool

testIDEA enables auto­mat­ed test­ing dur­ing dif­fer­ent phas­es of develop­ment, offer­ing real-time exe­cu­tion on hard­ware and inte­grates seam­less­ly into your develop­ment work­flow.

Exe­cute unit, inte­gra­tion and sys­tem tests on real hard­ware with­out code instru­men­ta­tion.
Sim­pli­fies the develop­ment of unit tests for embed­ded appli­ca­tions (C func­tions, C++ class­es).
Start test­ing quick­ly with a GUI that sim­pli­fies test case cre­ation and exe­cu­tion.
Save test cas­es in YAML for­mat for easy repos­i­to­ry inte­gra­tion and ver­sion con­trol.
Python script inte­gra­tion for Con­tin­u­ous Inte­gra­tion (CI) work­flows.

daqIDEA — Visualization Tool

daqIDEA is a reli­able graph­i­cal tool for pre­sent­ing and ana­lyz­ing large data sets acquired by winIDEA.

Visu­al­ize data val­ues in 2‑dimensional charts and tables.
Allows the user to con­fig­ure the sam­pling peri­od and export acquired data for third-par­ty tool analy­sis.
Zoom and stretch charts for detailed analy­sis.
Mon­i­tor vari­ables dynam­i­cal­ly with con­tin­u­ous data updates.
Acces­si­ble via winIDEA automa­tion API.

Support Microcontroller Architectures

Infi­neon AURIXTM
Arm Cor­tex
RH850 Rene­sas
NXP/ST Pow­er Archi­tec­ture
RISC‑V
and oth­ers..

For your develop­ment project, you can use the winIDEA IDE, but you also have the flex­i­bil­i­ty to take advan­tage of its pow­er­ful debug­ging capa­bil­i­ties into var­i­ous oth­er IDEs through sup­port­ed exten­sions or plu­g­ins. This allows you to work with­in your pre­ferred develop­ment envi­ron­ment while tak­ing advan­tage of winIDEA’s advanced fea­tures. The fol­low­ing IDEs are sup­port­ed:

https://www.tasking.com/content/finally-a-winidea-console-window/

TASKING Prod­uct Doc­u­men­ta­tion con­sists of prod­uct release notes, user doc­u­men­ta­tion, prod­uct patch­es (where avail­able), webi­na­rs and prod­uct relat­ed infor­ma­tion.

https://www.tasking.com/documentation/debug-trace-test-tools/

Scroll to Top