,

One more Zephyr training for 2024 (December 4th)

Golioth wants to make embedded engineers into better IoT engineers. That’s why we do a training where we not only show people how Zephyr works, but also how they can connect a device to the cloud and immediately get the benefit of streaming data, pipelines, Over-The-Air (OTA) updates, settings, Remote Procedure Calls (RPCs), and more.

After another successful year of Zephyr training, we will be holding our final training of 2024 on December 4th. Sign up today!

Changes over time

As Zephyr goes, so goes the Golioth Firmware SDK. Meaning, we are always updating our helper libraries and Zephyr implementation when new features are ready in the ecosystem. The latest changes from Zephyr 3.7 and NCS 2.7 have been incorporated into the Golioth SDK and are now part of the training as well. Not a lot has changed for our beginner content, but you’ll see things like the new board format while you’re compiling Zephyr programs.

By attending our upcoming training, you’ll gain hands-on experience with the latest version of our SDK and learn best practices for Zephyr development directly from the Golioth team. The training will cover topics such as:

Whether you’re new to Zephyr or an experienced embedded developer, this training will equip you with valuable skills and knowledge to build robust, secure, and scalable IoT solutions.

What’s Next?

As the winter begins in the northern hemisphere, many people find themselves inside with more time on their hands. Taking the Golioth training will unlock your Zephyr skills but also will have you on the path to becoming a better IoT developer. Use the same boards and underlying tools to build out your next IoT project or even utilize our Follow Along Hardware designs to replicate one of our many Reference Designs. As your data gets more and more complex, you can push that data through Pipelines to our variety of services, including many of our AI destinations for high complexity processing.

The best way to get started is to sign up for training today…we’ll see you on December 4th!

/by
, ,

Build Before Installing: Zephyr Dev Environment Using GitHub Codespaces

How fast can a new Zephyr user go from zero to successful code compilation?

Golioth continues to invest in Zephyr RTOS capabilities: we have a super strong device SDK that works right on top of the Zephyr SDK, our Reference Designs are built on top of Zephyr, and we continue to train engineers every month on how to get booted quickly with Zephyr. When a fresh face walks through the door of our virtual training, we want to ensure a good experience for training.

In this talk at the Embedded Open Source Summit 2024, Firmware Engineer Mike Szczys describes how we utilize Dev Containers and GitHub Codespaces to provide a pre-installed Zephyr toolchain so that users have a seamless getting-started experience.

An evolution of training

Golioth has held a number of virtual training events using Kasm, something we have written about in the past (and gave a talk about at last year’s EOSS). We liked this method because it provided a pre-installed toolchain in a virtual environment. But it also included a “virtual desktop” environment and was built on top of generic “always on” cloud compute. Any time we did the training we would spin up new EC2 instances to serve users.

The problem is that the utilization was often low and we didn’t keep these resources available. Moreover, the users couldn’t take the work with them: when the session was over, their work was destroyed.

GitHub Codespaces fixes this up front: it’s a configuration script and setup that can deploy a full development environment onto a user’s own GitHub account. If someone wants to continue their work later in the day/week/month, they boot the Codespace back up and pick up where they left off. It’s also possible to utilize the setup to extend to their own projects, or implement interesting remote testing. And you can take it with you, because it’s build on the open standard of development containers.

Development Containers (or just: Dev Containers)

Utilizing Dev Containers only takes a couple of lines of configuration. However, understanding the pieces can be tricky, especially if you’re new to containers generally. Let’s peek at the main .devcontainer file:

{
  "image": "golioth/golioth-zephyr-base:0.16.3-SDK-v0",
  "workspaceMount": "source=${localWorkspaceFolder},target=/zephyr-training/app,type=bind",
  "workspaceFolder": "/zephyr-training",
  "onCreateCommand": "bash -i /zephyr-training/app/.devcontainer/onCreateCommand.sh",
  "remoteEnv": { "LC_ALL": "C" },
  "customizations": {
    "vscode": {
      "settings": {
        "cmake.configureOnOpen": false,
        "cmake.showOptionsMovedNotification": false,
        "C_Cpp.default.compilerPath": "/opt/toolchains/zephyr-sdk-0.16.3/arm-zephyr-eabi/bin/arm-zephyr-eabi-gcc",
        "C_Cpp.default.compileCommands": "/zephyr-training/app/build/compile_commands.json",
        "git.autofetch": false
      },
      "extensions": [
        "ms-vscode.cpptools-extension-pack",
        "nordic-semiconductor.nrf-devicetree",
        "nordic-semiconductor.nrf-kconfig"
      ]
    }
  }
}

