,

Our largest in-person training yet

Golioth doesn’t just make servers to make it easier to implement secure OTA and send data back and forth to your IoT devices. We also offer open source SDKs that make it easy to build the devices in the first place.

We just got back from the Hackaday Superconference, a 3 day gathering of hardware- and software-minded enthusiasts from a wide variety of industries. We presented a 2 hour in-person training, using many of the things we have learned from our past all-remote training. This article will expand on the training and how things change when there are other people sitting in a room together.

A recap of training

For those that haven’t read the past articles about our training, let’s give a quick recap. We use the $35-ish Adafruit MagTag as our main board for this training. We like it because it has:

  • An Espressif ESP32-S2 for running Wi-Fi
  • Inputs:
    • Accelerometer
    • Light Sensor
    • 4 user buttons
    • Stemma / Qwiic header
  • Outputs:
    • 4 NeoPixel side launch LEDs (multicolor programmables)
    • Speaker
    • eInk Display

As we onboard people to this training, we try to slowly ramp people up as they are learning about the hardware and Zephyr, a real time operating system (RTOS) that we use as the basis of firmware we will put onto the board.

The first thing that trainees do is compile and install a pre-written program that connects to a Wi-Fi access point, connects the embedded hardware to the Golioth cloud, and interacts with the cloud sending data and log messages. Once the trainee has successfully connected to the network, we step back and show them how to compile and interact with the cloud and RTOS in a more targeted way, by giving them exercises that showcase different aspects of Zephyr.

This training had an additional “mode” because it was an in-person conference: Mike wrote an additional example that allows the users to pull their name off of LightDB State (our stateful database service) and update the ePaper screen. Once it pulls your name, the badge will preserve that data after a reset.

Programming without toolchain install

A key tenet we have for training is to get the user compiling as fast as possible. Asking people to pre-install software or install when they get to the training is a recipe for frustration. Instead, we use our Kasm setup that we have mentioned a couple of times on the blog. When the trainee sat down at the training, the only thing they needed to do was click on a link and they are launched into a virtual environment contained within the browser. In addition to the desktop environment, we have installed and configured all of the necessary files to immediately start compiling firmware.

We know that people come to training with a wide variety of computer hardware, which normally means we get a variety of eras of Windows, Mac, and Linux machines compiling the programs that will go onto the embedded hardware. One trainee had a laptop issue the night before and was our first trainee to complete the training using a Valve Steamdeck (a handheld Linux computer meant for gaming).

This training got big

We had 28 people sitting down and going through the training. This was our largest number of trainees to date. The Kasm servers are able to scale up to however many people we have taking the training, so that was no problem. Some things we noticed with a group this large.

  • The layout of the tables in the space we were in was one long “banquet” style table. This meant it was harder to sit next to each user and guide them when necessary. They did benefit from camaraderie with their fellow trainees.
  • We really enjoyed being able to peek over someone’s shoulder and see what they were having trouble with. We use gather.town when we do remote training, which is a good video platform, but it’s still a limited window into the other person’s struggles.
  • Having 28 people in a room strains the Wi-Fi a bit. We were in a facility with very good Wi-Fi overall, but there were additional people all over the space (outside the training area) that were also using Wi-Fi, so the system was a little strained. Remote training means everyone gets all of their home or office Wi-Fi bandwidth to work.

We may have found the practical upper limit of people taking the training without additional preparation like private Wi-Fi networks at a conference. We will continue to refine the experience so it’s a smooth onboarding to using Zephyr or other platforms we train with in the future.

Future training

Speaking of other platforms, Golioth supports more than just Zephyr! We have an ESP-IDF SDK, which makes it easy to use the FreeRTOS based implementation from Espressif. We can use the same hardware that we know and love, because it’s supported by both ecosystems. We also recently announced support for ModusToolbox™, which means we can help engineers connect their PSoC™ 6 based projects to the Golioth Cloud.

If you’re interested in taking part as an individual or as a company, sign up for future training here.

/by
,

Golioth is headed to the Hackaday Superconference this weekend!

Jon Beri, Chris Gammell, and Mike Szczys are headed for Pasadena this weekend for the Hackaday Superconference! After a hiatus of several years, we’re excited to get back out into the hardware community and this has become something of a can’t miss event for that crowd.

