RoadTest: Renesas RX65N MCU EV Kit
Author: gordonmx
Creation date:
Evaluation Type: Development Boards & Tools
Did you receive all parts the manufacturer stated would be included in the package?: True
What other parts do you consider comparable to this product?:
What were the biggest problems encountered?: Lack of support & documentation
Detailed Review:
First off, I would like to thank Renesas and Element 14 for the opportunity to evaluate the Renesas RX65N Envision Evaluation Kit (“the Kit”).
Summary Conclusion –
I must start my summary with an embarrassing admission that I hadn’t used Renesas’ e2Studio IDE in years and during my initial setup I inadvertently erased the bootloader program from the evaluation board. For over a month I tried various attempts to re-install the secure bootloader from the demo source code available from both Renesas’s and Segger’s websites to no avail. The secure bootloader was important because this is the method used in the eval kit’s documentation and video(s) to evaluate and compare the important features of the RX65N such as the 2D drawing engine, GPU, FPU and touch screen performance. Even then with the recommended firmware version the performance evaluation was somewhat subjective. The secure bootloader is also used to demonstrate the bank swap feature. I have searched the internet and tried postings to the Renesas Rulz community forum with little success.
As mentioned above, I have used Renesas dev kits in the past and surprised with all the issues I had. I finally did find a method to restore the board’s initial firmware, but I lost a great deal of time in the process. The lost time was useful in other ways. Although the performance I observed was impressive and worth looking into further, sadly to say the support both in documentation and on the community forum was less than recommendable to all but the experienced programmer. As mentioned in my conclusion at the end of this review, unless you have some experience with Renesas IDE, I would not like my boss to drop this off on my desk on Friday afternoon and ask to see a demo on Monday morning.
With all the issues I have had with the RX65N Envision board, I was impressed with the speed and overall performance of the board. The integrated FPU, GPU and 2D drawing engine is clearly an advantage in the RX65N. I did not get a chance to measure the power consumption, but other reviewers have and with good results. I have worked with other manufacturer’s touch screen displays and felt the smoothness and feel of the interface to be very comparable. I would like to see the demo programs updated to incorporate multi-touch on the display. NOTE: Multi-touch screen is an example in the Segger source code pack, but not implemented in their demo version.
Pros –
Cons –
Wish List –
Useful Document Links-
NOTE: Logging in to the respective websites may be required to access some of the documents.
Part I – What is the RX65N Envision Kit…
Before diving into my actual review of the Renesas RX65N Envision Evaluation Kit, P/N RTK5RX65N2C00000BR, let’s take a look at what it is. From what I can piece together from various documentation and websites, the kit itself is not a new board. The current hardware manual, rev 1.0, is date September 2017. Renesas has an unboxing video dated January 2018. So the kit should be fairly stable, but it does beg the question about support life of the components used in the evaluation board. As stated in the hardware user’s manual the purpose of the kit is as an evaluation tool for Renesas (RX65N) microcontrollers. In other words, although there is some limited value as a development board, its main purpose is to showcase the very useful features of the RX family and specifically the RX65N MCU. The main features of the kit are Renesas’ RX65N integrated:
The kit also highlights addition features as it combines other manufacturer’s peripheral components such as:
Other features are laid out on the board but not loaded like SD card, Ethernet, joystick, Pmod and Arduino interfaces. The user’s H/W manual refers to these user installable features as “User-Fit options”. Some of the User-Fit options require additional support components. I’m assuming the unloaded features were an attempt to reduce manufacturing costs and not reduce support.
From the user’s H/W manual, the following pictures show the general block diagram and component layout of the PCB.
RX65N Envision Evaluation Board Block Diagram
Board Layout – Under Side w/ Display Removed
Board Layout – Under Side w/ Display & User-Fit Option Installed
RX65N MCU Block Diagram (from datasheet)
The pre-installed firmware is partitioned into 3 intertwined segments. The first segment is the secure bootloader which is compiled and installed first using the unsecured program installer using either its *.mot or *.x file. The second segment is the “standard” program which includes the GUI-based 2D drawing engine, bouncing balls, Mandelbrot and bank swapping demos. The final segment is the “benchmark” program which includes the GUI-based secure update, storage benchmark, network statistics and system log demo screens. The last 2 segments are initially loaded as part of the full demo firmware install, but for the firmware swapping demo are converted to secure *.rsu files and loaded to a USB stick. This is where the 3 programs are intertwined. When the bank swapping demo from the standard program is called it initiates the secure update window from the benchmark program which uses the secure bootloader to actually load the new firmware. If you don’t have the standard program to call the benchmark program to call the bootloader the whole demo falls apart. I found this out the hard way by accidentally loading 2 different versions of the standard file (not prohibited in the demo) and, having no benchmark program to call, I had to re-install the initial full installation over.
Bear in mind if you don’t care to use the secure firmware swapping feature of the board you can do what I accidentally did and erase/overwrite the demo firmware, as demonstrated by other reviewers.
Part II – The Unpacking:
I have read many different views on the value and/or importance of the unpacking segment, but I feel it is important because it is often our first glimpse into what to expect in the product and support. I hadn’t worked with Renesas dev boards in a number of years, but I was excited to road test the “Kit” because of my past experience with them. I was especially interested in their touchscreen technology.
The shipping box arrived undamaged, always a good sign, and well packed. Obviously, it wasn’t shipped by Amazon 8^).
The box included the 1) RX65N Envision evaluation board, 2) a USB Type-A to Type B mini cable (for power & loading programs) and 3) an informational “quick start” card (as part of the kit packaging – as seen below).
The ”Kit” The “Kit” Content The "Kit" Instructional Information
The “Kit” – Front View The “Kit” – Rear View
Part III – Initial Board Power On:
At this time I normally power up the kit to get a feel for whether the unit will show any sign of life. The good news is it did power up (i.e. no smoke or blank-screen-of-death). As mentioned on the informational quick start card the out-of-box board comes preprogrammed with the 3 software components (i.e. secure bootloader, standard & benchmark programs). After a short boot screen the board boots to the standard demo program GUI.
Out-Of-Box Power On Boot Screen Out-Of-Box – Standard GUI Home Screen (v0.90)
You’ll see in later pictures that the version of demo firmware loaded to the “active” memory banks will be displayed in the Bank Swap homepage. Well sometimes.
Standard Demo Programs -
2D Drawing Engine (2DDE) v0.90 Demo –
One of the disappointing aspects of the out-of-box software is that some of the demos are not completely functional. The 2DDE is one of them. As you can see from the picture above, the 2DDE switch is non-functional (i.e. “no operation”). This is also reiterated by the text of the [HELP] screen (see highlight text below). The display shows the movement of the clouds as they travel across the screen, passing behind other objects and the logo. The movement seems jerky and we will have to wait for the installation of the next version (v1.0) to see the value of the 2DDE. However the touch screen works very smoothly. To return to the home page press the house icon in the upper left hand side of the screen. The Help menu is shown below.
Std(v0.90) 2D Drawing Engine Help
Enjoy the 2D Drawing Engine demo!
Info:
The 2D Drawing Engine demo shows the efficiency of the 2D graphic accelerator embedded in the RX65N MCU working with the semi-transparent images and alpha blending. The clouds sprite moves smoothly over the fixed image background with hidden area redrawn dynamically as it is uncovered. The RX Logo can be moved by your finger tip using the touch screen. Please note that shipped firmware doesn’t support the 2D graphic accelerator so far. Please download the latest firmware from the Envision Kit web page: www.renesas.com/envision
Usage Guide:
Using the touch screen you can freely move the RX logo over the fixed background and animated clouds. You can turn off the 2D Drawing Engine by the provided button to show the performance difference with and without the embedded hardware accelerator. With the Home button you can go back to the main screen.
Bouncing Balls (BB) v0.90 Demo –
Again another incomplete demo with no way to measure or compare the performance change. Note the blurriness of the balls. The help screen conveys the uses of the RX65N’s integrated Floating Point processor (FPU) to speed the ball movement, but doesn’t offer a comparison. Again we must want for the next firmware version. To return to the home page press the house icon in the upper left hand side of the screen. The Help menu is shown below.
Std(v0.90) Bouncing Balls Help
Enjoy the bouncing balls!
Info:
The Bouncing Ball demo shows the superior calculation performance of the 32-bit RX65N MCU. Several balls enter the screen at random angles from the top left and fall and bounce under the influence of a simulated gravity model. The RXv2 Core and the integrated Floating Point Unit (FPU) make the calculations an easy task for the RX65n.
Usage Guide:
With the Home button you can go back to the main screen.
Mandelbrot v0.90 Demo –
The Mandelbrot demo uses a number of the RX’s features (see Help text below) to produce a smooth construction of the display image. Once again the touch screen offers seamless motion with the added feature of single touch and drag zoom. It would have been nice to have implemented double touch zoom, but it is what it is. NOTE: Segger’s emWin demo code does have a multi-touch example, but I didn’t have a chance to try it.
Std(v0.90) Mandelbrot Help
Enjoy the Mandelbrot demo!
Info:
A Mandelbrot set image is generated by resolving an algebraic function for a series of complex numbers and is used as an example of calculation intensive activity for any CPU. The RXv2 Core structure includes:
- Single Precision Floating Point Unit (FPU) adapts pipeline processing to boost throughput.
- DSP functionality achieves single-cycle throughput on 32bit multiply-accumulate operation using two sets of wide-range accumulators.
- Dual-issue five-stage integer pipeline incorporates enhanced DSP/FPU functionality.
All of this makes the Mandelbrot calculation in real time an easy task for the RX65N.
Usage Guide:
Using the touch screen to plot opposite corners of a rectangular area, you can zoom in to the Mandelbrot set image and define the next set of fractal calculations in real time. With the Back button you will go back to the previous shown screen of the Mandelbrot image. With the Home button you can go back to the main screen.
Bank Swap v0.90 Demo –
The bank swap main page displays the current firmware loaded to Banks A and B. This is where the version of loaded code is shown. From the picture above, the current active bank (A) has the standard demo program loaded. The bank swap demo is part of the standard firmware. When the [Swap!!] button is clicked the banks are swapped (A <> B) placing the benchmark code into the active A bank, then the forces a reboot. As mentioned earlier, both demo programs are intertwined (see highlighted caution in the Help message below). Pressing [Swap!!] will result in the following display changes:
Reboot after swapping banks Benchmark demo home page
The text of the bank swap Help menu is shown below.
Std(v0.90) Bank Swap Help
Enjoy the Bank Swap demo!
Info:
It is possible to update the firmware by inserting a USB memory stick containing suitable firmware image into the USB Host interface of the Envision Kit. To obtain a firmware image to be copied to your blank USB memory stick, please go to www.renesas.com/envision. Once the new firmware image has been flashed into the alternate embedded flash memory bank, you can quickly swap between the two firmware versions using the Bank Swap dialogue. In the default kit shipment you will be able to find a benchmark firmware on the second memory bank.
Usage Guide:
Insert USB memory stick while pushing user button on the Envision kit within the Bank Swap demo screen to flash new firmware to the RX. In the Bank Swap screen you can swap between the two firmware versions by pressing the Swap button. With the Home button you can go back to the main screen. Please ensure that any new firmware you flash into a bank, supports a swap functionality, otherwise you have no chance to enter the second flash anymore, except by using the on chip debugger.
Benchmark Demo Programs -
The Benchmark program is comprised of 4 system maintenance/information/performance sub-pages. A status bar including the USB/SD status, the board’s IP address and the time since power on is displayed at the bottom of each page. After the Benchmark home page is initially touched, the operator can move between pages using the [next] or [prev] buttons. None of the sub-pages have a [Help] menu/button.
Secure Update v1.02 Demo-
The first screen to appear is “Secure Update”. From this page the Secure Boot (Firmware Area = bank A) firmware can be swapped with the Secure Boot mirror (Temporary = bank B) memory. After the banks have been swapped, the system reboots itself, and then starts up into the program located in the secure boot memory. This method can be used to update product firmware quickly.
If the operator wants to replace one of the programs you add the firmware file to a USB stick and plug it into the USB Type A port on the board. Since the firmware is load by the secure bootloader, the file must be a secured file (i.e. .rsu suffix). The .rsu file is created by running a .mot or .x file from the compiler through the converter.exe program found in the Renesas tool folder. The status bar will indicate that the stick is attached and all the valid firmware files on the USB stick will appear in the center column of the display. Using the touch screen, select the firmware to be loaded and then touch [update]. The status of the upload will appear in the console area on the right side of the display. If the upload is successful the screen will prompt you to press the [REBOOT] button.
NOTE: It is strongly recommended that if you would like to create your own secure firmware file that you go back and review my warning in the help message under the Bank Swap demo section.
You can move to the next demo sub-program by pressing [next] button.
Storage Benchmark v1.02 Demo-
By pressing [Start] then program will perform read/write speed tests on the USB and SD memory in Mbps. Since the SD card hardware is not installed on the board, an error will appear for SD-related tests. You can move to the next or previous demo sub-program by pressing [next] or [prev] buttons, respectively.
Network Statistics v1.02 Demo-
Although the firmware assigns the IP address (192.168.0.3:80), like the SD circuit the Ethernet hardware is not loaded, so the status is “TIME_WAIT”.
You can move to the next or previous demo sub-program by pressing [next] or [prev] buttons, respectively.
System Log v1.02 Demo -
This page shows the system log entries since power on. You can move back to the benchmark demo home page by pressing [prev] button.
As mentioned earlier, the out-of-the-box demo programs are not very useful and I will go over the improvements found in the next 3 version of the program found through my internet search, but for now my next steps would be to install the IDE, then try programming the board.
Part IV - Installing the e2Studio IDE Software:
Before jumping into the installation process, I wanted to show you my PC information:
I started by going to Renesas RX65N Envision website (www.renesas.com/envision) shown on the information quick start card that came with the kit and clicked on the links in the last 2 items in the “Features” list.
The 1st link takes you to the Eclipse-based e2Studio information and download page.
The “Download the Installer” link allows you to click on the version of the IDE you want to install. At the time I chose the latest version (v7.6.0) to install. NOTE: Current “latest” version is at v7.7.0.
The link below the download icon includes videos and a user manual for installing the IDE and building a project. I already had a very early version of e2Studio IDE installed on my PC, but since this is an out-of-box review, I uninstalled it before re-installing the newer version. From the link, I followed the installation video (https://www.renesas.com/us/en/support/videos/e2studio-v7-installation.html). The installation instructions are very terse and vague in many areas. This could certainly be an issue for those unfamiliar with Renesas’ e2Studio IDE.
NOTE: In cases like this I would normally use the default setting, but not this time (Oops #1). The install seem to go well, but I when I tried to compile the demo source code, things didn’t go well. As it turns out my choices may not have been the problem, but to play it safe I uninstalled my 1st re-install and re-installed again using the default setting. For my 2nd re-install, I followed the user manual which is just a brief. The entire install instructions represent less than a single page in the manual.
The actual installation of the software has been outlined by other reviewers so I will only hit upon a few areas in the following section that I found useful and that others had issues also. To start off I would recommend an instructive video by Renesas application engineer Gerald O’Docharty (see Useful Document section) was also very helpful as it demonstrates each step of the installation. NOTE: This video is not mentioned on the Envision webpage or in any documents, but maybe should be. It also covers how to build a GUI on the Envision display using emWin.
After installation is complete the IDE should look similar to:
The second link takes you in a slightly roundabout way to the Segger’s emWin Envision kit demo software and library website. A short cut to the final link is https://www.segger.com/products/user-interface/emwin/technology/emwin-support-renesas-rx-mcu/.
NOTE: For the purpose of my final example, I will be using the Segger’s EnvisionKit demo source code. This code is used to build the standard and benchmark programs, but not the secure bootloader code.
Part IV – Oops!!! Now what do I do???
As you probably have already gather, my experience with reviewing the Envision board was not what I had expected. As mentioned earlier, I have worked with Renesas dev kits before without any major problem, so my issues were somewhat of a surprise. But how did this happen? Of course it stemmed from a bad judgement call on my behalf.
I had just finished my 1st install of the IDE and had already downloaded the demo source code file (rx65n_envisionkit.zip) from the Renesas Envision website. Part of my plan was as always to evaluate the materials and documentation as would be available to a first time user. Since the source code was made available along with the IDE, building and loading the demo program was part of that plan. My next step was to import and build the demo project; however I decided to deviate from my plan just a little. And what a big however it turned out to be. I had read a recent blog about creating an empty project using the Envision board and the e2Studio IDE, so before building the demo project I thought I would give it a try. Everything was going fine until the last step. You see it was late, maybe too late, and I was getting tired. I didn’t notice that the instructions for building an “empty” was indeed empty of any source code. Interesting the empty project build beautifully (i.e. no errors, no warnings). It wasn’t until I pressed the debug button that I realized that there was nothing to load. My fear was confirmed when I but the board in standalone mode and found the following screen:
The screen was blank. NOTE: Not that the blank screen was due to the empty project, but because the IDE erases the current file before trying to load the new firmware.
Like I said “bad judgement”. However I thought, just a belief setback since I have the demo source code, right! Well…
Start with our blank workspace, let’s import the demo code from the Renesas Envision download page First download the rx65n_envisionkit.zip demo package to your PC. From the [File] dropdown menu, click [Import] -> General -> Existing Projects into Workspace, then [Next]. Under the “Import Projects” pop-up window browse to the directory you copied the demo source code to then click [OK]. Under the “Import Projects” pop-up window make sure the “Copy projects into workspace” option is checked, then press [Finished].
After the code has been imported the Project Explorer tab should display the 3 project components. NOTE: The screenshot shown below is of the IDE’s “C/C++” perspective.
In the Project Explorer, right click on “rx65n_envision_kit_demo” then select “properties”
Expand the “C/C++ Build” -> Setting -> Toolchain property tab. Select the version of the CCRX toolchain you want to use. Then press [apply and Close] NOTE: I chose v2.08.00 because it was the closest version to the one used to generate the original demo firmware.
Now double click the rx65n_envision_kit_demo.scfg file under the Project Explorer. Press [Open Perspective] to continue
Under the rx65n_envision_kit_demo.scfg -> Board tab, select the EnvisionRX65N (V1.00) device from the drop down.
Press the generate code button
Repeat the toolchain selection and perspective board selection for RX65N_EnvisionKit and rx65n_secure_boot projects.
Select the hardware debug configuration to build in the project config drop down, then select [Project] -> [Build All]
I chose “rx65n_envision_kit_demo”.
And this is where everything falls apart with 30 errors and 55 warnings!! The errors appear to be mainly due to missing header and linker files, but this is what came with the imported demo source. If additional files were required beyond the ones included in the demo archive the documentation (or lack of) does not mention them. I was able to track down the missing header files, still had compiling issues and finally aborted the effort.
Well this sucks! Back to the internet and more searching. Nothing! Well how did I final get the board back to the start (i.e. out-of-the-box firmware). Thankfully there is Goggle and the search began. I tried Renesas’ Rulz community forum where I posted my dilemma. Most of the time my questions were misunderstood leading to interesting, but useless answers. I believe that much of the problem was due to the inability to add files or pictures to my postings. If I could have uploaded the log or export file that may have helped.
But my actual solution was finally found in GitHub (www.github.com/Renesas-rx/rx65n-envision-kit). Although not reference on the Renesas website, the GitHub directory was the compiled code for the initial demo firmware, which can be uploaded using the Renesas Flash Programmer.
To recover the original demo firmware including the secure bootloader we must go to www.github.com/Renesas-rx/rx65n-envision-kit. You will have to register and log into GitHub to download the files. Click [Clone or Download] drop down, then “Download ZIP” (rx65n-envision-kit-master.zip).
Unzip the file to the directory of your choice.
The content of the archive file includes the following directories/files:
NOTE: The e2Studio IDE builds your programs into a Motorola S-Record (.mot) file which can then be downloaded (launched) to the eval board through the IDE. This download is unsecured since there is no verification (protection) against downloading undesirable programs. This type of file is written directly to the board and does not use the secure bootloader. To add verification the .mot file is run through the Renesas Secure Flash Programmer converter, and uses the SHA1 hash type, to change the .mot file to .rsu. The converter.exe file is included in the “convert” sub-directory. It makes no sense to convert the secure bootloader firmware since it can only be used by itself.
As mentioned in the readme file, you will need to download and install the Renesas Flash Programmer from https://www.renesas.com/us/en/software/D4000848.html
Once install, you must plug your Envision board into a USB port and launch the programmer. To select the project (.rpj) file
Status Window –
Loading Project (..\rx65n-envision-kit-master\initial_firmware\01_chip_erase\chip_erase.rpj)
Target device: RX Group
Connecting the tool
Tool: E2 Lite (5&270D4E49&2&2), Interface: 2 wire UART
Emulator's supply power: OFF
Emulator's firmware version：3.01.00.001
Connecting to the target device
Main Clock: 16.000000MHz
Setting the target device
Communication speed: 1000000bps
Setting the target device
Erasing the selected blocks
[Data Flash 1] 0x00100000 - 0x00107FFF size : 32 K
[Code Flash 1] 0xFFE00000 - 0xFFFFFFFF size : 2.0 M
Erasing the selected blocks
[Config Area]
Disconnecting the tool
Operation completed.
Now the board coding is blank
To install the initial demo firmware, including the secure bootloader. Repeat the above steps for “rx65n_envisionkit_test.rpj” by navigating to .\rx65n-envision-kit-master\rx65n-envision-kit-master\initial_firmware\02_rx65n_envisionkit_test
Status Window –
Loading Project (..\rx65n-envision-kit-master\initial_firmware\02_rx65n_envisionkit_test\rx65n_envisionkit_test.rpj)
Loading File (..\rx65n-envision-kit-master\initial_firmware\02_rx65n_envisionkit_test\bin\rx65n_envisionkit_initial_firmware.mot) CRC-32 : 58700822
Target device: RX Group
Connecting the tool
Tool: E2 Lite (5&270D4E49&2&2), Interface: 2 wire UART
Emulator's supply power: OFF
Emulator's firmware version：3.01.00.001
Connecting to the target device
Main Clock: 16.000000MHz
Setting the target device
Communication speed: 1500000bps
Setting the target device
Erasing the selected blocks
[Data Flash 1] 0x00100000 - 0x00107FFF size: 32 K
[Code Flash 1] 0xFFE00000 - 0xFFFFFFFF size: 2.0 M
Writing data to the target device
[Code Flash 1] 0xFFE00000 - 0xFFFFFFFF size: 2.0 M
[Data Flash 1] 0x00100000 - 0x00107FFF size: 32 K
Writing data to the target device
[Config Area] 0xFE7F5D00 - 0xFE7F5D7F size: 128
Calculating device checksum
[Code Flash 1] 0xFFE00000 - 0xFFFFFFFF size: 2.0 M
Calculating device checksum
[Data Flash 1] 0x00100000 - 0x00107FFF size: 32 K
[32bit additive method]
Device Checksum 0x10459486 [Code Flash 1]
Device Checksum 0x007ECCA4 [Data Flash 1]
Disconnecting the tool
Operation completed.
The board has now been restored back to the initial out-of-the-box condition!!
LATE BREAKING NEWS ** LATE BREAKING NEWS ** LATE BREAKING NEWS
Literally moments ago, as I was reviewing the draft of my review, I tried something which allowed the program to compile. As it turns out, one of the steps I was using broke the build. The instructions I was using had me set the board I was using to EnvisionRX65N (V1.00), then click the generate code button.
“Under the rx65n_envision_kit_demo.scfg -> Board tab, select the EnvisionRX65N (V1.00) device from the drop down.”
…
..”Press the generate code button”
Well as it turns out, the Envision board is considered a custom board by the demo program. When I used the EnvisionRX65N (V1.00) device and generated the perspective the IDE stripped half the header files out of the make file.
If I skipped the board selection step the program built with no error and a few warnings.
NOTE: However there is a word of warning. If you chose the wrong board and generated the perspective you may have to re-import the code anew because once the IDE strips the header files out you will have to re-add them manually or start fresh.
But now I can try a few additional tests (after I submit my review) before my license runs out in 22 days.
LATE BREAKING NEWS ** LATE BREAKING NEWS ** LATE BREAKING NEWS
Part V – How Back To The Review
In the course of my search for how to undo my big oops, I discovered that not only was the firmware shipped with the board was functionally incomplete, but the “current” firmware found on the Renesas website was also functionally incomplete, not very helpful and not the most current. As mentioned earlier, the code for the initial firmware (Std: v0.90 & BM: v1.02) can be found in the compiled and source code forms on GitHub (www.github.com/Renesas-rx/rx65n-envision-kit), although there were still issues with trying to build the code. The Std:v1.0 & BM: v1.04 is available in a both source code and compiled versions at the Envision download site https://www.renesas.com/us/en/products/software-tools/boards-and-kits/eval-kits/rx65n-envision-kit.html#downloads. But the most complete versions (Std:v1.10 & v1.20 w/ BM:v1.04) is available through Segger’s website as part of their emWin demo example file (https://www.segger.com/downloads/emwin/RX65N_EnvisionKit). The latest benchmark demo version I could find was v1.04.
One would think that the higher the version was the later the build, but there is little commenting within the source code to verify this assumption. Since each version was located at different website, it is possible that different programmers made update the code. But there is some similarity that would lead to a common base. The following figures show the GUI differences between versions. Within some subprograms switches are added or changed as version progressed. An example of this can be seen within the bouncing ball demo that went from no switch (v0.9) to a 2D drawing engine switch (v1.0) to finally a GPU & FPU switch.
The following screenshots displays the various Standard demo menu pages.
v0.90/1.0 v1.1 v1.2
NOTE: The menus for v0.9 and v1.0 are the same and show no indication of versioning.
The following screenshots displays the various 2D Drawing Engine demo pages of Standard program.
v0.90 (2DDE: Not Operational) v1.00 (2DDE: on) v1.10 (2DDE: on)
v1.20 (2DDE: off) v1.20 (2DDE: on)
NOTE: The only detectable difference between versions v0.90 and v1.00 is the operational 2DDE switch in the later. The smoothness of the cloud motion and the hidden object is clearly noticeable. There is no detectable difference between versions v1.10 and v1.20 aside from the version number seen on the demo menu page. But for evaluation purposes the best new feature on the later versions is the frames per second (FPS) display. The FPS performance for have the 2DDE turned off versus on is 9 versus 65, or over a 700% improvement. The touch screen also seemed less jerky with the 2DDE on, however it was not unacceptable with the 2DDE turned off.
The following screenshots displays the various Bouncing Balls demo pages of Standard program.
v0.90 (No Switch) v1.00 (2DDE off) v1.00 (2DDE on)
v1.10/1.20 (GPU: off & FPU: off) v1.10/1.20 (GPU: off & FPU: on) v1.10/1.20 (GPU: on & FPU: off)
v1.10/1.20 (GPU: on & FPU: on)
NOTE: The v0.9 version did not have a way to activate (or deactivate) any RX65N feature, therefore it was impossible to detect any effect of the RX65N implementation. The second version, v1.00, added the 2DDE switch, along with additional balls, which helped differentiate the effect of the 2DDE. The balls seemed slower and less sharp with the 2DDE off. There is no detectable difference between versions v1.10 and v1.20 aside from the version number seen on the demo menu page, but there was quite a change in the screen between v1.00 and these versions. The 2DDE switch was replaced by 2 switches, one for the GPU and one for the FPU. I understand how the 2DDE is can be assisted by the FPU and GPU, but isn’t all graphical display demos effected. In the help message for v1.10/1.20, reference to the 2DDE has been removed and no mention of either the FPU or GPU was added.
But that aside, once again the benefit with the latter 2 versions is the frames per second (FPS) measurements. With both switches off, the FPS varies between 5 and 14, where with both switches on is very consistent at 65 or an improvement of 460 to 1300%. With both switches on the ball definition and movement is smoother. For the position of FPU:on and GPU:off the FPS was consistent at 21, but less sharpness of the balls. For the position of FPU:off and GPU:on the FPS varied between 12 and 40.
The following screenshots displays the various Mandelbrot demo pages of Standard program.
v0.90 (No Switch) v1.00 (FPU: off) v1.00 (FPU: on)
v1.10/1.20 (FPU: off) v1.10/1.20 (FPU: on)
NOTE: The v0.90 version did not have a way to activate (or deactivate) any RX65N feature, therefore it was impossible to detect any effect of the RX65N implementation. Version v1.00/1.10/1.20 added the FPU switch. There were no other detectable differences between the later versions. All versions had fairly smooth single touch zoom capability. It would be nice to update the demo to include double (or multiple) touch zoom. As might be expected the Mandelbrot calculations are very CPU intensive and therefore not too surprising when you are using the touch screen the calculating is paused or slowed. I also noticed that with the FPU off, if I ran my finger back and forth across the screen about a dozen times the board would take a few seconds to catch up. This did not occur with the FPU on. The demo has no direct indicator of performance, but a rough estimation shows the differences between generating and displaying a stable pattern with and without the FPU is approximately .5 and 9 seconds, respectively, or an 1800% improvement.
The following screenshots displays the various Bank Swap demo pages of Standard program.
v0.90 v1.00/1.20 v1.10
NOTE: All the versions seem similar with the singular goal is as a gateway interface to the Benchmark program. Those it is interesting that there is some issue with the firmware version reporting that is inconsistent. On later versions of the demo they also added the spinning arrows in the lower left corner. I'm assuming it is to show that the demo is still running.
The following screenshots displays the various Benchmark demo menu pages.
v1.02 v1.04
NOTE: Other than the version numbers there no detectable differences
The following screenshots displays the various Secure Update demo pages of Benchmark program.
v1.02 v1.04
NOTE: Aside from a few formatting differences the v1.02 and v1.04 no sufficient differences in functionality. The console window includes an informational header in v1.04 with additional verbiage. The window directly below the “Secure Update Demo” is not labeled and display different content between versions.
As mentioned earlier, there were no detectable differences between versions within the remaining Benchmark program pages.
Part V – Conclusion
As mentioned earlier the goal in my review is to evaluate the out-of-the-box experience with Renesas RX65N Envision Evaluation Kit. Was the documentation complete? Were the items included or readily available enough to evaluate the advertised features? Were code examples available? Was support available? Was support helpful? My answer too many of these question would be marginable at best.
I’ve worked with Renesas dev kit in the past and was surprised with all the issues I had with this one. The enhanced features of the RX65N make it a worthwhile choice for graphic intensive portable products. However, unless you have some experience with Renesas IDE, I would not like my boss to drop this off on my desk on Friday afternoon and ask to see a demo on Monday morning. It feels like an engineer designed this board then gave it to a summer intern to document, then left for vacation.
The graphic interface impressive, but I would like to see more up-to-date samples and applications. It would be useful to have the Ethernet components loaded with more details for secure firmware updating.
To beat a dead horse, the Eclipse-based e2Studio is a very versatile IDE, but more time should be placed of verifying the demo source code and instructions. I good example of the demo software code in the Segger source download file. The instructive video by Renesas application engineer Gerald O’Docharty (see Useful Document section) was also very helpful and recommended viewing.
What I didn’t try
Because I ran into so many problems early in my evaluation I did not get to explore all the little extras surrounding secure firmware swapping, but maybe in the future.
What’s next?
I would like to continue to troubleshoot these issues, as well as dive a little deeper into the GUI building using Segger’s emWin libraries, as well as the dual memory bank swapping for firmware updating. I will post updates as time permits. My only issue is the limited remaining time on the compiler license.
Please let me know if I missed something in the documentation. Also please pardon my typos.
Gordon Margulieux
Meridian, ID USA
Top Comments
Clem,
Thank you for your comments. If you have worked with dev/eval kits for any length of time, you will eventually run into some frustrating ones. I can’t believe anyone would produce something that would…
I liked to read the review. Our experiences and opinions at the end of the trip are different and that makes it more interesting.
I like the way you put it: I was working out how to articulate this the right way but I agree, we did have different experiences. I would concur with Gordon that for a real beginner, this isn't the kit…