The top 3 lines of the .devcontainer file we use for training includes 3 critical elements:

  1.  A base level image with Zephyr pre-installed on top of a minimal Linux environment
  2. Where to mount the local workspace folder inside this container
  3. The name of the workspace folder and where to drop the user when they boot a container

A critical element having the toolchain pre-installed on a Debian image. The nice part is that you can utilize others’ containers, including ours! If you want to customize containers for your own builds, you might need to learn some new items.

Other customizations allow you to set up how you’d like VS Code to look and which extensions you’d like to have available on boot.

Extending with onCreateCommand.sh

You can add other capabilities once the box has been initiated and is building. This includes pulling in repository information and setting up .bashrc elements that you might find useful from the command line.

#!/bin/bash

west init -l app
west update
west zephyr-export
pip install -r deps/zephyr/scripts/requirements.txt
echo "alias ll='ls -lah'" >> $HOME/.bashrc
west completion bash > $HOME/west-completion.bash
echo 'source $HOME/west-completion.bash' >> $HOME/.bashrc
history -c

It’s key that the west environment was set up in the initial container, because this now utilizes those tools just like you would when setting up a local Zephyr environment on your computer using our docs.

Binary Downloads As The Main Output

If there’s one argument against this method, it’s that the output of the build is not directly loaded to your development board. We’re working on some capabilities to extend that (see the video for more details), but right now you need to download the binary (zephyr.hex) and load it to your board using a programming tool like nRF Connect For Desktop. That makes this method less optimal for rapid fire debugging. However, it’s possible to debug your program using GDB or something like Segger Ozone. It’s not the same “click to debug” experience that many hardware and firmware engineers are used to from vendor IDEs. We think the ability to get started in 60 seconds is worth the tradeoff.

Slides

View Mike’s slides below and watch the video for an in-depth look at how to create your own Codespaces installation and start with Zephyr today.

/3 Comments/by

Zephyr Training is now Anytime, Anywhere thanks to Codespaces

For more than a year, Golioth has been hosting free Zephyr training. We’re going to keep doing that. But the news today is that you can learn from our Zephyr course anytime, anywhere using Codespaces.

Ze…what?

IoT devices usually need a real time operating system (RTOS) to handle the networking aspect of connecting things to the Internet. Zephyr is an open source RTOS guided by the Linux Foundation. We like it for its far reaching cross-vendor support and handy network stack. Using Golioth with Zephyr is a snap because the Golioth Firmware SDK functions as a Zephyr module.

But for our customers to build devices with Zephyr they need to know how to use Zephyr. Which leads to our free Zephyr training!

Zephyr tools in your browser; code on your device

The Golioth Zephyr training is offered live via the video chat every month. We supply tools to everyone who participates, just bring your own dev board to run the code examples on.

The training documentation we use has always been publicly available, but this month we’ve started using Codespaces to host the build environment tools. Now it’s available to everyone, even outside of our synchronous training sessions.

Head over to our code repository now, and choose the Codespaces tab from the big green <> Code button in the middle of the screen. Launch your pre-configured development environment by clicking the Create codespace on main button.

Launch Codespaces from the Goilioth Zephyr-Training GitHub repository

Around 90-seconds after clicking that button, an instance of VS Code will open in your browser. It already includes the training code repository, but also has the Zephyr tree (all the code from the open-source operating system) and the compiling tools needed to build the code are pre-installed!

Golioth Zephyr Training inside of Codespaces

Follow our Zephyr Training document site to walk through how to use this tool with the training material. Because you are building in the cloud, but running the code on your local development board, there is a download-and-flash step necessary, but we’ll guide you through it.

For individuals, using Codespaces is free with a few generous monthly limits (at time of writing these that’s 15 GB storage a 120 core hours).

Now it’s your turn!

