FreeMASTER Knowledge Base

cancel
Showing results for 
Search instead for 
Did you mean: 

FreeMASTER Knowledge Base

Discussions

Version 3.1 of the NXP FreeMASTER tool has just been published online.  The installer is available along with documentation and other resources at http://www.nxp.com/freemaster. There is also a video presentation of new features available in the desktop version. Another video shows the new FreeMASTER Lite and Node-RED integration. Release description FreeMASTER  is a powerful data visualization tool developed and provided by NXP to help users monitor and control embedded applications running on NXP’s targets. It works with almost all NXP Arm ® Cortex®-M microcontrollers from both Edge Processing and Automotive BLs as well as with DSC and legacy Power Architecture, ColdFire and HCS12/Z platforms. FreeMASTER 3.1 release extends the version 3.0 by adding the new features. Older 2.x and 3.0 installations may co-exist on the host system with the 3.1 version which should enable smooth transition of projects, dashboards and other work items from the older versions to the new one.  Version 3.1 is backward compatible. It supports  variable monitoring, oscilloscope real time graphs, fast transient recorder graphs and connectivity to 3rd party applications. An HTML rendering engine based on Chromium with full support of JSON-RPC, HTML5 and JavaScript is available to create custom dashboards and other user interfaces that can run inside FreeMASTER or standalone in local or remote web browser. Older Internet Explorer rendering, ActiveX interface and protocols defined for versions 2.x are also still supported. Block diagrams The following pictures shows high-level view of the FreeMASTER desktop application and FreeMASTER Lite interfaces, their connections to the target microcontroller applications as well as to 3rd party applications.     What's new in version 3.1 Version 3.1 extends the last update of version 3.0 with all its minor updates and bug fixes. Refer to earlier announcements for versions 3.0.3, 3.0.1 and the 3.0.0.  Features introduced in version 3.1: Node-RED framework support Node-RED is a popular framework that enables visual programming of event driven applications. FreeMASTER 3.1 brings a palette of Node-RED "nodes" that act as a visual wrappers around JSON-RPC calls. Now you can leverage the full potential of both FreeMASTER & Node-RED to design your application or even visual dashboards with minimal or no coding at all. The FreeMASTER Lite server now embeds the full Node-RED runtime, so no other installation is required. At the same time, the installer comes with stand-alone packages that can be added and used with a  local Node-RED instance. This video training provides more details on FreeMASTER and Node-RED integration  FreeMASTER NodeJS modules The installation now contains two new NodeJS "npm" installable modules. FreeMASTER JSON-RPC Client as a general package for JSON-RPC interfacing which works both on the backend (NodeJS) and frontend (web browser). FreeMASTER Node-RED module as set of installable Node-RED nodes and example flows. Keep both packages together in the same folder when installing it for dependency resolving. Updated communication plug-ins to support protocol V4 The communication protocol version 4 has been first introduced in 2019 with FreeMASTER 2.5. Today, it is the primary protocol used by microcontroller applications based on NXP MCUXpresso SDK, automotive SDKs and other general applications targeting NXP i.MX-RT, LPC, Kinetis, S32K, S12Z and Power Architecture platforms. FreeMASTER 3.1 adds support of this protocol to the FreeMASTER Remote Communication Server, so it is again possible to access your microcontroller applications remotely over a network and even to share the same board connection with more FreeMASTER desktop applications. Protocol V4 is also now supported by the JTAG/EOnCE Real Time Data transmission interface available on DSC 56F800E/EX platforms. Virtual Variables New support of "Virtual" variables, which do not have an address assigned and can be created without any real counterpart in the MCU application. Virtual variables may still be accessed by scripts and may be added to Variable Watch and Oscilloscope views. This may be useful for script-defined global parameters and other purposes. Global Enumeration types Enumeration types are now managed globally. Multiple variables now share the string enumerations defined in a global repository (see menu Project/Enumerations...). The enumerations are loaded automatically from the MCU application's TSA tables. The 'enum' type parsing from ELF file to be supported in future. Recorder and Oscilloscope Properties dialogs extended New icons indicating variables' "trigger mode" displayed in Recorder variable list. Fixed drag&drop behavior in the variable list. Possibility to add multiple variables at once by pressing the "..." button. The Drop-down list with variable selection is now able to filter the content by a typed text. Working with context menu Project tree context menu has been extended by options to expand or collapse child nodes. Tree state is serialized to project (PMPX format only). Context menu commands were also added to easily duplicate existing Recorder and Oscilloscope items or to clone them from Oscilloscope to Recorder type and vice versa. New CAN interfaces supported The wide family of supported USB-to-CAN and other CAN interfaces (IXXAT, Vector, Kvaser, National Instruments, Peak Systems, Intrepid, ZLG, Glinker) has been extended by Viewtool Ginkgo devices.    Release target audience Both FreeMASTER and FreeMASTER Lite are primarily targeted to our customers, engineers and developers of NXP embedded applications from Industrial, IoT and Automotive areas who want to monitor and control their applications at runtime. FreeMASTER is also a strong framework which can be used to create interactive demos and user interfaces helping to use the embedded applications by yet wider target audience. Prerequisites FreeMASTER tools run on the host computer and communicate with the target microcontroller application using Serial, CAN, JTAG, BDM or other physical interface. The microcontroller communication drivers are available as part of MCUXpresso SDK, S32 Design Studio or as a standalone installation package. Get familiar with the communication protocol and the microcontroller driver API before using the FreeMASTER tool. Packages A single self-extracting installation package which contains both FreeMASTER desktop application and the new FreeMASTER Lite service is available for Windows platforms. A package with the FreeMASTER Lite service is also available for Linux. Access the installation and documentation at the FreeMASTER home page at   https://www.nxp.com/freemaster.
View full article
This article will focus on the embedded side of the FreeMASTER tool - the communication driver. Currently there are three sources you can get the embedded library from: Driver Package MCUXpresso SDK S32 Design Studio SDK The following two sections will guide you through each separate approach. Driver Package Driver package is independent of any SDK but implements outdated communication protocol versions 2 and 3. Refer to MCUXpresso SDK section for a driver which implements the latest protocol version 4. FreeMASTER 3.0 and FreeMASTER Lite are backward compatible and work with both protocol versions. Self-extracting installation package is available on FreeMASTER download page under  BSP, Drivers and Middleware section. After installation it will create a folder (default path - C:\NXP\FreeMASTER_Serial_Communication_Driver_V2.0) on your system with the following content:   You can start with ready to use projects from examples\SCI_driver_examples folder:   Each example contains a readme file specifying environment requirements (target board and and used IDE). To start a new project you would require to add just two folders to your project src_common containing generic protocol implementation and platform specific sources from src_platform. The latter has a similar layout to the examples (with a per platform sub-folder). Refer to documentation (doc folder) for further library configuration.   MCUXpresso SDK Currently, only MCUXpresso SDK includes latest version of FreeMASTER Communication Driver which implements the communication protocol v4. Latest implementation of the FreeMASTER Communication Protocol (v4.0) was integrated into MCUXpresso SDK. In case you don't have the IDE you can get it from MCUXpresso IDE download page . Next proceed to SDK builder.     Navigate to Development Board Selection, choose a Board/Kit/Processor and build the SDK.     Once the build is ready make sure that FreeMASTER Component is included.     Save your changes and download the SDK. You can import the it from MCUXpresso IDE QuickStart Panel :     In case it is not visible you can add it to your view from: Window → Show View  → Quickstart Panel. Check this video on how you can import SDK into MCUXpresso IDE: Now you can start a new project and add FreeMASTER middle-ware component or import FreeMASTER example from SDK   S32 Design Studio SDK S32 Design Studio SDKs include FreeMASTER Communication Driver v2.0. Refer to this article for FreeMASTER Driver usage with S32 Design Studio.
View full article
This article is meant to show you the minimal setup required to allow your embedded application to start talking to FreeMASTER host application. It is part of the FreeMASTER Tutorial series: Communication Driver (current article) Connecting to the Board Target Side Address Translation Communication Driver & S32 Design Studio Prerequisites: FreeMASTER Communication Driver S32 Design Studio for ARM 2018.R1 with S32 SDK S32K1xx RTM 3.0.0 See example application source code in attachments. If you read Communication Driver article you may have noticed that the the stand-alone package available on the FreeMASTER download page implements version 2.0 of the communication protocol. Why this video still uses an older version ?  The latest version is relatively new, and not all platform have updated support. S32 Design Studio and Model-Based Design Toolbox still use previous version of the driver. The host application is fully backward compatible and supports both versions of the communication protocol.
View full article
Introduction FreeMaster allows us to create HTML pages with Javascript to interact with our embedded application, and access the FreeMaster features, allowing us to create complex and personalized user interfaces. FreeMaster gives us two options for rendering and communicating our HTML page: Internet Explorer or a Chromium rendering engine. The Chromium rendering engine (which is the base for modern browsers like Google Chrome, Microsoft Edge, and Opera)  is the more modern option, supporting asynchronous JavaScript programming and other modern scripting technologies. The Chromium rendering uses the JSON-RPC protocol to call the procedures on FreeMaster. JSON-RPC is a remote procedure call protocol that use JSON to encode its data, in this case, is used to call procedures from the FreeMaster application,  FreeMaster gives us a JSON-RPC API for Javascript that facilitates the communication between the HTML page and FreeMaster. Browser (Chromium engine)  Example Description In this example, we are going to use the JSON-RPC API to connect an HTML page to FreeMaster. The HTML page will be capable of reading a variable and modifying a variable, the HTML page will also plot the read variable. This example is based on a FreeMaster project that calculates the value of a sine line based on an angle that is constantly incrementing, you can find the description of the project in How To implement an interface using FreeMaster. Hardware / Software used Hardware setup: Board Used: FRDM-K64F SDK: SDK_2.x_FRDM-K64F  Version 2.8.0 or later   Software setup: Board Application developed in: MCUXpresso IDE v11.2.0 FreeMaster Version: FreeMaster  3.0.2.6 Control Page (HTML, CSS, Javascript) developed with: Visual Studio Code 1.48.0 (this was the IDE used for developing the control page but you can use any IDE of your preference) Graphs library: Chartist.js Official page: https://gionkunz.github.io/chartist-js/   HTML page Example (without FreeMaster) For this example, the HTML page we want to connect with FreeMaster looks like this: This document is not meant to teach you how to design or create an HTML page, but to connect the HTML page with our FreeMaster project. The elements of our HTML page that will communicate with the FreeMaster Project through the JSON-RPC API are the next: Connect Button: The connect button will star communication with the board and the FreeMaster project. Start Measure Button: The measure button will start the reading operation for the sin_value variable. Angle Step Modifier: This input will write the angle_step variable in our project. Graph: The graph will plot the sin_value that has been read.   General Structure of the Project The two files that we are going to be working with will be our HTML file and our Javascript file, in this example we are going to name them index.html and index.js, we will add more required files as we keep going through the document. If you are using Visual Studio open the folder that will contain the files, you can add or create files in the Explorer tab:      In index.html, make sure that index.js is being imported (you can check at the end of the body element): <script type="text/javascript" src="./index.js"></script> Connect our HTML page with FreeMaster (Use of freemaster-client.js) FreeMaster provides us with a “freemaster-client.js”  file available in the FreeMaster installation folder. This file is based in a popular JSON-RPC javascript library for generating and parsing messages called “simple-jsonrpc-js”, this implementation is also found in the installation folder and you can find the full documentation here: https://github.com/jershell/simple-jsonrpc-js. To connect our HTML page with the FreeMaster application using the JSON-RPC interface we need to use a Javascript wrapper object that contains all the methods of the JSON-RPC API. The object is named as PCM and it is declared in the “freemaster-client.js” file, we access the API methods through the PCM object. In resume:      The complete address of the “freemaster-client.js” and the “simple-jsonrpc-js” in the installation folder is: C:\nxp\FreeMASTER 3.0\FreeMASTER\examples\scripting\JavaScript-JSON-RPC   We will need these files to connect to our HTML page with FreeMaster, copy the files to your HTML page project:     Now we need to import the files “freemaster-client.js” and “simple-jsonrpc-js.js” in index.html,  on the header of the document we write: <script type="text/javascript" src="/js/simple-jsonrpc-js.js"></script> <script type="text/javascript" src="/js/freemaster-client.js"></script>   Next, we need to instantiate the Javascript wrapper object that we import in the “freemaster-client.js”. To do that, you need to create an external Javascript file and import it in our HTML document or implement it inside a script element in the HTML document. The wrapper object is named PCM, the implementation of the PCM object in the freemaster-client.js file looks requires the following arguments: var PCM = function(url, onSocketOpen, onSocketClose, onSocketError)   The url refers to the direction of the web server we are going to connect, when we open the FreeMaster application it initializes the JSON-RPC server listening on port number 41000. So our url should be “localhost:41000”.  The next three arguments ask for handlers to execute when connecting to the server when the server is close and a handler in case an error occurs during communication. To use these handlers we first need to create them, in the form of Javascript functions and then we can pass them like callbacks (a function pass it as an argument to another function). So our instantiation should look something like this (in index.js 😞 let pcm = new PCM("localhost:41000", on_connected, on_close, on_error); function on_connected() { console.log("Connected to WebSocket"); }; function on_error() { console.log("Error with the WebSocket"); }; function on_close() { console.log("WebSocket Close"); } Here we use our on_connected, on_close, and on_error functions as handlers. The on_close and on_error functions only print a message on the console when they are executed. The on_connected method is also printing a message indicating that the connection to the JSON-RPC server was successful. The next thing we have to do is use some of the JSON-RPC methods to give functionality to the HTML page, showing and modifying the variables from our embedded application. In the next section, we are going to explain how the JSON-RPC API methods are used. Useful JSON-RPC API methods The full list of JSON-RPC API methods (as well as the ActiveX methods) can be found in the FreeMaster User Guide:FreeMaster User Guide.  We access to the JSON-RPC API methods through the PCM wrapper object. The API methods return a javascript Promise object, a Promise object represents an asynchronous operation, (like remote calls to FreeMaster) and we can indicate what to do in case of success or failure of the operation. The resolution of our asynchronous operation will be contained in a response object, and in the case of the JSON-RPC API, the output values of our operation will be in the data member of the response object, there is also another member named xtra that contains different values (like confirmation values) or alternative formatting to the response, check the user guide for more information of the returned value of xtra, but mostly we are going to use the data member. An example of the use of Promise with the JSON-RPC methods can be seen here: pcm.GetAppVersion() //In case of success we print the output value (data member of response object) .then((response) => console.log("App version: " + response.data)) //In case of failure we print the response object .catch((err) => console.log(err))   The then method is used in case of success and the catch method in case of failure. Both methods receive a callback function that receives the response object to indicate what to do with the response in each case. Some useful methods of the JSON-RPC API are listed below:   A full list can be found here:  FreeMaster User Guide. A more deep look at Promises in Javascript can be found in the official MDN Web Documents: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise. Implementing the JSON-RPC API in our HTML page In this section, we are going to exemplify some of the methods (StartComm, StopComm, ReadVariable, WriteVariable) that our PCM wrapper object offers. To give our HTML elements functionality we need to select them and add an event listener to them using DOM manipulation, in our script. Next is a simple example on how to do this, but for a more in-depth explanation check out the MDN Web Documentation: https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction. DOM Manipulation example In our HTML script (index.html), the connect button element is described like this: <button id = "connectBtn" type="button" class="btn btn-success"> <i class="fas fa-wifi "></i> Connect</button>   To select the button element in our Javascript script we use the id attribute of our element: let conButton = document.getElementById("connectBtn");   Finally, we add an event listener to give our HTML element functionality: Using the API Methods In this next section, we are going to use some of the methods that the JSON-RPC API offers us and apply DOM manipulation to use them in conjunction with our HTML elements. The following examples will be written in our javascript script, in this case, index.js (you can also add this in a script element at the end of the body section of your HTML file if you prefer it). The methods that we are going to connect with our HTML elements through DOM manipulation are the next: HTML element HTML name (DOM manipulation) API methods Function   conButton  StartComm and StopComm Start or stop the communication with the board.   measureButton ReadVariable Read a variable from our embedded application, in this case the value of our sine line.   inputAngle WriteVariable Write the value of a variable from our embedded application, in this case the increment between calculations of our sine line.   API Methods: StartComm and StopComm Example The StartComm and StopComm methods open and close the communication port. They receive the name of the port as an argument, the special name “preset” identifies the default connection built in the FreeMASTER desktop application. In our example, we are going to use these methods in index.js when we click the connect button, as you can see we obtain the button with DOM manipulation and use the methods in the event listener.   At index.js let conButton = document.getElementById("connectBtn"); let connection = false; conButton.addEventListener("click", (ev) => { if(!connection) { pcm.StartComm("preset"); } else { pcm.StopComm("preset"); } connection = !connection; })   API Methods: ReadVariable Example The ReadVariable method allows us to read one of the variables in our embedded application. The method receives the name of the variable that we want to read as an argument.  The response object contains the value of the variable. In our example, we are going to start reading the “sin_value” variable when clicking in the “Start Measure” button, we are also going to set an interval for reading that variable every 100 milliseconds.   At index.js let measureButton = document.getElementById("measureBtn"); measureButton.addEventListener("click", (ev) => { //The setInterval function receives a callback function and the time of repetition intervalId = setInterval(() => { pcm.ReadVariable("sin_value") .then((response) => { console.log(response.data); }) .catch((err) => {}); }, 100); })   API Methods: WriteVariable Example The WriteVariable method allows us to write to one of the variables in our embedded application. The methods receive the name of the variable to change and the new value. The response object returns a boolean value if the operation was successful. In our example, we are going to use this method when modifying the “Angle Step” for the input box, to write in the “angle_step” variable. At index.js let inputAngle = document.getElementById("angleStep"); inputAngle.addEventListener("change", (ev) => { pcm.WriteVariable("angle_step", inputAngle.value); })   At the end of the index.js file should look something like this: let pcm = new PCM("localhost:41000", on_connected, on_close, on_error); function on_connected() { console.log("Connected to WebSocket"); }; function on_error() { console.log("Error with the WebSocket"); }; function on_close() { console.log("WebSocket Close"); } let conButton = document.getElementById("connectBtn"); let connection = false; conButton.addEventListener("click", (ev) => { if(!connection) { pcm.StartComm("preset"); } else { pcm.StopComm("preset"); } connection = !connection; }) let measureButton = document.getElementById("measureBtn"); measureButton.addEventListener("click", (ev) => { //The setInterval function receives a callback function and the time of repetition intervalId = setInterval(() => { pcm.ReadVariable("sin_value") .then((response) => { console.log(response.data); }) .catch((err) => {}); }, 100); }) let inputAngle = document.getElementById("angleStep"); inputAngle.addEventListener("change", (ev) => { pcm.WriteVariable("angle_step", inputAngle.value); })   Graphs One thing that we probably want to have in our HTML page, are graphs to show the data from our embedded application. There exist multiple graphs and plotting libraries/modules made for javascript, the one to use truly depends on the requirements of the application, and the preference of who is developing the HTML page. For this example, we are going to use Chartist.js just to show the capabilities that you have using an HTML page with FreeMaster, but feel free to use the library of your preference. The next example will show the use of the JSON-RPC API with a graph library, take into consideration that we are using the Chartist.js for any other libraries/module check the corresponding documentation. Implementing Chartist In the HTML script (index.html), we need to import the Javascript and CSS files from chartists, you can download it from the Chartist official github repositoryhttps://github.com/gionkunz/chartist-js/tree/master/dist.  Or you can look at different alternatives for downloading it in the official page: https://gionkunz.github.io/chartist-js/getting-started.html In the head section of the HTML page we import the files: <link rel="stylesheet" href="./chartist.css"> <script type="text/javascript" src="./chartist.min.js"></script> In the body section, we can insert the chart element like this: <div class="ct-chart ct-major-twelfth"></div> The charts in chartist take an object that contains the data, which must consist of two series describing the data and the labels on the X-axis. Another object can be given indicating the values of the Y-axis. In the Javascript script (index.js) we write this at the beginning of the document: let data = { labels: Array(50).fill(''), series: [ Array(50).fill(0) ] }; let options = { high: 1, low: -1 }; let chart = new Chartist.Line('   Now, to update our chart with the values that we are reading from our board we are going to modify the event listener that we create for our Measure Button, instead of printing the response of our ReadVariable method, we are going to use the response to update the data object of our chart: let measureButton = document.getElementById("measureBtn"); measureButton.addEventListener("click", (ev) => { //The setInterval function receives a callback function and the time of repetition intervalId = setInterval(() => { pcm.ReadVariable("sin_value") .then((response) => { data.series[0].shift(); data.series[0].push(response.data); chart.update(data); }) .catch((err) => {}); }, 100); }) With this, we have set up the chart to update the values of our embedded application. Again, this is specific for the Chartist.js library, although it can serve as a reference for other libraries. Running the HTML Page in FreeMaster Desktop Application We can run our HTML Page either in our browser or in the FreeMaster Desktop Application. Opening in the Browser To run in the browser open the FreeMaster project in the FreeMaster Desktop Application and then open the HTML page in the browser:   Opening in the FreeMaster Browser Application For the FreeMaster Desktop Application, we need to go to the options of our FreeMaster Project:   Go to the HTML page section, there select the HTML file in the “Control page URL” input, and then select the “Chromium Embedded Framework” in the HTML Rendering Engine option:   Conclusion We can use HTML pages empowered with Javascript to create a powerful and customizable user interface taking advantage of the extensive tools that exist for Javascript. The API that FreeMaster offers for connecting our page with our embedded application allows us to create these pages easily without sacrificing the functionalities that we have with FreeMaster. Feel encouraged to check all the methods that the API offers and explore all the things that you can do with it. 
View full article
Introduction The FreeMaster driver has a feature called TSA (Target Side Addressing) a mechanism that allows you to describe the data types and variables directly in the embedded application source code and make this information available to the FreeMASTER tool to describe the variables that we want to display in FreeMaster, making the information automatically available from our board to the FreeMaster software.   With TSA we make the address of our variable available without the necessity of symbol files (a file that contains the description of all the variables in our embedded application: name, address, and size of the variable) that the FreeMaster application normally will need to see the variables of our application. Thanks to the TSA mechanism we can also describe files in our embedded application mapping the file to its hexadecimal values and creating a variable that contains those values. This combined with the elimination of the need for a symbol file can allow us to insert a FreeMaster project in our embedded application and give it a Plug-and-Play function to the board.   Without TSA   With TSA   There is a special type for user resources like memory-mapped files, with this we can make our FreeMaster project file available to the FreeMaster software from our embedded application, giving our project a plug and play functionality with FreeMaster.   Example Description In this example, we are going to convert a FreeMaster project file (.pmp or .pmpx) into a memory-mapped file, add that file to our embedded application, create a new TSA table for files and other types of active content where we are going to describe our new memory-mapped file and finally connect to FreeMaster and run our project automatically from our board.   Take notice that to follow this example you will need a FreeMaster project (.pmp or .pmpx) and an embedded application that already has the FreeMaster driver for connection with the project, more information about creating a FreeMaster project and configuring the board to run it can be found in How To implement an interface using FreeMaster. For this document we are going to expand the example from How To implement an interface using FreeMaster, you are invited to also use it or to use your FreeMaster project (just remember that the example code of this document will be based on the other example post).   Software/Hardware used Hardware setup: Board Used: FRDM-K64F SDK: SDK_2.x_FRDM-K64F  Version 2.8.2  (latest version)     Software setup: Main Application (Embedded Application with FreeMaster Configuration) developed in: MCUXpresso IDE v11.2.0 FreeMaster Desktop Application Version: FreeMaster  3.0.2.6   Convert  our FreeMaster project file to a hexadecimal block of data First, we need to convert the project file (.pmpx) into a block of data in a C header file, what we need is the representation of our project file in hexadecimal values and save it as a variable so FreeMaster can use the TSA mechanism later to access it as a memory-mapped file.   To do this we can use the bin2h application, we are going to explain how to do it with bin2h but you are free to use any other method at your disposal. To download bin2h go to http://www.deadnode.org/sw/bin2h/:   The bin2h program is a command-line utility so we need to open our command-line interpreter of preference to use it (in this example we are going to use the Windows Command Prompt). Open your command-line interpreter and go to the direction where you downloaded the bin2h program  (you can also add it to your Path environment variable so you can access bin2h from anywhere, you can see how that is done from https://www.java.com/en/download/help/path.xml) .   Now the syntax to use bin2h is the next:   bin2h -flags variable_name < input file > output file   The input file is our FreeMaster project file, the output file is the name of the C header file that will be generated and the variable name is going to be the name of our array of hexadecimal values representing the project file (can be any name you want). We will add the -c flag to tell the application to include a variable with the size of the array.   So in the command line we write: This will generate a data_example.h file containing a character array with the name example: data_example.h contains: At the end of the file another variable with the size in bytes of the array: After creating the data_example.h file, we need to pass it to our source folder in the MCUXpresso project of our embedded application (remember for this document we are using the project example from https://community.nxp.com/docs/DOC-347236 ) :   Implementing it in our code TSA uses tables to describe the information and data we want to share with FreeMaster. We will need to create a new table with the description of the memory-mapped file of our FreeMaster Project (the data_example.h file).   In the c file of our application we add: /* We include data_example.h in our code */ #include "data_example.h" FMSTR_TSA_TABLE_BEGIN(files_and_links) FMSTR_TSA_MEMFILE("/example.pmpx", example, example_size) /* projects to be made available in FreeMASTER */ FMSTR_TSA_PROJECT("FreeMASTER Project (embedded in device)", "/example.pmpx") FMSTR_TSA_TABLE_END();‍‍‍‍‍‍‍‍‍‍‍‍‍ In this example, we named the table files_links to describe the content of the table, but it can be anything name we want. We use the FMSTR_TSA_MEMFILE to indicate the variable where our file is memory-mapped, it takes as arguments the name we are going to refer the project file when we are running the FreeMaster application (it has to end with pmp or pmpx so FreeMaster knows is a project file), the variable that contains the memory-mapped file and the size of that variable.   With FMSTR_TSA_PROJECT we facilitate the access to the FreeMaster project from the FreeMaster application, it creates a hyperlink to the project from the welcome page in FreeMaster, we need to indicate the text of the hyperlink and the name of the project file (the one we set up with FMSTR_TSA_MEMFILE), in the welcome page it will look like this:     After we create the table we need to add it in our table list (in this example we already have another table for our variables): FMSTR_TSA_TABLE_LIST_BEGIN() FMSTR_TSA_TABLE(first_table) FMSTR_TSA_TABLE(files_and_links) FMSTR_TSA_TABLE_LIST_END();‍‍‍‍ To demonstrate the use of the TSA for memory-mapped files we are extending an example from the post How To implement an interface using FreeMasterHow To implement an interface using FreeMaster , in this example, we already have a TSA table for sharing our variables.   Our code should look something like this: float sin_value = 0; float angle_step = 0.0001; FMSTR_TSA_TABLE_BEGIN(first_table) FMSTR_TSA_RW_VAR(sin_value, FMSTR_TSA_FLOAT) FMSTR_TSA_RW_VAR(angle_step, FMSTR_TSA_FLOAT) FMSTR_TSA_TABLE_END(); FMSTR_TSA_TABLE_BEGIN(files_and_links) FMSTR_TSA_MEMFILE("/example.pmpx", example, sizeof(example)) /* projects to be made available in FreeMASTER */ FMSTR_TSA_PROJECT("FreeMASTER Compare Project (embedded in device)", "/example.pmpx") FMSTR_TSA_TABLE_END(); FMSTR_TSA_TABLE_LIST_BEGIN() FMSTR_TSA_TABLE(first_table) FMSTR_TSA_TABLE(files_and_links) FMSTR_TSA_TABLE_LIST_END(); //The rest of our application int main(void) { ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍   With this done, now we can compile our code and program the flash of our board, to finally run our FreeMaster project from the board.   Running the project Now let’s run the project from our embedded application, first open FreeMaster software and use the Connection Wizard to connect with your board: Use the “Use direct connection to on-board USB port” option and select:     After that in the Welcome Page, you will see a new box-button under the “Explore the board” section of the Welcome Page:   Click on the button and the project will open, you can see that FreeMaster tools like the oscilloscope and configurations for the Variable Grid have been imported from our FreeMaster memory-mapped file. The FreeMaster project should look the same as when we created it.   Conclusion With the use of the TSA feature, we have given our FreeMaster a plug and play functionality to run our project in any computer with FreeMaster without needing to pass our project file to that computer. The TSA table also allows us to share from our embedded application user resources like virtual directories, web URL hyperlinks,  EEPROM files, and SD Card files, expanding the possibilities of what we can share and demonstrate with our application.
View full article
Updated version 3.0.3 of the NXP FreeMASTER tool has just been published online.  The installer is available along with documentation and other resources at http://www.nxp.com/freemaster. Version 3.0.3 brings bugfixes and minor updates. The most significant enhancement has been made in the ELF/DWARF file parser which now fully supports the C++ namespaces and nested classes with fully-qualified names of global and C++ static symbols. Complete list of changes: Recorder automatic data loading has been made configurable (similarly as in versions 2.x). Critical fix of XML (.pmpx) file serialization. The file could get corrupted when saving large projects with internal object identifiers larger than 10000. Also the XML serialization was fixed to maintain internal object IDs between load and save - so the fresh-open project will generate a binary-same file when saving without change. Fixed broken link to PDF User Guide in the welcome page. Fixed file download feature in the Chromium HTML view (save-as dialog always displayed). Fixed GCC ELF/Dwarf4 parsing of global variables which are members of a C++ namespace. Fixed Recorder triggering using float variable when using old protocol with driver 2.0. Fixed startup crash while loading recent window layout. Need to restart app for 2nd time if this occurs. Fixed default color assignment in dynamically-created oscilloscope and recorder items. Fixed COM port name and description parsing from Windows registry. Fixed JSON-RPC DefineVariable call to accept one JSON definition argument. Fixed wrong initial sizing of the CEF view withing the parent container. Fixed PD-BDM plug-in operation on big-endian systems (see more in bdmpgi Release Notes). Thank you for using the NXP products and FreeMASTER tool.
View full article
  A FOUR-PART WEBINAR SERIES   |   60 MINUTES EACH FreeMASTER, from NXP, is a powerful real-time debugging and data visualization tool that can help you create engaging demo interfaces for your embedded application. Join NXP for this four-part on-demand training series as we’ll provide an overview of the software, it’s features, capabilities, available examples, application use cases and how to easily get started. Part 1:   Watch Now >  Get to Know the Easy-to-Use FreeMASTER Runtime Debugging Tool – Now Part of MCUXpresso SDK Join this session as we walk through live demos of FreeMASTER 3.0 examples provided in the SDK to highlight the main out-of-the-box features of this tool.   Part 2:   Watch Now >  Tips for Enhancing Embedded Applications with FreeMASTER UI from Various Development Environments like S32DS and Matlab/Simulink Join this session to learn and explore multiple FreeMASTER enablement options and how to design your applications to be much more user-friendly.   Part 3:   Watch Now >  Introduction to FreeMASTER Dashboard Coding Using HTML, JavaScript, ActiveX and JSON-RPC In this session we further explore FreeMASTER’s capabilities to connect to third-party applications primarily focused on the coding of JavaScript-based HTML to create interactive dashboard applications running either directly inside the FreeMASTER application or standalone in a local or remote web browser.   Part 4: Watch Now > Getting Started with FreeMASTER Lite and JSON-RPC Protocol: From Scripting to Visual Dashboards with Python and JavaScript Join this webinar to learn more about FreeMASTER Lite and how to get started as we’ll share coding examples in Python and JavaScript.
