RoadTest: Maxim MAX32650-EVKIT
Author: 14rhb
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?: Please see end of this review for comments
What were the biggest problems encountered?: I didn't seem to be able to find much guidance on using the libraries or explaination of the example software.
Detailed Review:
Roadtesting the Maxim Integrated Max32650 EVKIT by 14rhb
I was the fifth roadtester chosen to review the Maxim Integrated MAX32650 EVKIT for the Element14 community. I would describe myself as a keen hobbyist 'embedded software/hardware engineer' and have only recently got to experiment with ARM based boards following a couple of roadtests for Element14. Until then I knew very little about ARM microcontrollers and what special features they included.
These previous roadtests have given be a desire to know more and have also helped expand my understanding. Although I'm probably still in the keen hobbyist/novice group I am able to understand the basic steps to getting such a board up and running, at least to any demo software cycle or install and run.
My road-test aim is to explain to the Element14 community what this board is capable of in a fun and interesting way and to detail how easy I found that journey as a relative novice. I had planned to write a series of blogs concentrating on individual parts of this journey, culminating in a simple project using the boards and then to follow up with a summary in the road-test review format. However as I started to get this board running I thought to myself that I'd only be repeating what can be seen in the specifications anyway. More importantly it made me think about why the roadtest is important to both E14 and Maxim: if I were working at an embedded design firm using Maxim products already then I'd likely be prepared and have good knowledge of the MAX32650 already. If an embedded company used other products they would likely stick with those. My mind was then draw to those with less knowledge: they would perhaps like an interesting brief on this product, so I decided I needed to make it fun.
Summing all that up I have decided to give a slightly reduced overview of the processor and board and then concentrate on actually making a small fun project - hopefully that will interest E14, appeal to the sponsor Maxim Integrated and the Roadtest scheme manager Randall.....but what that project would be I had not decided.
The MAX32650 is an ARM based Microcontroller, the ARM Cortex-M4 from the range of available ARM devices. Up until about a year ago I wasn't too familiar with what an ARM device was and so I expanded that out in the following article: ST32L4R9I-DISCO: Part 2 (About the board) To summarise that, the ARM company designs Intellectual Property (IP) of microcontroller cores. Some manufacturers license that IP and utilise it in their own IC designs pulling in the ARM IP and linking to their other IC peripherals to make their own device. Some manufacturers stick to their own designs and don't use ARM IP at all - for example the PIC range from Microchip. The Cortex-M4 sits towards the upper end of the Cortex family of devices in terms of performance as can be seen below:
There are many device manufacturers and each produces a large array of different devices, so what makes this stand out i.e. what are the top selling points? From the Maxim website I've edited slightly and reproduced the internal schematic of the MAX32650 MCU. ( I much prefer a nice simple graphic and a few words when trying to understand anything new ).
These are the features and peripherals that Maxim Integrated have combined with the ARM Cortex-M4 IP block to produce their MAX32650 device. Things that stand out when I glance at this are the multiple clock frequencies; this range reflects the ability of this MCU to slow itself down. That is important as a slow clock also uses less power and therefore if the MCU can adjust this it can become more efficient. In extremis when powered down the clock will be able to drop very low, which appears to be 8kHz, and that would be enough to update the Real Time Clock (RTC) and also service a wake up call on interrupts. It is this ability that allows this MCU to be touted as ideal for battery operations.
The LCD controller is also inbuilt to the MCU allowing it to be optimised and therefore have minimal computational loading on the MCU.
Also note the Floating Point Unit (FPU), Real Time Clock (RTC), Direct Memory Access (DMA) controller, internal RAM, cache,Flash space and multiple common bus standards such as UART, I2S and SPI. The DMA needs a second mention as it is also SmartDMA capable that means it can service external memory blocks whilst the MCU is powered into a sleep state (and hence low power) - in practise that would allow the MCU to come back up to full processing speed without having to reload programs.
Although theMAX32650 EVKIT board measures 140mm wide by 152 mm there is surprisingly little component count topside and almost nothing on the underside: I make that comment in a good way though as it is easy to now see how this EVAL kit is meant to help the developer concentrate on the MAX32650 MCU and it's niche features. Admittedly if I wish to make a project to show off the MAX32650's capabilities then I am either going to have to use the limited peripherals or breakout one of the connectors to another sensor.
The basic board components and features for both side are shown below:
| {gallery} My Gallery Title |
|---|
MAX32650 Board Front
|
MAX32650 Board Rear
|
Having read the short-form instructions supplied in the kit I connected the USB from my laptop to the MAX32650 USB/UART connector CN2 and the board powered up. The LCD displayed the Maxim Integrated logo and the user LEDs LED0 and LED1 toggled in illumination between red and green. This was not perhaps the most complex of in-built demos I have seen on an embedded board, but the display looks crisp and this demo proves that the board is indeed working. There's not a lot extra I can add to this section but successful power up is always a good step for any roadtest.
From previous plans I had decided early on to try and use System Workbench again. It is free and runs under the Eclipse IDE. Therefore the first thing I did was to update my already installed version of Eclipse.
I read through the paperwork supplied with the board and browsed the given support link for starting, only to get this:
After some browsing around I found a download on the Maxim Integrated website for the board. This needed an extra step of creating a Maxim Integrated account, but that was fairly straightforward:
Once downloaded I installed that software:
 |
 |