This is the first time the three of us will be there showcasing Golioth. We’d love to discuss what our next-gen device management can do for you IoT fleet. Let us know you’ll be there using the DevRel email, so we don’t miss a chance to discuss in person.

Open Source RTOS on a Connected ePaper Badge

To kick off the con this Friday we’re presenting our developer training as a Supercon workshop. It focuses on getting started with the Zephyr RTOS.

We’ve been polishing our approach to training all year and this is the culmination of that work. A month ago Chris wrote about the Kasm “container in a browser” experience we’re using to pre-install all the build tools. We’ll be using that approach this weekend so that attendees can be up and compiling within minutes of starting. The workshop will build some muscle memory on the compiling/flashing process, then dive into Devicetree, Pin Control, working with sensors, and the basics of device/cloud interactivity needed in a successful IoT deployment.

The tickets for the workshop sold out right away. If you’re at Supercon, we’d be happy to go through the training with you during “alley-con”. Find us at any time during the weekend to try it out yourself, or even to get a quick badge demo. If you can’t make it to the conference, you can do a self-guided version of the Golioth Developer Training or sign up for future versions of in-person and remote hardware training.

Super-what?

This is the sixth Hackaday Superconference and the first in-person even following a two-year pandemic hiatus. An intimate gathering of fewer than 500 people, everyone you see there has a fascinating backstory, usually involving (or adjacent to) electronic hardware creation. There’s a workshop on designing your own ASICs, talks on wearables, manufacturing, grant-writing for open-source, and the list goes on. Our own Chris Gammell is presenting on his experience as a one-engineer dev shop. Both Mike and Chris helped to kickstart the conference 6 years ago and we’re thrilled that it’s still such a vibrant gathering of hardware enthusiasts.

Almost everyone brings along demos of what we’ve been working on; you can bank on us having a bunch of Golioth demos in our backpacks. There’s also a custom electronic badge, this year it’s an intricate handheld 4-bit computer, complete with a 12-button input register for shifting in your machine-language formatted commands.

Given that there is an input/output expansion header on this badge, it would be a shame if we made it through the weekend without connecting this thing to the Internet in an interesting way. Hit us up on the Golioth Forum thread for this post if you have some ideas on where we can go with that concept.

Take Us for a Test-Drive

We’re not stopping until we’ve spread the word about Golioth. Device management is the piece of IoT ecosystem that companies keep reinventing–a painful and fraught process. Our Dev Tier is free for the first 50 devices.

As your fleet moves from 10 to 100 to 1,000 devices, you face a growing set of problems with handling the data, command and control of the devices themselves, remote firmware updates, and the big one: making sure it remains secure. Give us a chance to show you how we’ve solved these problems, and many you haven’t even thought of yet.

Head over to the Golioth Console to get your free account, then checkout out the Getting Started docs, or jump into the Developer Training we mentioned earlier. Interested in joining a future in-person or remote training? Sign up here.

/by

Golioth showcased at Embedded World 2022

Royalty free map photo by Anthony Beck from Pexels: https://www.pexels.com/photo/close-up-photo-of-wooden-jigsaw-map-4278035/

The conference season is in full swing, and the Golioth team will be showing off device cloud hardware demos at Embedded World in Nuremberg.

With the past few years of virtual meetings, we’re relieved that we can finally connect with our friends and colleagues in person. We’d love to see you swing by the Golioth booth to say hi. You’ll find us as among the Zephyr Project exhibits at Booth #4-170 in Hall 4.

The show floor is going to be pretty hectic, so if you want to get together for an more in-depth conversation, we’re happy to schedule a meeting in advance. Email the DevRel team and let us know.

A preview of the Golioth hardware demos

We had so much fun putting together a set of awesome hardware demos to show what we’ve been working on since coming out of stealth mode a year ago and completing our beta phase back in November. If you’re interested in trying out anything you see here, our Dev Tier is free for your first 50 device!

OpenThread

The new hotness on the IoT block is OpenThread, an open-source implementation of Thread. This mesh networking protocol is officially known as 802.15.4 and it works extremely well with Golioth’s device management cloud—we have already published our demo code, and have a full guide and blog post ready to roll next week while we’re at the conference.

Our demo uses a Raspberry Pi as the “border router”, although any Linux device will work nicely. A Nordic Semiconductor nRF52840 dongle connects to the Pi, acting as the radio co-processor (RCP) so that the Pi can communicate with the other devices on the Thread network. We’re connecting three Laird BT510 nodes (also based on the nRF52840) to build out the network.

