RoadTest: Arm Education: Internet of Things Course
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?: This was an unique RoadTest because I was review the actual HW or SW but how was presented in a course. I did compare it to some seminars I had attended.
What were the biggest problems encountered?: The product received was a mix of old material and new hardware. Much of the lectures were outdated. It seemed like they wanted to use the E14 to debug their updated course materials.
First off, I would like to thank ARM Education and Element 14 for the opportunity to evaluate their updated Internet of Things Online Course (“the Course”).
Summary Conclusion –
NOTE: Before I get into any great details of the course I wanted to give a few personal notes. This was one of the most interesting and somewhat disappointing RoadTest to date for me. Just after the reviewers were selected, we were informed that the road test was being delayed due to ARM Education media’s current rewrite of the course. What we finally received for review was a poor mashup of what appears to be a mix of mostly old course lectures and videos and newer hardware. It gave me the feeling that what we were being asked to do was “beta” (or even “alpha”) testing on an unfinished product.
As noted above, this review covers the “beta” testing of ARM Education Media’s Internet of Things recently updated online course. Since the hardware is not included with the course and must be purchased separately from the STM (or a distributor) and supported by ARM Education Media (ARM-EdM), this review will focus mainly on the lecture and lab completeness, ease of understanding/use, how the material flows, customer support, etc. The performance of supplemental resources such as IDE/SDK programs and hardware will only be discussed when necessary and pertinent to the course content.
DISCLAIMER: Since the course access was not initiated through the normal channel (i.e. directly from ARM-EdM), but through E14, some of the initial communication and support issues listed below may not be indicative of ARM-EdM actual process. It would be interesting if future ARM-EdM/RoadTest reviews could be handled directly through the vendor.
Improvement Suggestions –
Overall I did find some of the topics very useful, but the course overall seemed to lack the effort on the part of the vendor to supply a finished product. If indeed we were being asked to beta test their product, I wish they would have let us know ahead of time. This leaves me with the question; is all their courses this way? I would be happy to be proven wrong. If ARM-EdM has a better example of what they can do, I would be happy to review it.
Useful Documents Links-
NOTE: Logging in to the respective websites may be required to access some of the documents.
Element 14 RoadTest Website:
ARM Education Media Course Website: https://www.arm.com/resources/education/online-courses/internet-of-things
VitalSource (Content Hosting) Website: https://www.vitalsource.com/login
STM NUCLEO-F401RE Website: https://www.st.com/en/evaluation-tools/nucleo-f401re.html#resource
STM X-NUCLEO-IKS01A1 Website: https://www.st.com/en/ecosystems/x-nucleo-iks01a1.html
STM X-NUCLEO-IKS01A2 Website: https://www.st.com/en/ecosystems/x-nucleo-iks01a2.html
ARM MBED Online Compiler Website: www.mbed.org
ARM Keil MDK Website: www.keil.com
Android Studio IDE Website: https://developer.android.com/studio/
Part I – The Unpacking: 8^) with a little 8^(
Welcome to the first part of many of my evaluation of the ARM Education Media’s Internet of Things (IoT) Course. 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.
For the course, the “unpacking” appeared in 2 phases: 1) the hardware in the form of 3 development boards and 2) the course videos and instructions.
The dev boards included a main board and 2 Arduino form-factor shields (dev boards) that were shipped directly from E14. This will play an important part as discussed later. Each dev board came individually packaged with web links to STM’s product specific information. No ARM-EdM information were supplied or referenced for the hardware.
The hardware included:
NOTE: For the course content discussion I will limit myself to a few select screenshots of the published material due to possible copyright issues.
Concerning phase 2, we were informed shortly after the reviewers were selected that ARM-EdM was updating the content of the course and that we would not have access to the videos and instructions until the update was finished. As it turned out, the course access and content was granted about 2 months later. Aside from the access code and course web link no other information was supplied. The course web link takes you to VitalSource, a content hosting site, where you enter the access code and view the course videos.
Part II – A Little Bit About The Course
From the ARM-EdM website for the course the key “learning outcomes” include knowledge and understanding of:
In addition we should be able to gain the abilities to:
NOTE: As we will see, this maybe over stretching the goals for this online course just a little. At the least, this may be a fair to good introduction to the topics.
Part III – The Details
The course is broken up into 12 modules or topics as shown in the following syllabus:
Module 1 Introduction to Internet of Things
Module 2 Introduction to Embedded Systems
Module 3 Arm Cortex-M4 Processor: Part 1
Module 4 Arm Cortex-M4 Processor: Part 2
Module 5 Interrupts and Low Power Features
Module 6 Introduction to the Mbed Platform and the CMSIS Library
Module 7 ArmV7-A/R - ISA Overview
Module 8 Arm Cortex-A9 Processor
Module 9 Smartphone Programming
Module 10 Introduction to Bluetooth Low Energy
Module 11 Networks and Connecting Things to the Cloud
Module 12 Weather Station
The course is designed as an online training tool with the combined lecture and lab videos averaging about 45 minutes per module. Not all modules have lab exercise(s).
The modules are roughly tied together in the flow shown below:
Part IV – Video Lectures, Quizzes and Lab Comments
NOTE: The speaker in the videos for both the lectures and labs has a great English accent, but every once in a while he slips up and has to repeat a line. This occurred more than once during the course and instead of editing out the “oops” he just continues on. This is not a great deal, but to catch it was fun. In some of the modules the audio sounded tinny and a little echoey.
This section covers some of the details of the lecture, quizzes and lab for each module. Again due to possible copyright issues, screenshot of the videos will be limited. The lecture videos range from 15:53 to 28:19 minutes long. Along with the video, the slides are available to view with additional comments under each topic. A notepad is available to bookmark interesting slides and add viewer comments. The quizzes range from 3 to 17 questions and are straight forward. If you miss a question(s), you can retry the exam. After the first try, you can click to see all of the correct answers. The lab videos range from 12:19 to 23:56 minutes long and normally accompanied by a couple of pages of instructions to supplement the videos. Unfortunately, the program only allows you to print 2 pages at a time.
The labs are light with step by step instructions for coding. It would be more useful if additional labs were included to reinforce the concepts. In addition, aside from the unintentional problems due to the updated hardware and software, it would have been useful to have example code with errors built it for testing our troubleshooting skills.
Module 0: Course Information
This module covers how to navigate the VitalSource course website. Lecture Video: (4:03 minutes); No lab or quiz.
Module 1: Introduction to IoT
If you have ever viewed a webinar or been to a vendor presentation on IoT (and who hasn’t) you have seen most of the information shown in the lecture video already. In the first half of the video the speaker talks about the quickly expanding field of IoT devices, giving predictions on the great numbers of units expected by the year 2020! Wait, that just 5 months away. This is where we start seeing some of the “dated” information in the course. I’m sure I’ve seen some of these slides 5 years ago. Some timelines on the slides stop at 2014.
The second half of the video covers the multiple ARM processor families and how the fit into IoT devices. The video wraps up by mentioning the ARM MBED development environment used in later labs. The video as a whole is informative, but as mentioned a little dated.
As mentioned in the above note, for those viewing this module, on slide 15, 10:56 into the video, the speaker can be heard saying “sorry one more time” as he restarts his last sentence.
Lecture Video (17:51 minutes/25 slides); Quiz: (8 questions); No Lab
Module 2: Introduction to Embedded Systems
This module talks about some examples of embedded systems and how they relate to MCUs. Slide 9 shows some of the tradeoffs (i.e. cost, size, power, etc.) for different hardware and software implementations. The last portion of the lecture deals with the attributes of embedded system. A good intro to the topic but not much detail.
Lecture Video (13:24 minutes/16 slides); Quiz: (6 questions); No Lab
Module 3: The Arm Cortex-M4 Processor Architecture - Part 1
Now we start getting into some more internal details of the Cortex-M4 processor, its architecture and primary use. The lecture includes details on the feature set, block diagram and register structure. The module concludes with an example of assembly level coding with ARM MCUs. Very nice refresher.
NOTE: This is the first lab that requires the installation of the Keil uVision v5 IDE. Again the version mentioned in the video preceded the actual available IDE by a few year, but is close enough to compile and upload the lab code with a little extra effort. The instructions for installing the IDE included with the lab download is copyrighted 2014. The video mentions that the professional version should be installed, but doesn’t include details for licensing. As it turns out, for the first few labs the MDK-Lite version is all you need. The MDK-Lite version has the needed level for compiling the lab code, but is limited to 32KB programs. This becomes an issue in the labs for modules 11 and 12. None this information is included in the written instruction for the labs.
Lecture Video (21:42 minutes/26 slides); Quiz: (9 questions); 1 Lab Exercise Video (11:29 minutes)
Module 4: The Arm Cortex M4 Processor Architecture - Part 2
Module 4 continues where module left off with details about M4’s memory mapping, bit-band operations and an overview of the ARM/Thumb instruction set. Another good review, but again little more of an overview.
The lab includes more assembly level coding and bit operations to control an I/O port to blink an LED using one of the dev board’s buttons.
Lecture Video (17:00 minutes); Quiz: (9 questions); 1 Lab Exercise Video (12:13 minutes)
Module 5: Interrupts and Low Power Features
Pointing out the inefficiency of the last lab’s polling for a button push, this lecture discusses interrupts and exception handlers. I enjoyed the topic which touched on types of interrupts, handler versus privileged modes, the use of the IDE’s debugger and some issues (i.e. timing, priority, response latency, etc.) that can arise with the use of interrupts. They showed how ARM’s nested vectored interrupt controller (NVIC) can help reduce many of these issues. I wish the video and labs would have gone into more depth in the area of lowing power consumption. The lecture and lab low power discussion mainly focused on the power reduction by not continuing to poll for an event. During the lab, the presenter briefly mentioned turning off or putting in sleep mode circuit components not being used, but he never show how it was implemented. Links to additional resources would have been nice.
The lab was similar to the last module, but using interrupt handlers.
Lecture Video (24:43 minutes/46 slides); Quiz: (11 questions); 1 Lab Exercise Video (10:36 minutes)
Module 6: Introduction to the mbed platform and CMSIS Library
The last module ended with a comment about the difficulty with using lower level program and a need for a high level programming interface. That is where the mbed platform and the use of higher level software libraries. The benefits of one such library, the Cortex Microcontroller Software Interface Standard (CMSIS), are outlined in the module along with the mbed software development kit (SDK).
CMSIS is a vendor independent hardware abstraction layer for the Cortex-M processor. It provides a standardized software interface which helps you control the processor more easily. There are different CMSIS libraries based on the functionality needed, such as CMSIS-CORE, -DSP, -RTOS, -SVD, etc. For our examples only CMSIS-CORE is required
This module also discusses the mbed SDK, including the online C/C++ IDE used in the lab.
The lab is broken up into 2 parts. The first part has you build the blinking LED program using the online mbed IDE (www.mbed.org) and downloading the resulting .bin file into the virtual storage device linked to the dev board connected to a USB port on your PC. Instructions are straight forward and worked well.
Part 2 of the lab was you setting up the project using the online IDE, then exporting the mbed source and library files to your PC for completion using the Keil uVision IDE. This worked fairly well until you try to compile the program. The following error occurs and the compile fails:
Build started: Project: LED_and_Button
*** Using Compiler 'V5.06 update 6 (build 750)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'
Build target 'LED_and_Button'
.\BUILD\LED_and_Button.axf: error: L6031U: Could not open scatter description file <<<<<<
/filer/web_data/repo_builds/4/336/TARGET_NUCLEO_F401RE/TOOLCHAIN_ARM_STD/stm32f401xe.sct: No such file or
Not enough information to list image symbols.
Not enough information to list load addresses in the image map.
Finished: 2 information, 0 warning, 0 error and 1 fatal error messages.
".\BUILD\LED_and_Button.axf" - 1 Error(s), 0 Warning(s).
Target not created.
Build Time Elapsed: 00:00:02
The linker couldn’t find the scatter description file. I contacted Robert Iannello, senior education manager at ARM-EdM and he responded in less than a day with the solution. As is turns out, the location of the file defaults to the wrong path under “Options for Target… -> Linker -> Scatter File” and needed to be changed to a local directory.
Default (Wrong Path) Correct Path
ARM-EdM had a quick turnaround and the program compiled, but then oops another problem. This time with upload the bits to the dev board:
No Algorithm found for: 08000000H - 08005EC7H <<<<<
Error: Flash Download failed - "Cortex-M4"
Flash Load finished at 00:07:55
After a little googling it would seem that there needs to be an algorithm for our MCU. Back to the options window again, but this time let open the Utilities tab. Press the [Settings] button under “Configure Flash Menu Command” to get a MCU selection popup:
I selected “STM32F4xx 512kB Flash” then clicked [Add], then [OK]. Finally close the Options window, compile and load.
Both these issues were common with many of the reviewer and should have been caught prior to release. A note should be added in the lab .zip file.
Lecture Video (20:08 minutes/36 slides); Quiz: (3 questions); 2 Lab Exercises Video (13:06 Minutes)
Module 7: ArmV7-A/R – ISA Overview
As mentioned in the title of this module, this section is a brief overview of the ArmV7 – A/R Instruction Set Architecture (ISA). With 29 slides to cover in 20 minutes, the topic moves fast and only scratches the surface, but still very useful.
Lecture Video (20:08 minutes/29 slides); Quiz: (12 questions); No Lab
Module 8: Arm Cortex-A9 – Processor
In earlier modules the presenter shows how in a product can have multiple MCUs of similar and/or different types, so in this module we pay a visit to the application focused ARM Cortex-A9. As higher performing MCU, the presenter covers new features such as multi-cores, pipelining, the media processing engine (MPE), virtual flag registers, small loop mode, flow prediction, the performance monitor unit (PMU), memory systems and the memory management unit (MMU). Some issues and solution as discussed, but as with previous modules the topics are only covered on the surface. Many of these features are very interesting, but never seem to make it into any labs or their discussions.
Up to now the Keil MDK worked well for the Cortex-M processor, but for the –A9 lab we needed to install the ARM Developer Studio (DS). Like previous installs, the software version mentioned in the lab video (DS-5 pro) was no longer available and must be replaced with DS-2019. Along with installation, we will use the new IDE and its debugger to build and run prewritten mixed assembly level and C program on the DS ARM Cortex-A9 simulator. There was an issue with setting the debug configuration that was not addressed in the lab documentation or the video. I contacted ARM-EdM support, but haven’t received a response yet. I did finally found a workaround.
Lecture Video (28:19 minutes/23 slides); Quiz: (17 questions); 1 Lab Exercise Video (14:35 minutes)
Module 9: Smartphone Programming
This module introduces us to the basic of smartphone architecture and the Android Studio IDE (AS-IDE) to prepare us for the next 3 modules. It starts off with another “dated” discussion on the importance of smartphones in the world today (2015) and the future. It continues with examples of how different ARM processors are a part of the solution, and then transitions the features of the Android operating system.
The lab starts with installing the latest Android Studio IDE. Once again the version of the IDE in the lab video and documentation is a few years old and the user interface has changed quite a bit, but most of the instructions are easy to adapt to. The video used API-19, but the latest was API-24. I had to guess on a few steps, but was able to complete the lab. Only a few basic features were used on the project.
Lecture Video (23:28 minutes/22 slides); Quiz: (11 questions); 1 Lab Exercise Video (12:19 minutes)
Module 10: Introduction to Bluetooth Low Energy
The lecture covers the history of the Bluetooth technology, comparing the features, advantages and disadvantages of different versions up to 4.0. Topics discussed included BLE protocol, device roles and architecture (User application, Host and Controller levels). A very interesting key part of the course. I would have like to dig deeper and a good reference would be good.
The lab was a disappointment since the hardware needed to complete the lab was not readily available. The BLE heart rate band mentioned in the documentation was currently not available through the Amazon link. I did follow most of the lab, but could not complete the project due to the lack of hardware. Maybe a HRM simulator could be used.
Lecture Video (15:53 minutes/19 slides); Quiz: (11 questions); 1 Lab Exercise Video (14:14 minutes)
Module 11: Networks and Connecting Things to the Cloud
As the title suggests, this module covers network topic such as internet protocols, IoT protocols, network types, security before launching into cloud services. Under cloud services different service and deployment models are discussed, as well as building and running apps.
The lab was divided into 2 exercises. The first part used the motion MEMS and environmental Nucleo expansion board (X-Nucleo-IKS01A2), however the lab code was built around an earlier version of the sensor board (X-Nucleo-IKS01A1) that used a different pressure sensor. This still allowed the program to compile and load, but the pressure measurement was not displayed. Another workaround was found to display the measurement, but this again leads me to ask if anyone at ARM-EdM even tested the code before release. I did email the ARM-EdM support manager about the issue and he responded a couple days later that they couldn’t find the problem with their X-Nucleo-IKS01A1. I reminded them that the problem was with the new sensor board and I hadn’t heard back from them since.
The second exercise was the “nail in the coffin” for me. It used the Bluetooth Low Energy Nucleo expansion board (X-Nucleo-IDB05A1) instead of the older X-Nucleo-IDB04A1. Due to what I believe was an expanded board library, the code would not compiled due to the Keil MDK-Lite linker size limitation (32KB). See the comments under module 12 for further details.
Lecture Video (27:35 minutes/29 slides); Quiz: (4 questions); 2 Lab Exercises Video (15:21/13:31 minutes)
Module 12: Weather Station
There is no lecture video for this segment. The lab video is easy to follow and complete the project code, but as with the last lab, the compiler’s 32KB code size limitation causes the linker to fail. The program compiled to 47KB. I tried different optimizing setting under the C/C++ compiler tab, but could only get down to 41KB (Option –O3). Again I tried to use the 7 day trial license button on the Keil MDK license management page, but couldn’t get it to work. I did not contact ARM-EdM for a trial license since that was not part of the support process in the installation instructions. When I followed the written instruction I received no reply. Not being able to complete this
No lecture or quiz; 1 Lab Exercise Video (23:56 minutes)
Part V – Additional Labs Comments
The labs should be the heart of the course since that is where the concepts are cemented together. This is probably my biggest disappointment for the course. There were a number of issues and/or concerns that arose during the labs:
What I didn’t try (much)
For reasons mentioned previously, I was never able to complete the second lab exercise in module 11 and the lab exercise for module 12 due to compiler issues, but I tried. I even tried building a .bin file at www.mbed.org with little success. Unfortunately, the course access and IDE license will expire soon which may further limit my progress.
I’m interested in trying to port the weather station code to ST’s free no size restriction compiler. I would also like to try a different ARM-EdM course to see if this was just a “oops”.
Please let me know if I missed something in the documentation. Also please pardon my typos.
Meridian, ID USA
Nice summary and great review.
You were able to nail the specific gotchas better that I did.
Having the solutions published helped me through some of learning curve (especially some typos), but as you point out, other roadblocks kept those published solutions from working.
I agree with you too, in that I did learn alot, but the course and material had potential to be really good. The significant time I invested in it was not productive, so I was disappointed and frustrated.
Very good and honest review.
I agree, if a vendor is going to charge for these courses, the buyer should get their monies worth and there should be no missing pieces.
After all, the courses are intended to increase the number of ARM users, not piss them off so they go somewhere else for their hardware.
Good tools make or break a hardware buy decision, so your difficulties indicate that ARM support may not be up to primetime standards yet.
Sorry that this roadtest was not as great as expected. I can only image that it was difficult to go through the motions of writing such a nice review on something that did not deliver the expected level of training.