Our training code is built to run on either the nRF9160-DK or the nRF7002-DK (one codebase, two boards thanks to Zephyr). Grab one of those boards and make your way through the modules of the training site.

  1. Start with the Intro to Golioth course
    1. You’ll flash a pre-compiled binary, save your credentials to the device, then try out the IoT feature built on top of Zephyr RTOS
    2. Code for this first sample is available to learn from
  2. Move on to the Zephyr Training course
    1. Start with an overview of the major components of the Zephyr ecosystem
    2. Move on to build your own binaries from source using Codespaces
    3. You’ll go from Hello World, to defining your own hardware components and using the RTOS threads and timers to control them

Of course it’s more fun to take on the challenge along with other people in the same boat. You’re more than welcome to join us for a free Zephyr training. Our next session is January 24th, and we’ll have another coming up in February. Sign up now!

/by

Our final free Zephyr training of 2023 (November)

Golioth has now trained current and future IoT engineers from across the globe more than 10 times. We have learned a lot about how to get people up and going with Zephyr, the popular Real Time Operating System and ecosystem. Our next training will happen November 29th, 2023. This will be our last training session of the year. The price continues to be…free!

What does training look like?

Our training on October 25th was another iteration of our ongoing series to show people how to get started with Zephyr. It broadly has two sections:

  • In the first hour we help you get your dev board (nRF9160-DK or nRF7002-DK) loaded up with a pre-built binary and connecting to the network. This lets us know that you understand the workflow and you can see early success at building an IoT project. You’ll load binaries directly to the board (no compiling required), input security credentials from the Golioth Console, watch the device connect, and then interact with readings on the Cloud.
  • In the second two hours, we take things back to basics and show you how Zephyr works from the ground up…with examples! As with any good project, we start from hello_world and blink examples, and build you all the way back up to things like using the connectivity on-board and then building a more complex IoT application in Zephyr. This includes plying more difficult topics like the Devicetree, as well as learning some RTOS topics like threads. Along the way we demo full featured applications like our Thingy91 demo and reference designs.

Sign up for November 29th training now!

You have one final chance to get in on the fun in 2023. We’ll have additional training sessions (with some fun new content) in 2024. Feel free to bring others from your company and work together on the sessions! We have had groups of trainees that were able to work together and even discuss how the Zephyr concepts will apply to their development inside their company.

/by

Free Zephyr Training is Two Weeks Away (October)

Zephyr is the fastest growing real-time operating system. If you’re not already using it, you should be! Now’s your chance, Golioth’s next training and the next session is just two weeks away. Join our free Zephyr training on October 25th at 9am Pacific time to get yourself up to speed.

What Will I Learn?

This three hour training happens on real hardware—sign up now so yours arrives in time for training. By the end of the session, you will have compiled, run, and worked with the output from a Zephyr app numerous times. Along the way you’ll gain understanding of the major building blocks of Zephyr (CMake, Kconfig, Devicetree, etc). We delve into mapping hardware, working with threads, and troubleshooting build issues.

This training session is held live on a video chat platform. You move around as an 8-bit avatar, automatically opening chats when you get near people. This makes it pretty easy to ask questions from other people at your table. And when you get stuck, you can pair up with instructors to get help.

Golioth Uses Zephyr

Golioth is your instant IoT cloud. Chances are, we support the microcontrollers you want to use. This is thanks to Zephyr’s approach to building for a wide range of hardware while at the same time providing a fully-featured networking stack perfect for connected devices. The Golioth Zephyr SDK is a module that you add to any Zephyr project to enable device management, data transfer to/from the device, and over-the-air (OTA) firmware updates a simple matter of making a function call.

We’ll demo the Golioth platform and give you a chance to try it out at the beginning of the training. If you can’t wait until then, our free Dev Tier allows up to 50 connected devices, so give Golioth a spin today.

/by

Our Next Free Zephyr Training is September 27th

A group of engineers sitting in a circle, learning together

Come and learn Zephyr RTOS with Golioth! This free training will get you up to speed on the basics of the fastest growing Real-Time Operating System. We host these remotely, so you can take part from the comfort of your home or office (or perhaps your home office). Sign up now to join in on September 27th from 9am to noon, Pacific time!

