Change is in the Air

You may have noticed that our posting has slowed down this year. That's because our 8 month old baby and a consulting business have left little free time for the website.

We're changing that.

Out of all the work we do, we get the most joy out of creating high-quality embedded content and sharing it with the world. We want to continue to support the embedded community by sharing our hard-won knowledge. We want to focus on writing articles, building libraries, and creating learning materials to help embedded systems engineers reach the next level.

In order to pour the majority of our effort into the website and allow it to flourish, we’ll need support from our readers. We’ll be spending the next month updating the website with a member’s only area and new content.

This article will be the last post on the website in its current incarnation.

What's Staying the Same

Even though we're re-launching the site, some things won't change.

The blog will remain free, and we will commit to publishing at least one new article per week. The newsletter will remain free. We will also maintain our commitment to never place advertisements, corporate sponsors, or product shilling articles on our website. We value our ability to always speak truthfully.

What's Changing

While the existing website structure and content will largely remain unchanged, we will augment the Blog Archive and blog sidebar with additional ways to discover and explore existing content.

We are also adding membership tiers to support the website. Members will have exclusive access to new areas of the site. Initially, members will receive access to a members-only forum and the all new Embedded Field Atlas, a curated guide for learning embedded systems concepts.

The Field Atlas will feature a roadmap of foundational skills for embedded systems developers to master. It will also contain the thousands of links we’ve collected on hundreds of embedded topics. Information will be organized so you can quickly find what you need. The Field Atlas content and layout will be similar to our existing resource collections.

The Glossary will be incorporated directly into the website. Defined terms and acronyms will be highlighted in articles on the website. Hovering over glossary terms will show a tooltip providing a brief definition or explanation of the term or acronym. Members will be able to access a term page with additional information and links related to the topic. Members will also be able to suggest new terms for the Glossary and new categories for the Field Atlas.

Other member benefits include: stickers, free access to the yearly "Best of" e-book collections, discounts for Embedded Artistry courses and products, discounts for partner companies, and more.

What's Planned for the Future

Once we wrap up the initial re-launch, we have a roadmap of website content we will begin developing.

We will start by building hands-on courses that teach practical embedded systems skills, such as mastering the art of reading datasheets, writing device drivers, automated quality enforcement, unit testing embedded code, and setting up an RTOS for the first time. Courses will be available to everyone and members always receive a discount.

We will also release a members-only video library, featuring standalone video lessons that showcase our approach to building, debugging, and testing embedded systems.

Our free articles will continue to flow weekly - we still have countless ideas to explore with our readers.

See You Soon

Thank you for taking this journey with us. As the re-launch effort progresses, we’ll release more information about membership tiers and the new site on Twitter and in the Newsletter. We look forward to seeing you on the new site!

Article/Lecture Recommendation: Grady Booch's "The History of Software Engineering"

I'm a member of the IEEE, and I like to read the monthly Edge magazine which is put out by the IEEE Computer Society. This month, the feature article was "The History of Software Engineering" by Grady Booch.

Grady walks us through a brief overview of the history of computing. Grady's account spans from the late 19th century's human computers, through the first digital computers in the 1940s, a review of who's-who in software engineering, and ending with a wise note on the fundamentals that govern our field.

If you are a member of the IEEE, definitely read this article. If you're not a member, never fear: the article was adapted from an ACM lecture that is publicly available.

I enjoyed learning about the early beginnings in human computation efforts, and there are excellent quotes to reflect on. But my favorite aspect of this article is the name dropping. I am always interested in reading the foundational texts. I want to understand the foundational thoughts that shaped our present situation. I hope you'll select a few people whose names are unfamiliar and study them. I scrawled out my own (long!) list of foundational names and works to research:

If you're curious about the history of software engineering, you'll enjoy reading the article, listening to the lecture, or both!

My Highlights

A question that we will need to answer in the coming years:

How do we best architect systems with parts whose operation we cannot explain or fully trust?

Grady hits the nail on the head. This situation is why blanket advice is never all that helpful.

Some software is like building a doghouse: you just do it, without any blueprints, and if you fail, you can always get another dog. Other software is like building a house or a high-rise: the economics are different, the scale is different, and the cost of failure is higher.

Much of modern software engineering is like a city: there is room for radical innovation, but you are constrained by the past as well as the cultural, social, ethical, and moral context of everyone else in the city.

We must focus on mastering the bolded skills:

One thing I do know. No matter the medium or the technology or the domain, the fundamentals of sound software engineering will always apply: craft sound abstractions; maintain a clear separation of concerns; strive for a balanced distribution of responsibilities; seek simplicity. The pendulum will continue to swing - symbolic to connectionist to quantum models of computation; intentional architecture or emergent architecture; edge or cloud computing - but the fundamentals will stand.

Grady ends with pure magic:

Software is the invisible writing that whispers the stories of possibility into our hardware.

Further Reading

Motorola FLEX Protocol References

I've been working on a project involving the Motorola FLEX paging protocol. There is plenty of useful information out there about implementing the FLEX protocol. Strangely enough, in the age of modern search engines I could not easily find many of these resources. Because of our struggle to

Table of Contents:

  1. About FLEX
  2. FLEX Patents
  3. Useful Resources
  4. Open-Source Projects
  5. Our Observations

About FLEX

If you need an introduction to FLEX, start here for basic information:

FLEX Patents

The following patents are helpful for understanding the FLEX protocol in detail:

  • US5555183 - describes the FLEX messaging structure and frame collapsing
  • US5168493 - describes the signalling protocol for sending FLEX transmissions

Useful Resources

These were the most helpful documents for implementing a FLEX decoder:

Open-Source Projects

These projects can serve as useful references if you run into a problem decoding FLEX messages:

Our Observations

The long capcode decoding scheme described in the patent is incorrect. The conversion scheme described in the ARIB standard seems to be what is actually used by our test equipment. The actual conversion scheme that worked for us is:

#define LONG_CAPCODE_CONVERSION 2068480 // Patent says: 2067456, but that math doesn't work

uint32_t rawAddrToLongCapcode(uint32_t addr1, uint32_t addr2)
    uint32_t addr2_complement = (uint32_t)~addr2;
    // We have to truncate because we have bit 0x80000000 set and it shouldn't be
    return (((addr2_complement << 15) + LONG_CAPCODE_CONVERSION + addr1) & 0x7FFFFFFF);