Renesas RX65N MCU EV Kit - Review

Table of contents

RoadTest: Renesas RX65N MCU EV Kit

Author: Jan Cumps

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?: other microcontrollers with LCD driver peripheral

What were the biggest problems encountered?: Some software libraries unnecessary tied to manufacturer's toolchain. Most optional components on the valuation board are not for sale. Some pins with unique functions (e.g. DAC) used for on-board switches, not broken out.

Detailed Review:

TL;DR: I think this is a good microcontroller and a good evaluation kit for screen-to-machine designs..

highlight: some 150 example programs and application notes available.



source: road test in action - control the LCD


Evaluation Kit


This section discusses the Envision kit in total. Does it achieve it's stated goals?


The Envision kit is positioned as an instrument to the RX65N family as user interface controller for trusted environments.

The front side is fully covered by an LCD touch screen. The out-of-box examples show the graphical capabilities and the capability to validate software uploads before accepting them.

The controller has enough calculation power, data transfer speed and memory to give a smooth user interface experience. When using the kit's 480 * 242 display with touch screen, all actions feel real-time.

The demo actually does a good job showing that off. It shows a button-based GUI and animation capabilities at a glance.

If you dig a little deeper, you can also test the secure bootloader and some USB benchmarks. Sources and documentation then explain how to safely swap firmware and validate signatures.



source: road test in action - test pattern for the LCD


Next to that, the evaluation board also has a number of user-configurable options. There's a set of headers that aren't populated by default and some components that are left off by default but can be fitted in.

The popular Arduino connector is used to break out many of the controller signals. Where possible, the pin use  resembles that of an Arduino UNO. A good way to allow reviewers to use commonly available hardware.

Other free pins are broken out to an additional set of pin headers. You have access to most RX65N pins.