Hands on with the basics of Zephyr

Closeup image of two Nordic development boards

There is no cost to take part in the training, but we do ask that you order your own hardware. Our code examples work on either the nRF7002dk (WiFi) or the nRF9160dk (Cellular) development boards. We start with a pre-compiled binary that shows your device connecting to Golioth as a basic IoT device. From there, we go back to first principles:

  • Learning about the build system
  • Modifying existing Zephyr programs
  • Testing simple Zephyr outputs

By the end of the day you will have a taste of how to add sensors and work with threads, and how to run those examples on your target hardware.

Remote, yet it’s still kind of like being in-person

Training is held in a virtual classroom that looks like it’s straight out of the Legend of Zelda. You have a character to walk around with the arrow keys and when you get close to other people, a video chat opens up. This makes it very easy to pick your study group, ask question, or listen in as others are getting help. Golioth staff are on-hand to present the training and answer questions along the way. It’s the next best thing to being in the same room together and we can’t wait to see you there. Sign up below and we’ll send you all the into you need to get ready for training.

(Please note: This form will automatically switch over to the following month once registration for September is closed)

/by
,

Everything you wanted to know about Environmental Monitoring (webinar)

On September 28th, 2023 at noon EDT / 9 am PDT, we’re hosting a webinar with Keenan Johnson of the Ribbit network! You have seen Keenan featured in our Case Study about Ribbit where we detail how they are using Golioth to power their fleet of environmental monitors. We’ve been giving away Ribbit kits to new newsletter signups, so be sure to sign up and enter the sweepstakes if you haven’t already.

But really we want to get into the nitty-gritty details of environmental monitoring: what are the challenges for putting devices into the field and how does someone address those challenges with a connection to the internet?

This session will cover things like:

  • Protecting a project from the elements while also still measuring those elements
  • Creating resource efficient communications back to the internet to prolong device life
  • Gathering relevant fleet health data to ensure long deployments
  • Working with community partners to deploy sensor networks asynchronously
  • Visualizing data in a useful way for all stakeholders
  • Utilizing automation to reduce engineering overhead for a large sensor network
  • Empowering citizen science to improve environmental monitoring

The presentation will last approximately 40 minutes, followed by a Q&A session with attendees that can ask questions directly to Keenan. Sign up for the webinar below!

 

/by

How to use the Golioth REST API to Access IoT Fleet Data

Golioth makes it easy to work with the incoming data from your IoT fleet. How easy? Very Easy! But you don’t need to take our word for it… you can try it for yourself right now using our self-guided Golioth REST API training module.

The Golioth REST API is incredibly full-featured, unlocking all aspects of accessing data and controlling your IoT fleet from the cloud. This was no afterthought, everything that can be done from the Golioth web console is based on the API. Whether you want to perform some simple queries, deploy a new firmware update, or spin up you own custom app for device management, we’re ready for it!

This training is self-guided and available for everyone.

Getting to Know the Golioth REST API

Golioth REST API Docs

If you browse the REST API in the Golioth Docs you’ll see there is a lot to take in. We added a REST API training module to help you get familiar with the basics. You will learn how to:

  • Get a list of devices and status information from your fleet
  • Query your sensor data
  • Issue Remote Procedure Calls (RPCs) to control your devices
  • View all of the REST API calls made by the Golioth Web Console as an example for more complex operations

This is the newest section of Golioth training. It builds on the Intro to Golioth module, which runs a pre-compiled binary on your choice of the nRF9260 DK or nRF7002 DK boards to send temperature sensor data to the cloud a few times a minute. Having a device sending live data means you will see device status and sensor data entries returned by your REST API queries.

Internet, Meet Things

Connecting your devices to the internet is only one piece of the IoT puzzle. How will you collect and store the data from your devices? How will timestamps be associated with that data? What does it take to send command and control information to your fleet? Golioth has already solved these problems, and we packaged that solution into a REST API from the start.

Get your IoT deployment up and running in days, not months. With our Dev Tier, your first 50 devices are free, so take the plunge and sign up now. Our self-guided training will jump-start the skills you need and we’re always available to answer questions and share advice in the Golioth forum.

/by
, ,

Free Zephyr Training on July 12th

