(Important and/or major changes/innovations are marked with !!!.) 

Structograms

• !!!
  Structograms for Java:
• Open Java files as structogram
• Create new Java structogram
• Edit Java code in the structogram
• Save structogram as Java file
  
  
• !!!
  Structograms for C#:
• Open C# files as structogram
• Create new C# structogram
• Edit C# code in the structogram
• Save structogram as C# file
  
  
• !!!
  EasyCODE now supports collaboration with the development tool MPLAB® X by Microchip®:
  A plugin for MPLAB® X enables the exchange of debug data between MPLAB® X and EasyCODE and allows debugging in the structogram.
  The plugin is located in the EasyCODE subdirectory “Plugins” and has to be installed in MPLAB® X. Further information in the plugin documentation.
  
  
• Structograms for C/C++:
  Also functions with keyword struct or enum in their return declaration can be read in as structogram elements.
  
  
• Structograms for C/C++:
  In the configuration dialog under menu Options > Language-specific Structogram Settings can be specified that each case element has to contain an empty statement when a switch element is inserted.
  
  
• In the EasyCODE default debug interface, now information on variables is available also on mouse-over in the structure diagram view, similar to the debug interface for Keil uVision (UVSOCK).
  
  
• !!!
  Structograms for C/C++:
  Bug fix in pre-processor elements:
  It was sometimes difficult to insert a pre-processor alternative because there was no room to insert it. There is now a space behind the condition. It’s also possible to click on the + or - button or on the keyword to mark an ifdef-statement.

Statecharts

• !!!
  The command „New Statechart Project” (to be found in menu „Project” and in the start window) lets you create just with a few clicks a project for managing multiple associated statecharts and for generating code from them.
  
  
• !!!
  Optionally it’s now possible to let the member variable „extra“ be generated for a statechart. With this member every instance of a generated Statemachine has its own attached data object. It’s possible to select the type of this member variable below the statechart. (If there is now type given the member variable won’t be generated.)You can use this member variable in all actions and guards of the statemachine with „me.extra“(C++, C), „this->extra“(C++) or „pThis->extra“(C) You can find this type in the exported XML Tree at DOCUMENT/STATEMACHINE/TYPE_OF_EXTRA
  
  
• !!!
  To access the current instance of a statemachine object you can use the following identifiers in the guards and action des statechart:
• me:
  The Statemachine
• base:
  The part of the statemachine inherited from CEcBaseStatemachine
• base_extra:
  The extra-member in the part of the statemachine inherited from CEcBaseStatemachine
• sub: A in a state included sub-statemachine (if existing)
• Examples: 
  me.extra accesses the extra-member variable of the current statemachine
  base_extra accesses the extra-member variable of the base statemachine.
  sub.extra accesses the extra-member variable of a included sub-statemachine.

• !!!
  Statechart-Debugging:
  EasyCODE is now able to read debug data for statecharts also from a UART interface (serial port) or from a file. That’s why most of the available micro controllers are able with the help of the instrumentalized code, generated from an EasyCODE Statechart, to send debug data with over the UART-Port to EasyCODE. EasyCODE uses this Debug Data especially to highlight the current state in the diagram at runtime.  (Animation of the statechart diagram.)
  
  The configuration for the reading-process from the UART PORT or from a file is possible in the EasyCODE menu at “Options”->”Statechart Settings”->”Debugging”.
  
  The function CEcFramework_sendDebugInfoToEasyCODE() in the framework file  EcCustomize.c/cpp has been extended with code for the transfer of debug data from the DebugStatechart.exe via UART and Files.
  
  The sample project “Uart_...” (You can find this directory in the samples sub-directory of your EasyCODE-Installation directory) demonstrates this UART-Implementation.

• !!!
  Statechart Debugging:
  Control of a Target System, Event Injection:
  During a statechart-debug-session over uart it’s possible to control the target:

 

• Start statemachine Debugging (Framework initialisation, start the statemachine)
• Stop statemachine Debugging(Stop the statemachine, clean up the Framework)
• Event-Injection:
  You can select this command from the context menu of a selected event, related transition or transition-caption in the statechart or the statechart-structure-tree.