I would have liked that the 2 DAC signals (something that's not that common in controllers of this class) were broken out to a header. In this kit, they are used for the user switch and unpopulated joystick.



source: road test in action - gpio test


The LCD sits perfectly flush on the front side of the PCB. When you place the optional through-hole headers, the thickness of the solder joints prevents that the LCD can be placed back where it belongs.

Demmel-grind the through-hole pins and joints away as low as you can to the PCB to enable the LCD display to fit on the board again.

It's doable with a steady hand and proper care. I'd have prefered SMD header footprints for this board.



source: road test in action - prepare the board for power safe mode currents measurement


The selection of some other optional parts is at times unfortunate.

As indicated by and someone on the Renesas RX65 forum, the majority of these components (SD Card connector, Ethernet connector, Joystick and some ICs) are either hard to get or obsolete.

For no obvious good reason. There are long-standing common components around for these.


Power to the board is delivered via USB. The same connector is used for debug, UART and power.

You are able to send specific log messages over the USB while debugging, but the USB port is not available as a serial port while it's used as a debugger.

If that's needed (say you want to debug a program with serial communications), you can either use an external debugger or connect a logic-level-to-USB-translator to one of the other serial ports.

The debugger supports the expected functionality: load the firmware and let you step, view, explore.

What's particularly well designed in the power part, is that you can fully isolate all current going to the microcontroller from it's surrounding. Very useful if you want to measure the IC's consumption in the power save modes.

This is done with good care, implemented simple and easy to use.


The overall quality of PCB, solder joints and components is good. The manufacturing is well executed. Full schematic and BOM are available.



source: road test in action - partly customised board. I added a breakout point for DAC later


Development Tools


Here I review the software and support options



Renesas offers the e2 studio IDE. It's Eclipse based, with Renesas specific add-ins.

The Eclipse integration is well done. This feels like your typical installation with the usual build and debug cycles. At certain points, when Renesas specific technology is used,it's well integrated.

There are Project Create wizards that help you to select the right setup for the controller.


Hardware Abstraction Layer and APIs

Once a project is set up, Renesas has "FIT modules", blocks of drivers and libraries, that you can use both as set up tool for the peripherals and as API generator.

The Hardware Abstraction Layer for the RX65N modules are implemented as such blocks. There's a graphical configuration tool named Smart Configurator that lets you select the blocks, configure them, assign pins and generate code.



source: road test in action - Smart Configurator


If you follow their Smart Configurator methodology as a good citizen, the mechanism supports iterative changes: you can add logic to the generated code and keep on using the Smart Configurator to add/modify blocks and regenerate the HAL layer.

The configurator supports board definition descriptions. If you have a description for your design (Renesas has one available for this kit), the functions of the microcontroller pins, the clock frequency and some other settings adapt to those definitions.



source: road test in action - add FIT modules to a project


C toolchains

There are two toolchains from Renesas CC-RX and GCC for Renesas.

Both can be selected when installing the IDE. I've never used a Renesas toolchain before so the commands used aren't faimiliar to me. The IDE and wizards help to make the learning curve smooth.

Creating a GCC or CC-RX project is almost identical. Settings are sometimes o a different property sheet but some click-and-seek helps.

Most of the FIT module documents show the code size, data size and number of CPU ticks used for each of the toolchains (and for iAR).



source: road test in action - the toolchain wizards


A watch-out if you're reviewing the kit is, that the CC-RX chain requires a license. It's free evaluation for 60  days. Then the code size is restricted.

The price per seat is fair. I wish they had a permanent non-commercial license though - to allow reviewers to keep talking about all aspects after 60 days.

The GCC toolchain does not have any restrictions or costs. You can use it for the majority of the work. You can't use Renesas' USB/FAT and SHA FIT modules with it though.

These are partly distributed as binary libraries in a CC-RX format that can't be linked in  GCC programs.

As long as you have a RX65N model without hardware SHA accelerator (like the one in this kit), you can use non-Renesas libraries for FAT and SHA.


With the Envision kit, you also get access to Segger's emWin GUI toolkit. This is a set of libraries , controls  layout tools and format converters that let you build a GUI for the LCD.

You can visually build your screen, then generate C code from that. The tool works fairly intuitive and the controls are nice and clear.



I've used the support forum a few times, to ask questions or raise a bug report. It's not very busy but the answers are polite and to the point.


Examples and Documentation


An overview of the documents and sources available for controller and kit


This family has the largest set of examples and application notes I've ever seen for a microcontroller. There are more than 150 downloads.

Most of these are a combination of an application note and example project(s). Organised per peripheral, sometimes grouped into a larger functional example.

The demo programs give a good feel for the capabilities of the controller - most of them are fully functional and come with an application note that describes the peripherals and the example's logic.



source: Renesas application note for the SHA FIT module


They aren't easy reads though. Renesas' documents are void of any pleasant narrative. Dry facts, theory of operation and resources consumed are presented each time. Engineer targeted, very complete, yet hard to read.

You can download the examples from Renesas website. If you need an example while working on a project, you can right-click on a FIT module and retrieve examples specific for that module.


I've used 18 of the examples in my roadtest, reviewing, UART, CAN, power modes, LCD, DMA, ADC, DAC, RTOS, security/secure boot, USB file access, gpio and timers.

They are all well written and (depen ding on the complexity of the subject) easy to follow and reuse.

I learned some flaws in the IDE/FIT mechanism while validating them too:

The examples were sometimes made for another evaluation kit. That's ok, but if Renesas would have used their own Board Description concept, porting would have been a matter of selecting the right kit.

Changing from the RX65x controller used in the example to the one on the board sometimes breaks the build in cryptic ways. When that happened I had to start over.

FIT modules are not always backward compatible and examples don't use the latest. If you want to play (change, reconfigure, extend) with the examples, you have to update them to the version you have. That's a  process that tends to break - making you figure out what's broken instead of learning the module.


I like the concept of having at least one project per peripheral. It helps to get you going with the controller. If you have worked with another device with a similar module before, the learning curve is often short.

But if you have time, spend some deep learning in the out-of-box demo. It's available as source code.

If you understand the secure boot loader and the two applications that can be loaded with it, their sign-and-verify process and how the whole thing fits together, you master a large part of the RX65N.

Do this within the first 60 days that you have the kit. You will not be able to build and step through it when your CC-RX license expired.



RX65N Family


The controller and its family


The majority of controllers I reviewed lately were all ARM based designs. Not his one. The RX65N is a 32-bit CISC core with Harvard architecture.

The Renesas RX is a big family. The available umph, memory, peripherals, security and safety provisioning are dependent of the target design.

The overview below suggests where this family can be used, and what functions can be handled in the applications.


image source Renesas RX Family overview flyer


The RX65N on the kit has 640KB ram, 2MB code flash (can hold two firmware programs/version in flash at a time), 32 KB data flash and clocks up to 120 MHz.



source: road test in action - graphical view of a GCC linker/loader script


t doesn't have encryption hardware. I found no evaluation kit for this family that has a controller with their security hardware in silicon. Maybe that's an export regulatory thing?

The peripherals that stand out are CAN, Quad-SPI and DAC.  The LCD module supports hardware-built-in 2D drawing functions.

I haven't looked at the parallel data capture module yet, a block that helps synchronising parallel fetching/syncing. On the yet to-do list.


There are four power-save modes that I've tested out - each with their own wake-up speed and wake-up triggers. The board design has a dedicated spot where you can measure the RX65N's consumption in isolation.

Getting the controller in and out of sleep modes is straightforward. There are examples for each of the possibilities.



source: road test in action - log low power mode energy profile


Real Road Test


The real road test, digging into the kit, the controller, the modules and the software, is done in a series of blog posts here on element14.

You can find the list of tests below. Many of them have the e2 studio project attached.

I'd like to thank fellow tester . We were reviewing different aspects of the same thing several times and his support was a big help.



Related blog
part 1: Create an Empty Project
part 2a: Blinky with GCC Toolchain
part 2b: Blinky with Timer and Interrupt
part 3: Port an example from Renesas toolchain to GCC
part 4a: Low Power - Sleep
part 4b: Low Power - Software Standby
4c todo: power mode 3
4d todo: power mode 4
part 5: DAC
part 6: Software SHA
part 7: Blinky with FreeRTOS
part 8: DMA
part 9: UART
part 10: Reserve LCD Frame Buffer in Expansion RAM with GCC
part 11: port emWIN to GCC and run an LCD Widget
Renesas RX65N MCU EV Kit - Review
Andrew Johnson's blog series
Renesas Envision Kit RPBRX65N Roadtest