Skip navigation
> RoadTest Reviews

Arm Education: Internet of Things Course - Review

Scoring

Product Performed to Expectations: 3
Specifications were sufficient to design with: 3
Demo Software was of good quality: 3
Product was easy to use: 5
Support materials were available: 5
The price to performance ratio was good: 3
TotalScore: 22 / 60
  • RoadTest: Arm Education: Internet of Things Course
  • Evaluation Type: Development Boards & Tools
  • Was everything in the box required?: Yes
  • Comparable Products/Other parts you considered: 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.

  • Detailed Review:

    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. 

     

    Pros –

    • Although the course labs could not be completed due to both hardware and software issues which could have been avoided by the vendor, most of the “learning outcomes” (i.e. objectives) were met at an introductory level.
    • Very useful refresher for ARM assembly level programming.
    • Very useful low power operation, Smartphone and BLE segments.
    • Most of GUI-based IDEs had familiar Eclipse-based interfaces.

     

    Cons –

    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.

     

    • As mentioned earlier, the course lectures and labs seemed to be “dated” with some information showing references back to 2013.  The overall feel was that the materials were a mashup of old and new information with little additional thought and that we were actually beta testing a very rough draft of the “updated” course.
    • During the course the user has to keep track as to when access to the class material/video ends.  Initially the access duration for the review was set to 30 days (for a 60 day review cycle). On the 31st day, without notice from the vendor, access was lost.  On a positive note, access was restored within hours after the issue was reported.
    • The course access is purchased for a given duration in 3 month increments.  There was no clear indicator as to when the access period begins.  Is it when you first log on or when you start viewing the videos or when you pay. 
    • With the exception to the E14 RoadTest description, the ARM-EdM course description page does not list the recommended hardware and software used during the course. Only after you are granted access to the course material does the user see the required HW/SW.
    • Two of the three dev boards supplied with the kit were updated versions of the boards used in the lab videos and had compatibility issues with the lab code supplied.  The last 2 labs could not be completed using the recommended IDE due to compiler size restrictions caused by the libraries for the new BLE board.  NOTE: Since the dev boards were supplied by E14 this may not have been an ARM-EdM issue.  When I contacted ARM-EdM support, I got the impression that they thought we were using the board recommended in the videos.
    • The IDE development software shown in the lab videos were outdated without updated instructions.
    • The labs were overly simplified and it would have been more useful if they had included more examples of the features they mentioned in the lecture videos.

     

    Improvement Suggestions –

    • The labs are the heart of the course and should cover the hardware features to a deeper level.
    • It would be useful if an indicator on the hosting web page show the remaining number of days the materials were available.  This would also help show when your access period had begun.
    • The ARM-EdM website should have links to where to purchase the hardware/dev boards. 
    • The recommended hardware and software would be listed on the course description page so it can be ordered before the user starts the class.  Since the hardware requirements are very specific, it would be very help to contract with specific vendors (i.e. STM, Element14, etc.) to supply a complete kit or set of materials to the user.  Maybe even a kit discount.
    • As recommended hardware and/or software changes or updated, the course materials should be update.  It would be nice if the related video(s) were updated, but even an addendum note in the respective lab folder(s) showing the changes would be very helpful.
    • Along with the recommended hardware, a list of recommended reading material (i.e. books, data sheets, app notes, etc.) would be helpful.  This should also be listed on the course description page.
    • It would be nice to be able to download a copy of the slides from the videos in pdf format to take notes on as you watch the lectures.

     

    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:

    https://www.element14.com/community/roadTests/2021/l/arm-education-internet-of-things-course

    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

    STM X-NUCLEO-IDB04A1 Website: https://www.st.com/content/st_com/en/products/ecosystems/stm32-open-development-environment/stm32-nucleo-expansion-boards/stm32-ode-connect-hw/x-nucleo-idb04a1.html

    STM X-NUCLEO-IDB05A1 Website: https://www.st.com/content/st_com/en/products/ecosystems/stm32-open-development-environment/stm32-nucleo-expansion-boards/stm32-ode-connect-hw/x-nucleo-idb05a1.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:

    • Nucleo-F401RE (Qty 1) – Main Dev Board
    • X-Nucleo-IKS01A2 (Qty 1) – Motion MEMS & Environmental Nucleo Expansion Board
    • X-Nucleo-IDB05A1 (Qty 1) – Bluetooth Low Energy Nucleo Expansion Board

     

    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:

     

    • Smartphone architecture and technologies,
    • ARM-based SoCs architecture and development,
    • Appcessory programming and embedded programming,
    • BLE technology,
    • Sensor networking and applications,
    • IoT fundamentals

     

    In addition we should be able to gain the abilities to:

    • Specify, design and develop a smartphone-based networked electronic system, which entails appcessory development, MCU programming and connected app development and
    • Use the ARM Mbed IoT Device Platform and Android SDK to create smartphone apps and control end devices such as a mini robot or wearable health device and
    • Design and implement an appcessory with BLE connectivity using standard mobile application development tools and
    • Program an ARM-based BLE connected MCU using mbed development tools and
    • Develop demonstration applications (e.g. smartphone-based, sensor station, etc.).

     

    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'

      compiling main.cpp...

      linking...

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

      directory

      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:

     

      Load "..\\Labs\\Module_6\\LED_and_Button_uvision5_nucleo_f401re\\LED_and_Button\\BUILD\\LED_and_Button.axf"

      No Algorithm found for: 08000000H - 08005EC7H <<<<<

      Erase skipped!

      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:

     

    1. The licensing for some of the software used in the labs was time limited.  The ARM-DS software gives the installer 30 days of free use, after which you are locked out.  If course requires more than 30 days is the trial license extendable?  If a student takes another course that requires the DSIDE, can they get another trial license?  The lowest featured version of DS-2019 costs $2500/per year/per seat. The same issue can be asked about the trial version of Keil’suVision, which is only 7 days long.  How to obtain or extend a license should be included in the lab installation instructions.
    2. A better way to communicate hardware recommendation changes need to be found.  Including better documentation in the lab zip file may help.
    3. The lecture videos mention many great features for ARM processors, but unfortunately the vast majority of those features never get demonstrated 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.

     

    What’s next?

    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.

     

    Gordon Margulieux

    Meridian, ID USA


Comments

Also Enrolling

Enrollment Closes: Sep 4 
Enroll
Enrollment Closes: Sep 6 
Enroll
Enrollment Closes: Sep 9 
Enroll
Enrollment Closes: Aug 30 
Enroll
Enrollment Closes: Aug 31 
Enroll
Enrollment Closes: Sep 10 
Enroll