These devices all have IPv6 addresses and connect to the wider internet via the border router. Of course Golioth is secure by default, so all communications are encrypted. You get the best features of Golioth, from full-featured data management to over-the-air (OTA) firmware upgrades.

IoT Devices reacting to one another

As we showed at the recent Zephyr Developer Summit, we color-coded all of our demos for easy reference. The Green Demo shows off the interconnected features of Golioth. It’s based around the concept of using smart grow lights in a greenhouse to supplement natural sunlight.

A light intensity sensor reports back the actual readings. If it’s a cloudy day, lower intensity readings are detected and the grow lights automatically swing into action, modulating their power usage to dial in the target light intensity. This saves energy, while ensuring the greenhouse yield and harvest dates aren’t affected by the fluctuation of natural light.

The target intensity can be set remotely through the Golioth Console. But for fun, we also made a dashboard you can load on your phone to adjust the setting.

Output Streams for your cloud team’s favorite platform

Your device data is stored on the Golioth Cloud and easy to work with. But your cloud team may already have infrastructure in place on a platform like Microsoft Azure, Amazon AWS, or Google Cloud Platform. No sweat! We can seamlessly connect to those with our output streams feature.

The Blue demo at our Embedded World booth shows off the ability to select which weather sensors (temperature, humidity, pressure) are being recorded, and select between sending the data to any of the three cloud platforms. This is also a great option if your team ever decides to move to a different cloud. You can put multiple output streams in place in order to test out the new setup before moving your production servers.

Mapping data and visualizing everything

Golioth’s Orange Demo started as a way to show that commercially-available hardware can be used with our platform. The Nordic Thingy91 is a cellular device that includes GPS, a sensor suite, and a rechargeable battery. This demo uses it as an asset tracker, caching GPS readings and uploading them to Golioth every few minutes.

But data is only useful if you can do something with it. We used the Grafana platform to visualize the data on a map interface. In fact, we have built up Grafana dashboards for all of the demos. It’s easy to make the data wow your customers with this interface. You can plot historical data using our REST API, and real-time data appears as soon as it’s received thanks to the open source Grafana plugin we wrote earlier this year.

Embedded World through Golioth’s eyes

Alas, only a small part of the IoT community will make it to Embedded World this year. Don’t worry, we’ll be posting video walkthroughs of our demos on our YouTube channel shortly after the conference. But don’t forget to follow us on Twitter as well, we’ll make sure to share the coolest things we see at the conference. And the offer to set up a chat is still good, even if it’s not in real life—the Developer Relations hotline is open!

/by
, , ,

Golioth Showcase at ZDS

Hello from ZDS!

This week the Golioth team is at Zephyr Developer Summit. Previously we announced that we’ll be there and shared the talks we are presenting. We will post those shortly after the conference takes place. In the meantime, let’s recap how we got here in the first place and share a little bit more about what we’re showcasing.

Why Zephyr?

In short, because it helps our users. We are members of the Technical Steering Committee (TSC) and have been almost since the inception of the company. We built our first Device SDK on top of Zephyr because of the broad hardware support and high level integration of Golioth features into the Real Time Operating System (RTOS).

The assertion that “Zephyr helps our users” might be extra frustrating to beginners: Zephyr—and RTOSes more broadly—represents a tricky new set of skills that might be foreign to firmware or hardware engineers. For beginners coming from the hobby space, it can be an extra rude introduction into the world of command line compilation and large ecosystem. However, connecting to the internet is a difficult task, especially for custom hardware: we think that Zephyr represents a great first step towards managing those devices over time. We are committed to pushing for more user-friendly code and methods from the Zephyr foundation, and we will continue to publish best practices on our blog and our YouTube channel to help people get connected.

Showcase

One thing we’re excited about is showcasing how Golioth works to members of the community. We have been developing different “color coded” demos to make them a bit more memorable for folks that stop by our booth. Each of these demos feature a hardware (device) component and a dashboard component, in order to visualize the data that is on the Golioth Cloud.

This is the first time we have showcased the “Aludel”, which is our internal platform for prototyping ideas and switching out different development boards and plug-in sensors. We will post more about this in the future, including our talk on the subject.

Red Demo