On my Windows 10 laptop this resulted in a start menu entry with various Maxim EVKIT board datasheets and a start command for Eclipse. Only when I'm writing up this roadtest report that a recent post in Happy Valentines Day! - What do you Love / Hate about Electronics? by koudelad enlightened me that some manufacturers install a separate and pre-configured version of Eclipse to support their board or device. For now this isn't an issue as it should mean that the installed version works well, however it could be confusing perhaps when it comes to maintaining and updating software.
It was after watching the informative Maxim videos for this product and opening the CLCD demo code for inspection that I started to re-think how I'd do my roadtest project. In 'claiming' the CLCD program to be mine (as in I make changes to the code to prove I can complete the development cycle and program the board) I ended up making a bitmap image of my own. What I did was study the CLCD example and soon realised there was no higher level GUI functions, or perhaps I missed them. I'm aware there are actually third party graphical packages for embedded engineers but I always found them to be constrained by time-limitations or supported niche board/devices. As a hobbyist approach investing money in one of those packages is not a reality and whilst some are free I also don't like finding they are great only to have them stop working some months later; I prefer open source or completely free vendor supported software. After watching those Maxim videos I was enthused to try and make something using my own function library and the RAM buffers....it was almost like going back a few decades !
Manually adjusting strings of numbers to look up in the colour palette would be almost impossible so I decided to explore bitmaps further. I ended up creating simple images under Microsoft Paint that could be saved as 256 value bitmap images - the Maxim Logo is a 280 x 81 pixel image. I'd then need to convert my bitmap file to the text required to paste into my C program under Eclipse. To do this I wrote a program using Microsoft Visual C#. This allows the user to select an appropriate bitmap and creates a text file of the numbers and separately the colour palette values to use. Copying and pasting into the Eclipse C code is then fairly straight forward (although I did inadvertently create a final comma that I had to constantly delete).
With a little experimentation I created these scenes:
| {gallery} My Gallery Title |
|---|
 |