• ClockTick-Event-Injection
• Trigger a „do“
  
  
• This change is meant for the behaviour of a statemachine generated with an EasyCODE-generation-script: 
  If a target state of a transition is in the initial state then up to this point, while the transition was processed, the exit-action of the initial state was processed, too. UML 2.0 demands that in this case the exit case will not be executed though: 
  
  „A high-level transition with a target upside the composite state will imply the execution of the exit action of the composite state, while a high-level transition with a target inside the composite state will not imply execution of the exit action of the composite state.” (UML Superstructure Specification v2.0, Page 555.)
  
  That’s why we have made to changes to the Framework Files EcBaseStatemachine.c/cpp (marked with 120727-02), to prevent the processing of this exit-actions in the described cases to make the statecharts fully UML 2.0-compliant.
  
  
• During the generation of a switch-case from a statechart a break will be generated in empty default-branches. (Some compiler are expecting this.
  
  
• While moving a state over an out of the state positioned junction-object the junction was “caught” by the state. That means junction object was moved together with the enclosing state. This unwanted side effect has been mostly removed: A junction object will be moved only if the objects connected directly to the junction are inside the state, too. (This makes sense because in most cases of this scenario the junctions are part of a sub statemachine in the enclosing state.
  
  
• When you close the edit-mode in a statechart all whitespaces before and after the edited text will be removed. (Spaces, Tabs, \r, \n) This should remove the necessity to make corrections and search for errors caused text that are not empty by mistake but consist out of whitespaces.
  
  
• When you embed a statemachine as a sub statemachine in a state you will get the directory of the current statechart file as base directory in the appearing file selection dialogue from now on.
  
  
• Bug fix in the EcFramework for the determination process of Entry-Chains.
  
  
• This changes have been applied to the following functions:
  CEcBaseStatemachine_setupEntryChain_() (in C)
  and
  CEcBaseStatemachine::setupEntryChain() (in C++)
  
  
• Changes in EcBaseStatemachine.h/hpp at the definition of the macros EC_DEBUG_REGISTER_SIGNAL and EC_DEBUG_CLEAR.
  
  
• The warning messages that some compilers reported at this positions should be removed with this changes.
  
  
• Bug fix:
  If a DeepHistory Element is included in a state, that includes an external statemachine and this statemachine is activated for the first time over this DeepHistory element (that means the start or initial transition of the Submachine was never reached before this moment) then until now the state that leads to the DeepHistory-transition was not going to be active. Instead the state in whom the initial transition led was active.
  
  
• The most important code snippets, which are necessary to integrate the generated state machines in a project, are now easy to find commented out in the framework EcIncludeInStatemachine.h: this concludes code for the initialisation, start, stop, destruction of the state machines. This also includes examples for the handover of ClockTick and other events to the state machines. This code snippets can be used easily at the fitting position with copy and paste and should make the work with the framework a little bit easier.
  
  
• Multiple memory optimization changes have been made in the EcFramework and the statechart code generation scripts.
  
  
• Some improvements to the behaviour of the selection-box during text-editing in the statechart have been made.
  
  
• In EcDynamic.c/cpp removed and in EcDynamic.h/hpp added: 
  #include "EcFramework.h/hpp“. This is necessary in the case that no statemachine has been included to prevent error messages while compiling the simulation.
  
  
• Bug fix:
  The context menu of the statechart structure tree is no also working when an element is selected.
  
  
• Bug fix:
  There was sometimes a crash when a text was inserted into a text field from the clip board.

Project management

• !!!
  New command „New Statechart Project“.
  See above under „Statecharts“.
  
  
• Some improvements have been brought to the function “Add Files to selected directory”.
  
  

User-defined Build

• A Log file will be written in the output directory during user defined builds if the Registry-Entry “HKCU\Software\EASYCODE Inc.\EasyCODE\9.0.0\Components\Project\BuildManager_UD_strDefaultLogFileName” is not empty. This entry will be also used as log file name. If no log file name is given(this is also the default setting) no log file will be written.
• The place holder %PROJECTDIR% and %PROJECTNAME% which were only available in the SPX Generation but not in user defined builds have been replaced with %PROJECT_DIR% and %PROJECT_NAME%, which are also available in user defined builds.
• If a text should be written to a batch file (*.bat, *.cmd) during a user defined build step this text will be converted to OEM now. This prevents problems with mutated vowels (for example in path names) when the batch file is executed.

General

• You can select to show or hide the start-up windows in the menu at “Options”->”Structure Diagram Settings”->”Open/Save.