Come learn Zephyr with Golioth on July 12th, 2023! You will need to order your own hardware, but there is no cost to attend the live training. Sign up now so that you know you have a seat and can order a dev board with plenty of time.

Golioth’s Zephyr Training in a Nutshell

Golioth is an instant IoT Cloud for microcontroller-level devices. We are hardware agnostic, and we use Zephyr, the fastest growing RTOS, because it supports a wide range of hardware from different vendors. We have a number of customers who ask where to find Zephyr training, so we developed our own boot camp to get you started.

Nordic nRF7002-DK board

Nordic’s new nRF7002 Development Kit

This three-hour training uses your choice of the Nordic nRF7002 DK (WiFi) or nRF9160 DK (Cellular). We begin by installing the Nordic tools on your local machine for loading new firmware on the boards. Everything else happens in a browser-based container. You’ll use VS Code and the Zephyr build environment, but it’s already set up for you to start working quickly.

Two sections are presented. We first load a pre-compiled binary on the board and test out the Golioth platform features. This ensures you are able to successfully program the board, and exposes you to the Zephyr networking stack, serial shell (used to assign credentials which are loaded into non-volatile storage), and logging system. The second portion of the training provides an overview of how the Zephyr development environment works before getting hands-on with Devicetree, Kconfig, pin mapping, timers, threads, and general RTOS knowledge.

You will come away with an understanding of how a Zephyr application is formatted, how the build system works, and what to expect when your application is running on your board.

Take a Peek, then Join Us Live!

Our training is no secret, the self-guiding documentation and the sample code are both available to peruse right now. However, you’ll find the interaction with other attendees and with the Golioth staff running the training fills in a lot of knowledge that’s not so easy to print on a webpage.

Sign up

Join us Live on July 12th! Note that we also changed our signup policy: if you meet the criteria, you will be automatically enrolled into training (see form for more details). We are limited to 60 trainees, but we plan to also hold a training in August. We hope to see you there!

Fill out the signup form at https://forms.gle/3yk5WrWJ3Dunds9CA

/by
,

Golioth trains future Zephyr engineers

Golioth just wrapped another Zephyr training session that was open to the public. This was a group of 30 trainees, all remote. There continue to be challenges with remote training, but we are always refining how we train engineers and will detail some of the learnings below. We appreciate everyone who took part in the training and are energized to do another one. In fact, you can sign up for our July session at the end of this post!

Why does Golioth focus on training?

Golioth’s main business is creating the web infrastructure that IoT devices connect to and enhance IoT offerings. The devices have a seamless connection experience by using our various device SDKs. Supporting customers that use Zephyr means we have a large amount of hardware that we can support “out of the box”. Our Zephyr SDK helps us advance our goal to support the maximum number of hardware platforms. We also have a Golioth Firmware SDK that extends that goal by supporting additional ecosystems like ESP-IDF and ModusToolbox™. We have plans for other ecosystems in the future.

Golioth focuses on Zephyr training because we think it gives customers a great opportunity to build hardware that is tightly coupled to Cloud services that Golioth provides.

Zephyr is unique because it is both an ecosystem and a Real Time Operating System (RTOS). This is in contrast to something like FreeRTOS, which is an RTOS (obviously), but then vendors like Espressif or Infineon (and a range of others) maintain a vendor specific ecosystem on top of the core RTOS. The net result is that Zephyr has many vendors contributing, but ultimately the core members of the open source Zephyr project drive the direction of the ecosystem and the RTOS. I believe this is what is driving a lot of the popularity of Zephyr. As the popularity continues to increase, we see more people looking to learn about how to use Zephyr in their projects.

There is a steep learning curve when getting started with Zephyr. This, of course, depends on your experience. To hardware and firmware engineers who are used to bare metal programming, it might be difficult to learn about an RTOS for the first time. Understanding how KConfig, Devicetree, and the west build systems can work for your project is another layer to unfold. Device vendor specific implementations of Zephyr APIs and interacting with real hardware takes the problem off of the code editor and into the real world. And throughout the entire process, understanding error messages and building troubleshooting capabilities is a necessary skill-building exercise.

This is why we want to help train people around Zephyr. We know the power of the platform and we want to unblock developers from getting their device talking to the internet using the Golioth Zephyr SDK.