The image was reduced in colours from 16-bit to 256 and became blocky, the MAX32650 board would have displayed it nicer if I hadn't compressed the colours. |
And from that first image with clouds I decided what my application would be. The Max32650-EVKIT has two user buttons and although I could expand out from one of the many ports available on the board I decided to keep to that two-button constraint for my game. I'm old enough to recall simple games on the ZX80 that only had left and right controls. My take on that is a simple game that allows the user to try and control the wind direction to keep the forming and changing clouds above or away from certain things. The player would gain points for their ability to keep the rain and sunshine on certain areas and off others. I decided on the following areas for the ground:
I'm not going to be too ambitious with the rules as they could be expanded out in time. The point will be to make this game on the MAX32650 to show off the processing power of an M4-Cortex whilst also exploring the power save modes.
Probably a very silly name but it gives me something to display on the splash screen. The coloured rectangles were added as I had a lot of trouble getting my C# code to process multiple bitmaps whilst also maintaining a single master colour palette file. I've left these test colours in as I know as soon as I removed them I would likely want them back again.
After a few separate images I started to understand how the bitmap worked and that as coded I needed one master colour palette. I therefore modified my Visual C# code to archive that, reading in multiple bitmaps and passing out their own file for inclusion into the Maxim C code but with a single master palette of values. This actually took a long time to perfect as I repeatedly got incorrect colours appearing until I finally tracked down a small error in my C# that enabled multiple bitmap colours to get repeated. Soon I was on track again and back to making those sprites move around as I intended to make Rain-Brain work.
The list of sprites grew and I was glad I had invested time in writing the C# application to manipulate and generate source code for copying and pasting across. The final list of sprites is shown below with a short excerpt from the processing log:
Bitmap Width: 125 Bitmap Height: 63 Sum pixels: 7875 Bytes written: 7875 Colour range: 122 Finished C:\MAX32650EVKIT\BeachFun2.bmp New colour found BGR @122::0x00C0E0 Bitmap Width: 125 Bitmap Height: 63 Sum pixels: 7875 Bytes written: 7875 Colour range: 123 Finished C:\MAX32650EVKIT\BeachFun3.bmp New colour found BGR @123::0x802020 New colour found BGR @124::0x802000 New colour found BGR @125::0x400000 New colour found BGR @126::0x800000 Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 127 Finished C:\MAX32650EVKIT\Num0.bmp New colour found BGR @127::0x80A080 Bitmap Width: 16 Bitmap Height: 17 Sum pixels: 272 Bytes written: 272 Colour range: 128 Finished C:\MAX32650EVKIT\Num1.bmp New colour found BGR @128::0x004020 New colour found BGR @129::0xC06000 Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 130 Finished C:\MAX32650EVKIT\Num2.bmp New colour found BGR @130::0xC06020 Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 131 Finished C:\MAX32650EVKIT\Num3.bmp Bitmap Width: 16 Bitmap Height: 16 Sum pixels: 256 Bytes written: 256 Colour range: 131 Finished C:\MAX32650EVKIT\Num4.bmp New colour found BGR @131::0xC0A0A0 Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 132 Finished C:\MAX32650EVKIT\Num5.bmp Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 132 Finished C:\MAX32650EVKIT\Num6.bmp Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 132 Finished C:\MAX32650EVKIT\Num7.bmp Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 132 Finished C:\MAX32650EVKIT\Num8.bmp Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 132 Finished C:\MAX32650EVKIT\Num9.bmp Bitmap Width: 15 Bitmap Height: 16 Sum pixels: 240 Bytes written: 240 Colour range: 132 Finished C:\MAX32650EVKIT\NumBlank.bmp Finished ALL.
Constructing the game required careful placement of the sprites and for that I made good use of the #define command in C to keep all the adjustments easy to access (rather than loosing these important adjustments in the main C code). I added variables to monitor the success or failure of rain and sunshine on the various areas of the background and with some tweaking I was able to create my game. Without a high level graphical or game engine it is quite difficult but also quite rewarding in terms of brushing up on C programming. I added code to randomly change the cloud formations whilst also remembering what had just gone off screen in case the wind direction changed and it came back into view. Other areas of fun were the beach becoming lively, the reservoir filling or draining and the crops growing.
I also made use of the UART to output data to help me debug the game's operation:
The final step was how to display the user's score to the screen rather than the UART. I decided I'd need the entire number set as some more sprites and so created them in paint, added them to my VS C# code (at the end of the list to help preserve the existing colour palette) and loaded them up into a new header file. Converting the integer value to a string and inspecting each element allowed me to stitch the number sprites together to create the user score on screen.
I guess I should also better post a short video of the game running....
I had a look around Farnell UK for similar ARM based development boards for a similar cost (based on current MAX32650 EVKIT ~£118 UK) and found this possible contender:
| Board | Picture | Features | Cost (UK Pounds Feb 2020) |
|---|---|---|---|
| STM32L476G-EVAL |  |
| £220 |
The game could of course be much better, but it is actually playable and IMO fun! With inclusion of graphics libraries much better visual solutions can be created so don't think this simple project is all the MAX32650 board can do, far from it, as for a starter it could be loaded up with the RTOS. The ARM Cortex-M4 is a very powerful unit and when coupled with the other Maxim peripherals has created a compact and low power device.
I've stated that I'm quite novice at ARM based boards but I have had a go at programming a few other manufacturer's development boards. In comparison I have found this Maxim Integrated board to seem quite sparse in peripherals and board level capability as it stands....but that in my opinion makes it stand out. It is actually easier to learn on as there are not layers of abstraction and function calls which cannot be understood. A business that undertakes embedded design would obvious leap miles ahead of me on this and would likely have invested in commercial GUI software libraries or created their own game engines anyway.
There is far more to explore on this capable board such as the low power functions and peripheral connectivity. Although the Maxim website started with five great introductory videos I didn't manage to discover much other supportive documentation. Determining what the board examples achieved wasn't obvious to me nor what libraries I would be able to pull in and how their functions could be included...maybe I just missed something, but that IMO is what a roadtest is all about. If I can't see it then perhaps other possible users won't either. Hopefully the Maxim team will find such comments constructive and they are more then welcome to contact me if they need any clarification of this.
My marking may seem harsh when compared to other similar roadtests and so perhaps needs some constructive explanation of the numbers:
| Criteria | Score | Reasoning |
|---|---|---|
| Product Performed to Expectation | 9 | It was a capable ARM Cortex M4 based board, and I had no issues with it technically. |
| Specifications were sufficient to design with | 9 | Again, no issues reading the technical specification. Datasheets are very good quality. |
| Demo Software was of good quality | 7 | I mark the demo software being the main shipped demo and the other examples. The main shipped demo was very limited and not particularly eyecatching. |
| Product was easy to use | 9 | The software and driver install was seamless for me, slightly lower due to lack of 'getting started' tutorials after that. |
| Support materials were available | 6 | The videos were great but support seemed to stop at that point, or at least I failed to find it from the main device page. |
| The price to performance ratio was good | 8 | I have purchased similar boards with LCD for less than this, although perhaps they may have been marketed as a 'loss leader' This rating would have been lower but the inclusion of the Olimex JTAG programmer pulled the marks up. |
In summary I found the MAX32650 EVKIT: a great, powerful and easy to understand, uncluttered board, aimed to allow the MAX32650 to be explored quickly. It is probably not the easiest board for a novice to learn on due to the lack of supportive training material, however the simplistic and uncluttered nature of the board counters that somewhat.
A special thank you to Maxim Integrated for kindly sponsoring this equipment test through Element14 Community and, as always, thank you to rscasny for running this roadtest and selecting me from all the other worthy applicants. I'm looking forward to reading the other roadtesters' comments in a few weeks and seeing what I inadvertently missed out on - I suspect there is a great big chunk of material I just didn't spot! Also thank you to jancumps for helpful comments on the Maxim MAX32650-EVKIT roadtest page which have enabled me to run my own code with just a simple USB power connection to the MAX32650 EVKIT board.
I've found this project and roadtest a great amount of fun whilst also learning some extras about the ARM development cycle and getting confidence in driving my own project along. My next steps? I think I'm going to have to try and improve on "Brain Rain" on the Maxim Integrated MAX32650 board, I'm kind of hooked on improving this little game now !
Edit Log:
22nd Feb 2020: Minor edits of grammar and spelling
Top Comments
Dear 14rhb,
I presented my views regarding your evaluation. Because , you Basys board review is now a Reference for any new beginner.
Now , you focus more on general functionality. Each Microcontroller…
Nice Review of the hardware, the animations for the game are implemented nicely, Moreover that weird water-tank that filled and emptied upon itself, created real creepy effect, required for the game and…
Great review (and I like the game). Your observations on the training, documentation and getting started are appreciated as I count myself as being enthusiast level and definitely not professional. It…