Implement basic platform support for NXP Kinetis KE02 MCUs (Cortex M0+)

[forGGe]

Task is to integrate theCore with KE02 MCUs

Refs:

• FRDM-KE02Z Kinetis Development Platofrm
• Kinetis run-time SW
• OpenOCD guide

Must include

• JSON-based configurator
• Documentation page with available periphery
• At least one example
• BAT test suite

[forGGe]

Working branch for this issue : https://github.com/forGGe/theCore/tree/g230_kinetis_ke02_exp_support

[iia]

Hi there,

I'm interested to work on this issue. So what is the current state of KE02 support ?

[forGGe]

Hi @iia ,

Currently we have the g230_kinetis_ke02_exp_support branch that pretty outdated and should be refreshed.

If you would like to contribute to this issue, I can guide you with steps required to bring KE02 alive and assist in development.

If you want me to implement KE02 support, I can rearrange priorities and complete the task.

Let me know what you think.

[iia]

Hi @forGGe ,

I'm interested in contributing to this issue. So it would be great if you can provide with some assistance. To be more precise an overview of the project, the main parts and how they relate and connect among themselves. And of course what is involved to add support for new platforms.

[forGGe]

Hi @iia,

I really appreciate your interest in contributing!

Below is an overview you requested.

Overview

theCore tries to provide a framework that consistent enough to make portable applications for different kinds of microcontrollers. "Portable" means that you just write your application code once and then compile it for every compatible device.

For example, an application code for reading humidity sensor and writing samples to the MicroSD card will be the same, no matter where you attached MicroSD card and humidity sensor - to STM32F4 or to TI TM4C microcontroller. In a some way, theCore looks like HAL-on-steroids.

(Besides just providing consistent APIs, theCore aims to be a full-featured framework, see Roadmap for more information)

Project main parts

To achieve that goal theCore provides different kinds of modules:

• architecture modules - placed under arch directory. The goal of architecture module is to provide the early startup and initialization code, shared by different microcontrollers. This is where your program starts. Architecture module then passes execution to the platform module, described below.

• platform modules - most important and hard part. Placed under platform directory. Goal of specific platform module is to initialize MCU (clock, watchdog, etc.) and give a user (and theCore) similar APIs for every supported periphery - UART, SPI, etc.

• device modules - external device drivers, placed under dev directory. Those modules provides support for things that are usually attached to MCU: LCDs, audio codecs, sensors, etc.

• lib modules - various libraries, placed under lib directory such as memory allocators, vendor-specific libs, FATFS and other stuff that does not fall in any of previous categories.

• kernel modules - RTOS-related modules, placed under kernel directory. Only FreeRTOS is really supported for now.

• system module - placed under sys directory - it is just a little part of theCore code that initializes theCore itself. There you will find runtime constructor calls and console greetings.

Project configuration

Besides just providing classes to access different devices or MCU peripheries, often it is required to additionally specify how those modules interacts with each other (say, you have attached LCD to MCU) or you need to configure specific module parameters (baud rate of UART console).

theCore gives you an option to specify that details in a JSON configuration file, rather than write C/C++ code that initializes each module in question in a required way (writing C/C++ code can be tedious and error-prone).

Part of theCore, responsible for such configuration is basically called the configurator.

Good example is TI TM4C configuration for LED demo. Path to that configuration file then passed to theCore in main project file

Essentially, theCore configurator is just a code-generation tool, which takes a JSON file and produces corresponding C/C++ definitions that you can use inside your application code

See the filesystem module example that shows how incoming JSON converted into the C/C++ code. Configurator is written using Python Cog utility. The aforementioned file system, Cog-based configurator can be found here.

Configuration based on JSON is somewhat described in the respective documentation page.

Generated code is available if to include ecl/core_generated.hpp header.

Buildsystem

Not much to say here, CMake is used everywhere. Where it cannot handle things like code generation, Python is used.

Module interaction

