Skip navigation
> RoadTest Reviews

Maxim MAX32650-EVKIT - Review

Scoring

Product Performed to Expectations: 9
Specifications were sufficient to design with: 9
Demo Software was of good quality: 7
Product was easy to use: 9
Support materials were available: 6
The price to performance ratio was good: 8
TotalScore: 48 / 60
  • RoadTest: Maxim MAX32650-EVKIT
  • Buy Now
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes
  • Comparable Products/Other parts you considered: 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

     

    1.    Introduction

    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.

     

    2.    Overview of the MAX32650 MCU

     

    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.

     

    3.    Overview of the MAX32650-EVKIT board

    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

    4.    Power Up

    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.

     

    5.    Software Install

    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.

     

     

    6.    A Project Idea Journey

    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:

     

    • A beach - requires clear sky, cloudy and people start to leave and if it rains then their is a negative effect on the user score.
    • A reservoir - needs to be kept topped up to generate electricity and water crops.
    • A crop field - needs sun and rain periods, too much sun isn't good, too much rain isn't good.

     

    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.

     

    7.    Making of "Brain-Rain"

    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....

     

    8.    Similar Boards

    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:

     

    BoardPictureFeaturesCost (UK Pounds Feb 2020)
    STM32L476G-EVAL
    • ARM Cortex-M4
    • Two MEMS digital microphones
    • Two independent audio headphone jacks
    • Micro SD Card Slot
    • IrDA
    • Joystick
    • Includes 4GByte uSD Card
    • 16MBit SRAM
    • 128MBit NOR FLASH
    • 256 MBit Quad-SPI FLASH
    • Potentiometer
    • Coin Cell battery backup
    • 40x8 LCD Display
    • 320 x 240 LCD Panel
    £220

     

     

    9.    My Summary of the MAX32650-EVKIT

    9.1    Summary Thoughts

    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.

     

    9.2    My Marking of the MAX32650

    My marking may seem harsh when compared to other similar roadtests and so perhaps needs some constructive explanation of the numbers:

     

    CriteriaScoreReasoning
    Product Performed to Expectation9It was a capable ARM Cortex M4 based board, and I had no issues with it technically.
    Specifications were sufficient to design with9Again, no issues reading the technical specification. Datasheets are very good quality.
    Demo Software was of good quality7I 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 use9The software and driver install was seamless for me, slightly lower due to lack of 'getting started' tutorials after that.
    Support materials were available6The 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 good8

    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.

     

    9.3    Final Comments

    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


Comments

Also Enrolling

Enrollment Closes: Sep 16 
Enroll
Enrollment Closes: Aug 13 
Enroll
Enrollment Closes: Sep 15 
Enroll
Enrollment Closes: Sep 8 
Enroll
Enrollment Closes: Aug 21 
Enroll
Enrollment Closes: Aug 28 
Enroll
Enrollment Closes: Aug 25 
Enroll
Enrollment Closes: Aug 18 
Enroll
Enrollment Closes: Aug 18 
Enroll
Enrollment Closes: Aug 17 
Enroll