Things we learned

In preparation for our June training, we revamped multiple aspects of our Zephyr program. We also learned more about what works, and what doesn’t

New training site

Training.golioth.io is where we maintain all of our training documentation. Our training programs are focused around written material, instead of being dependent on presentations from the trainers. This unlocks users to move ahead during the training or go back and review a section that is difficult for them to understand.

We also broke up the training into some new sections. We have a new REST API training section, that is separate from our Zephyr training. We will hopefully have other types of training on there in the future. We broke out the “Intro to Golioth” into its own section, because this is the same regardless of which training you’ll be going through.

Having well written documentation continues to be a positive aspect to our training, though we found additional areas we can clarify.

A focus on binaries

In the Intro to Golioth section, we encourage users to download and flash a binary onto their hardware. This matches a recent experiment we did with pre-compiled binaries on the Thingy91, since we think this is the fastest way to try out the capabilities of Golioth. We want trainees to also be able to explore the Golioth Console, which is made easier by a binary that can be put onto the supported hardware during the training. An added benefit is that this tests that users are capable of programming their hardware with a known-working application, which means they’re ready for subsequent training sections.

Previously we had users compiling a program immediately after starting the training. The binary seems to be a better solution to accelerate users’ progress.

Switching to Nordic hardware

Another change for this training is focusing on development hardware from our partner Nordic Semiconductor. We wrote about our excitement around the nRF7002-DK for training, since it provides an affordable board with a built-in programmer. We also enabled a second piece of hardware, the nRF9160-DK. That board is cellular based, which gave users more flexibility to take the training in places where they didn’t have access to the Wi-Fi credentials; it also happens to be one of our best supported boards. Finally, this showcases how Golioth, Zephyr, and Nordic Semiconductor hardware enable cross platform solutions (even different connectivity types), with almost the same underlying code.

Another reason we were excited to switch to Nordic-based hardware is the cross platform support of the nRF Connect for Desktop tool suite. This gives a graphical programmer and reliable serial terminal, which we integrated into our training. Supporting engineers across the range of computing hardware (laptops, desktops) is a surprising challenge. Even though Windows, Mac, and Linux based options are the norm, there is a huge variability between different types of machines. This is also why we continue to be excited about Kasm.

Kasm Environments

Kasm is a streaming container platform that we have standardized on in our training. This allows us to create an entire desktop computing environment that gets streamed to a user’s browser. The best part is that as soon as the user logs in, they have access to all of the toolchains, IDEs, downloaded firmware projects, and any helper tools needed on the virtual remote machine. As the user goes through training and compiles binaries for themselves, they can download the binary to their host machine. That binary can then be programmed using the nRF Connect for Desktop programmer tool. The net result is that our users are ready to compile Zephyr programs within minutes of starting the training. See below for a look “inside” our training.

Where our training still falls short is a direct connection from the Kasm remote environment to the users’ development boards. This is a tough nut to crack.

You might be thinking, “Why not have the user install tools locally? Or have them install tools before they show up to training?”. Past training experiments where we asked users to install the Zephyr tooling onto their host machine took a significant amount of time, and sometimes didn’t work at all because users show up with a wide range of laptops to a training. Don’t believe us? At our in-person training at Supercon 2022, we had a user show up with a Valve Steamdeck handheld Linux gaming computer (his laptop had broken the night before). He was able to successfully use our Kasm container to compile and program the hardware!

For now, we will continue to experiment with connections to pre-configured containers, as we think this unified development experience is the best case scenario for training users.

Sign up for the next one

We continue to refine our capabilities on these training sessions and decided to hold another one on July 12th! We also changed our signup policy: if you meet the criteria, you will be automatically enrolled into training (see form for more details). We hope to see you there!

Fill out the signup form at https://forms.gle/3yk5WrWJ3Dunds9CA

Many Thanks

Though I had the opportunity to help administer this training, the majority of credit goes to my co-worker Mike Szczys. He wrote, tested, and built all of the firmware images and training materials and the training would not be possible without him.

Thanks also go to Golioth team members like Chris W, Dan, Dylan, Marko, and Sam for being on the training and walking users through Golioth.

/by