arch and platform are the only modules that interact directly. Arch module calls theCore main routine, theCore main routine then calls platform initialization code and user's main

All other modules sit aside and wait until they will be used by the configurator tool.

You will get more insights about specific modules while hacking KE02 platform.

[forGGe]

I will take an action of refreshing the g230_kinetis_ke02_exp_support branch and will send you more instructions about platform creation soon.

Let me know what you think about it.

[iia]

Hi @forGGe ,

Thanks for the detailed overview. I'm ordering a KE02 dev board. Let me know after you have refreshed the branch.

[forGGe]

Just for reference:
The OpenSDA support, included by default in the KE02 MCU makes debugging really painful.

See also: https://www.eevblog.com/forum/microcontrollers/freescale-opensda-linux/

Right now, I'm debugging my fresh, new KE02 dev board by just uploading binaries via the virtual mass-storage that appears after I connect the board.

So, I will try to upload correct J-Link compatible MCU firmware, found at these pages:
https://www.segger.com/downloads/jlink#JLinkOpenSDABoardSpecificFirmwares
https://www.segger.com/products/debug-probes/j-link/models/other-j-links/opensda-sda-v2/

And I hope my board will stay functional :)

[iia]

Hi @forGGe,

From where you ordered your board?

[forGGe]

From where you ordered your board?

Aliexpress, but I can't find it there anymore. I'll try to check other suppliers.

[forGGe]

@iia, branch g230_kinetis_ke02_exp_support is updated.

Here is instructions of how to run simple demo on your KE02 dev board:

1. install JLink on your host system (it is not yet shipped with Nix)

2. download theCore

3. install Nix: https://forgge.github.io/theCore/guides/getting-started.html#using-nix

4. cd to theCore directory

5. enter Nix shell:
   nix-shell .

6. create build dir:
   mkdir ke02_build && cd ke02_build

7. build a project:

   cmake ../examples/ke02_hello -DCMAKE_BUILD_TYPE=Debug  -DCMAKE_TOOLCHAIN_FILE=../toolchains/arm-cm0-plus-gnu.cmake 
   make 
   

8. flash image w/ help of JLink.

   Using GDB:

    # Run JLinkGDB server
   JLinkGDBServerCLExe -device MKE02Z64xxx2 -endian little -if SWD
   
   # Run GDB in another console
   arm-none-eabi-gdb ./ke02_hello -x ../scripts/ke02_jlink.gdbinit
   
   # Flash image
   (gdb) taget_load
   Loading section .text, size 0x1958 lma 0x0
   Loading section .data, size 0x14 lma 0x1958
   Start address 0x58c, load size 6508
   Transfer rate: 52064 bits in <1 sec, 2169 bytes/write.
   Resetting target (Type = 6)
   Writing register (SP = 0x20000C00)
   Writing register (PC = 0x0000058D)
   # Run image
   (gdb) c
   

   Using JLink itself:

   # Run JLink
   JLinkExe  -device MKE02Z64xxx2 -if SWD -Autoconnect 1 -Speed 1000
   
   # Sub-shell will be opened
   
   # Download image
   J-Link>loadbin ke02_hello.bin 0
   loadbin ke02_hello.bin 0
   Halting CPU for downloading file.
   Downloading file [ke02_hello.bin]...
   Comparing flash   [100%] Done.
   Verifying flash   [100%] Done.
   O.K.
   
   # Restart and go
   J-Link>r 6
   J-Link>g
   

[forGGe]

Also, check https://octopart.com/frdm-ke02z-nxp+semiconductors-70303061?r=sp&s=oR9dcxYPTvqj5TI7Sgx1Ug for list of available suppliers

[iia]

@forGGe,

Thanks for all the info. I got the board today and everything worked and I could execute ke02_hello.bin. Since now I have a working setup I can take a better look on the whole system.
BTW as much as I could figure out for today you are using the driver lib for KExx series which is posted here in the build system right?