The Red Demo is our showcase of devices running OpenThread on Zephyr; this is part of our larger interest in Thread, which we see as a very interesting way to connect a large range of sensors to the internet securely. We have been excited to show how we can use low power devices like the Nordic nRF52840 to communicate directly with the Golioth Cloud.

The devices we are using in this case are off-the-shelf multi-sensor nodes from Laird called the BT510. This hardware has additional sensors on the board which we integrated with LightDB Stream to send time-series data back to Golioth. This was fast work, thanks to Laird’s Zephyr support, it was as simple as calling out the board when we compiled the demo firmware.

We then capture the data from these on the Red Demo Dashboard, showing both historical and live data for the sensors.

 

Green Demo

The Green Demo showcases LightDB State, our real-time database that can be used to control a wide range of devices in a deployment. On the device side, it uses the Aludel platform to measure a light sensor, as would happen in a greenhouse. There is also a secondary Zephyr-based device inside a lamp, representing a grow light that might be inside a grow house. The lamp is set up to “listen” to commands from another node, in this case the Aludel.

LightDB State is used to control elements like “update rate” to control regulate flow of information. It also lets us monitor critical device variables on an ongoing basis and set up logic on the web to take actions as a result. Command and control variables can be set from multiple places, including a custom mobile app, the Golioth Console, a visualization platform, a web page, or (as is the case here) even from another device!

Our Green Demo Dashboard (below) again showcases live and historical information, as well as the current status of the connected lamp.

As an added bonus, we control some of the logic on the back end from a Node-RED instance, including control logic. That takes the light intensity sensor output and calculates how bright the lamp should be. Because this is written in Node-RED, we can include an additional input from a mobile app to control the “target intensity”. In this way, people at the booth can adjust the lamp output if the exhibition space is brighter or darker. Plus…it looks cool!

Blue Demo

The Blue Demo helps to showcase how data migrates into and out of Golioth. Using Output Streams, you can export all cloud events to 3rd party providers like AWS, Azure, and Google Cloud. Buttons on the Blue faceplate switch the output being sent back to the cloud. The sensor readings being exported to all 3 clouds can be turned on or off by changing which variables are exported from the device.

On the device side, we capture a sensor using our Aludel platform. The sensor is a BME280 (in-tree sensor in Zephyr), going through a feather form-factor dev board, talking to the network over a WizNet W5500 Ethernet external chip to the network. The Blue Demo Dashboard showcases the live data, and of course the data is being exported simultaneously to the 3 cloud platforms in real-time.

Orange Demo

Golioth is a “middleware” built on top of Zephyr RTOS, which means you can use it to implement new features on top of already-existing hardware. This demo uses the Nordic Semiconductor Thingy91 with custom firmware to send GPS data back over the cellular network to Golioth using LightDB Stream. This demo also has Golioth Logging and Device Firmware Update, which are easy to add to any project as an additional service for troubleshooting or in-field updates.

On the dashboard side, we wanted different ways to showcase this data, including “latest update”. Having access to the raw data is useful for anyone wanting to try asset tracking applications. We’re excited to be able to showcase this data as it dynamically flows into the Golioth Console and back out to the Grafana dashboard.

Future showcases

We’re excited to be showcasing our demos at the Zephyr Developer Summit, but these are moving targets! We will continue to update and pull in new feature for future events. We will be at Embedded World in two weeks (June 20-24th) and will have many of the same demos there.

/by
, ,

Golioth will be at the Zephyr Developer Summit

The Zephyr Developer Summit (ZDS) is coming up June 7th-9th 2022 in Mountain View California at the Computer History Museum. Golioth will be there and we’re very excited to interact with fellow users, developers, and stakeholders in the open source real-time operating system (RTOS) known as Zephyr!

We love Zephyr

People reading this blog will not be surprised to know that we love Zephyr. We write about it quite often and it is the basis of our Zephyr-based SDK. As a result, many of our samples and demos are built using Zephyr. We often talk about Zephyr being an indicator that a hardware device will work with Golioth; all you need is a network connection, a board running Zephyr, and little bit of storage overhead to hold the Golioth code. It’s the hardware interoperability of Zephyr that allows Golioth users to target a wide range of platforms, including microcontrollers from Espressif, Infineon, Intel, Microchip, NXP, Nordic Semiconductor…and more being added every day!

Our plans at ZDS