View full article
A FOUR-PART WEBINAR SERIES | 60 MINUTES EACH FreeMASTER, from NXP, is a powerful real-time debugging and data visualization tool that can help you create engaging demo interfaces for your embedded application. Join NXP for this four-part training series as we’ll provide an overview of the software, it’s features, capabilities, available examples, application use cases and how to easily get started. Part 1: Tuesday, April 28 | 10 AM CDT |   REGISTER NOW >> Get to Know the Easy-to-Use FreeMASTER Runtime Debugging Tool – Now Part of MCUXpresso SDK Join this session as we walk through live demos of FreeMASTER 3.0 examples provided in the SDK to highlight the main out-of-the-box features of this tool. Part 2: Thursday, April 30 | 10 AM CDT |   REGISTER NOW >> Tips for Enhancing Embedded Applications with FreeMASTER UI from Various Development Environments like S32DS and Matlab/Simulink Join this webinar to learn and explore multiple FreeMASTER enablement options and how to design your applications to be much more user-friendly. Part 3: Tuesday, May 5 | 10 AM CDT |   REGISTER NOW >> Introduction to FreeMASTER Dashboard Coding Using HTML, JavaScript, ActiveX and JSON-RPC Join this webinar to further explore FreeMASTER’s capabilities to connect to third-party applications primarily focused on the coding of JavaScript-based HTML to create interactive dashboard applications running either directly inside the FreeMASTER application or standalone in a local or remote web browser. Part 4: Tuesday, May 12 | 10 AM CDT |   REGISTER NOW >> Getting Started with FreeMASTER Lite and JSON-RPC Protocol: From Scripting to Visual Dashboards with Python and JavaScript Join this webinar to learn more about FreeMASTER Lite and how to get started as we’ll share coding examples in Python and JavaScript.
View full article
This article will explains the TSA functionality from both embedded and the FreeMASTER tool side. It is part of the FreeMASTER Tutorial series: Communication Driver Connecting to the Board Target Side Address Translation (current article) Exposing project variables via TSA
View full article
Tutorial video explaining FreeMASTER TSA (Target Side Address translation) functionality.   Music by   Bensbound
View full article
Updated version 3.0.1 of the NXP FreeMASTER tool has just been published online.  For more details, please read the recently posted FreeMASTER 3.0 Announcement. Also see downloads, documentation and other resources at http://www.nxp.com/freemaster. Major changes introduced in the new version: Added support for PEAK-System CAN (PCAN) devices using the PCANBasic API P&E Micro BDM plug-in has been updated to support the latest P&E debugging interface cables. Packet-driven BDM plug-in configuration dialog extends the list of available target devices and valid RAM ranges when searching for a PDBDM command buffer. Bug-fixes and other minor changes: Fixed oscilloscope data reading using old V1-V3 protocol versions on big-endian systems. Fixed manual recorder stopping when using old protocol versions. The expanded/collapsed state of project tree items is now stored to project file and restored when project is open (PMPX file format only). Reading large block of data (e.g. reading embedded project file using the fmstr:// protocol)  has been made more robust and prone to communication errors. Fixed confusing recorder name "not found" when using old protocol versions. Fixed calculation of total recorded point size in Recorder Properties dialog. Fixed wrong JSON keys in exported FreeMASTER Lite configuration file. Thank you for using the NXP products and FreeMASTER tool.
View full article
This article is meant to show you how to connect to your board, monitor and control embedded application using FreeMASTER tool. It is part of the FreeMASTER Tutorial series: Communication Driver  Connecting to the Board (current article) Target Side Address Translation Monitoring and Controlling an Embedded Application Prerequisites: FreeMASTER 3.0 See the demo project in attachments.
View full article
Tutorial video show a simple use case featuring monitor and control capabilities of the FreeMASTER tool.   Music by   Bensbound
View full article
Tutorial video explaining how to integrate FreeMASTER Communication Driver into an embedded application. Music by Bensbound
View full article
Release Description FreeMASTER is a powerful data visualizer tool developed and provided by NXP to help users monitor and control embedded applications running on NXP’s targets. It works with almost all NXP CortexM microcontrollers from both Edge Processing and Automotive BLs as well as with legacy Power Architecture, ColdFire, DSC and HCS12/Z platforms. FreeMASTER 3.0 release brings a suite of new updates for the host application, extending the variable monitoring capabilities, oscilloscope real time graphs, fast transient recorder graphs and connectivity to 3rd party applications. A new engine based on Chromium with full support for JSON-RPC, HTML5 and JavaScript is now available to define custom user interface running embedded in the FreeMASTER desktop window or standalone in local or remote web browser. The latest FreeMASTER also remains backward compatible with ActiveX interface and protocols defined for versions 2.x and even the 1.0 introduced more than 18 years ago. A new feature – called FreeMASTER Lite – composed of a the FreeMASTER communication core library and the web-server running on the host is now available for Windows and Linux operating systems facilitating connection to the target microcontroller application from any web browser. JavaScript or Python scripting to control the target is now also available via FreeMASTER Lite. Target Audience Both FreeMASTER and FreeMASTER Lite are primarily targeted to our customers, engineers and developers of NXP embedded applications from Industrial, IoT and Automotive areas who want to monitor and control their applications at runtime. FreeMASTER is also a strong framework which can be used to create powerful demonstrations and user interface helping to use the embedded applications by yet wider target audience. Prerequisites FreeMASTER tools run on the host computer and communicate with the target microcontroller application using Serial, CAN, JTAG, BDM or other physical interface. The microcontroller communication drivers are available as part of MCUXpresso SDK, S32 Design Studio or as a standalone installation package. Get familiar with the communication protocol and the microcontroller driver API before using the FreeMASTER tool. Packages A single self-extracting installation package which contains both FreeMASTER desktop application and the new FreeMASTER Lite service is available for Windows platforms. A package with the FreeMASTER Lite service is also available for Linux. Access the installation and documentation at the FreeMASTER home page at https://www.nxp.com/freemaster. What’s New Chromium browser and JSON-RPC API While Internet Explorer and ActiveX scripting interface is still supported, the new Chromium rendering engine is now available thanks to the CEF project. All ActiveX methods are now also accessible using fully asynchronous JSON-RPC API. Control pages and JavaScript can now be debugged in a standalone Chrome browser. Support for Communication Protocol v4 FreeMASTER Communication protocol has been completely redesigned to enable new features like password protection, more robust error detection or multiple parallel instances of Recorder and Oscilloscope.  New MCU Serial Communication Driver Serial Communication Driver is now available as a middleware component of MCUXpresso SDK driver suite. See more information in an online version of the SDK Builder. Add the FreeMASTER middleware to your SDK package and start with one of the FreeMASTER example applications. When using MCUXpresso IDE, the FreeMASTER driver may be easily inserted to existing projects. Multiple Recorder, Oscilloscope and Pipe Views Graph and Pipe views may now be open as floating windows or docked to a side of the main application window. Simply right-click an Oscilloscope, Recorder or Pipe item in the project tree and select "New Window...". Enhanced Data Capture Multiple graph and pipe views can now be configured to capture data to files simultaneously. Oscilloscopes may also be configured to capture only unique values, skipping redundant consecutive samples. Open ZIP-compressed Project Files ZIP-compressed project files may be open in FreeMASTER for read-only use. Minimizing the project file size may be useful when embedding it to target microcontroller Flash memory and accessing it by TSA Active Content feature. FreeMASTER "Lite" Service Brand new FreeMASTER "Lite" Service may be started on a host computer to provide a JSON-RPC API to remote clients. Such clients are typically control pages running on remote devices (tablets, phones) or test scripts written in node.js, Python and others. Using the "Lite" service, you can exploit FreeMASTER functionality on Windows or Linux platform without running the "full-weight" FreeMASTER UI application. The JSON-RPC interface implemented by the service is almost identical to that provided by the standard FreeMASTER desktop tool and to its ActiveX interface. Unlike the full FreeMASTER application though, the Lite service does not have a user interface. It is configured by a local configuration file and runs silently on the user computer. The control pages and other clients (like script applications written in node.js or Python) may connect to the service from local or remote computers and access the target microcontroller application. The major difference from the desktop FreeMASTER application is that the Lite service also acts as a standard web server and may provide control pages and their resources to remote clients like tablets or mobile phones.
View full article
Dear users,  18 year after releasing the first version the tool (called PCmaster that time) and four years since the FreeMASTER version 2.0 we are here again with something new. FreeMASTER 3.0 comes with updated communication protocol, extended floating and dockable graph views, new JSON-RPC scripting support and with a Chromium engine to render Control Pages. Old concepts of ActiveX scripting and the embedded Internet Explorer remain available for backward compatibility. Along with the reworked desktop application, we also introduce FreeMASTER Lite service. The FreeMASTER Lite strips down the UI and concentrates on the communication core. Same as the desktop tool, the lite version enables users to connect to the target microcontroller board and to share the access with remote clients using JSON-RPC. It also runs its own web server and enables remote mobile devices like phones or tablets to connect, fetch HTML files and other resources and run the Control Page interface in a standalone environment. FreeMASTER serial driver supporting the new version (v4) of the communication protocol is now available in the MCUXpresso SDK as a middleware component. See more details in the SDK Builder at mcuxpresso.nxp.com. Use this newly created community page to discuss FreeMASTER use cases or issues. See you around, your FreeMASTER team.
View full article