We’re excited to be returning to ZDS. Last year we officially announced Golioth to the world at ZDS, and talked about how our platform works within the Zephyr ecosystem. We hope to have another year of connection, this time in person and online. Let’s look at how we’ll be participating.

Sponsoring/Showcase

We are helping to sponsor ZDS this year. We believe in the mission of the project and the conference and wanted to be part of it. We will also be showcasing Golioth at a vendor table at the conference. If you would like to see Golioth in action, you can stop by at any time to ask questions and see demos. You can, of course, also try out Golioth at any time using our Dev Tier plan, which gives anyone up to 50 free devices on the platform.

Giving Talks

We will be presenting a range of talks at ZDS:

  • What chip shortage? How we use Zephyr for truly modular hardware
    • Chris and Mike from Developer Relations will highlight the Aludel, an internal hardware platform we’ve built as a customizable solution that can switch out hardware pieces without major redesign. This modular hardware showcases a path for hardware and firmware teams to unify their codebase using Zephyr while targeting a wide range of hardware. Being able to swap out a sensor, microcontroller, or radio but keep the main board, or go from outdoor air monitoring to indoor monitoring is really powerful. Zephyr makes it much easier to create alternate builds and manage firmware pipelines to hardware variants.
  • Connecting Zephyr Logging to the Cloud over Constrained Channels
    • Our resident Zephyr expert Marcin will cover an approach to preparing Zephyr logging messages for transmission through a constrained networking layer, such as a cellular connection. This includes CBOR compression on all logging messages, including special handling around binary payloads. There is also an interface to a CoAP library to take advantage of smaller payloads and standardized format to a cloud backend. Additional tooling is included for selectable acknowledgement of messages, to handle high priority and high traffic scenarios.
  • Zephyr <3 Internet: How Zephyr speeds implementation for new IoT devices
    • I (Jonathan, CEO) will make a case to people outside of the Zephyr ecosystem on why they should adopt the platform and contrast the difficulties to other RTOS solutions. These networking concepts are so baked-in that it fundamentally changes the cost for anyone buying into the ecosystem. From vendors adding modems to developers building apps, the underlying framework saves time and engineering complexity.
  • End-to-end IoT development with Zephyr
    • Founding engineer Alvaro will cover the options for getting a Zephyr app connected (WiFi, Ethernet, Cellular), selecting the right data encoding (JSON/CBOR), securing the data transfer (DTLS/TLS), and choosing a protocol (HTTP/MQTT/COAP). But that’s not the end of the story, the cloud needs to manage devices allowed to connect, consume the data being received, open up options for using that data, and be aware of the continued state of the hardware. And once you have the data you need to build a user-facing application on top of it.

Giving a workshop

Hands-on demos are a critical part of understanding a new system. This is true of both Zephyr and of Golioth. We wanted to showcase how Golioth works to Zephyr users, while also helping people get a real piece of hardware talking to the cloud. We’re giving a workshop called “Hands-on with Zephyr-based IoT Hardware – Data Goes in, Data Comes Out, Data Goes Up“.  This is a hands-on developer training showing how to get a finished piece of hardware utilizing the various features that Zephyr has to offer. The main thrust of the training is getting up and running with the Zephyr toolchain, implementing examples on a piece of hardware (provided), and interacting with cloud services. The user will learn about various abstraction layers around things like CoAP and CBOR, and experience a real world example of a smart device talking back to the Golioth Cloud. This will also expose the user to web-side technologies and how they can export data to external commercial services like AWS, Azure, and GCP.

Meeting with users and partners

We love our community and are always looking to meet new people within it. Interested in setting up a time to discuss something? Email [email protected]

Should you attend?

If you’re a someone already developing for Zephyr and pushing code upstream, this is the best opportunity to meet with others from the community and continue to build your skills. We think this is a perfect event for you!

If you’re new to Zephyr, the content can seem a bit intimidating…but fear not! The first half day of the conference (June 7th starting at 1 pm) is the “Intro to Zephyr” day, and this is a great introduction to the platform and how you can build your skills using Zephyr. There are also reduced cost tickets for students, if you’re still learning. We think if you’re looking to build a product with Zephyr in the future, or already are building with Zephyr, it’s a worthwhile experience to be there.

See you there!

We’re excited to meet more people and hear the other great talks that will be happening at the 2022 Zephyr Developer Summit. While we definitely plan to share the talks after the fact, and you can also participate in the virtual conference, we still hope to see you there!

/by