Skip to primary content
Skip to secondary content
Contact Us Today! 248-719-6850 | [email protected]
Contact

BeningoEmbedded Group

Main menu

  • Start Here
  • About
    • About Jacob
    • Events
  • Services
    • Services Overview
    • Consulting
    • Firmware
    • Training
    • Workshops
  • Clients
    • Clients
  • Insights
    • Insights Overview
    • Articles
    • Toolkits
    • Webinars
    • Videos
    • White Papers
    • Newsletter
    • Conferences
  • Store
    • Store Overview
    • Books
    • Embedded Software
    • Online Courses
    • Quick Pay
    • Cart
  • Blog

Simplifying Concepts.
Accelerating Innovation.

Jacob's Blog

Category Archives: Software Techniques

Post navigation

< Older Posts
January 19, 2023

Expert Best Practices For Developing A Coding Style Guide

This post will discuss developing a coding style guide and how to automatically enforce it to help you improve software quality and reduce time to market. Continue reading →

Read More >>>
December 29, 2022

Embedded Software Trends to Watch in 2023

As 2022 creeps to a close, many of you probably reflect on what went right and what didn’t. You’re probably looking to the future and...

Read More >>>
December 22, 2022

5 Tips for Designing an Interface in C

An everyday activity for an embedded software developer is designing an interface for the software component they are working on. An interface describes the interactions...

Read More >>>
December 8, 2022

C++ Project Setup using STM32 Microcontrollers

C++ has been slowly gaining momentum within the embedded systems space. You’re probably well aware that many microcontroller vendors provide C libraries and interfaces to...

Read More >>>
November 24, 2022

5 C++ Tricks for C Programmers

Over the past several years, C++ has become a more popular language to use in embedded systems than C. Don’t get me wrong, C will...

Read More >>>
November 3, 2022

Considerations for using an RTOS in a Bootloader

A bootloader is a light-weight application that manages the boot and update process of a microcontroller-based product. The bootloader is used to authenticate and verify...

Read More >>>
October 27, 2022

Official Release: Embedded Software Design

It’s official! My latest book Embedded Software Design has been released in paperback and electronically! In an earlier post, Book: Embedded Software Design, I provided...

Read More >>>
October 13, 2022

Developing Machine-Learning Applications on the Raspberry Pi Pico

The Raspberry Pi Pico is a versatile, low-cost development board that applies to many applications....

Read More >>>
October 6, 2022

5 Software Architecture Killers

The chip shortage has forced many embedded systems companies to rethink their software architecture. Many embedded systems have tightly coupled embedded software that makes the...

Read More >>>
September 29, 2022

Firmware Error Handling using Do while Loops

An interesting area of a code base to examine is error handling. I’ve found that many firmware and embedded software projects don’t do an excellent...

Read More >>>
September 22, 2022

Are Multiple Languages Needed for Embedded Systems?

Over the last couple of months, I’ve been writing several articles at embedded.com that explore programming languages and embedded software architecture. For example, in Is...

Read More >>>
September 15, 2022

4 Tactics to Unit Test RTOS Tasks

More than 50% of all embedded software projects use Real-time Operating Systems (RTOS). Unfortunately, using an RTOS can pose several problems to developers looking to...

Read More >>>

Post navigation

< Older Posts

Categories

  • Artificial Intelligence
  • Beningo Embedded News
  • Book Reviews
  • Bootloaders
  • C Concepts
  • C++ Concepts
  • Career Management
  • Conferences
  • Consulting
  • Defect Management (Debugging)
  • Design Cycle
  • Design News CEC
  • Digital Signal Processing (DSP)
  • Downloads
  • Driver Design
  • Embedded Basics
  • Hardware
  • IoT
  • Low Power Design
  • Machine Learning
  • Micro Python
  • Optimization
  • Platforms
  • Prototyping
  • Q&A
  • RTOS
  • Rust
  • Security
  • Software
  • Software Techniques
  • Testing
  • Tips and Tricks
  • Tools
  • Uncategorized
  • Webinars
  • White Papers

Archives

  • ► 2023 (1)
    • ► January (1)
      • Expert Best Practices For Developing A Coding Style Guide
  • ► 2022 (24)
    • ► December (3)
      • Embedded Software Trends to Watch in 2023
      • 5 Tips for Designing an Interface in C
      • C++ Project Setup using STM32 Microcontrollers
    • ► November (2)
      • 5 C++ Tricks for C Programmers
      • Considerations for using an RTOS in a Bootloader
    • ► October (3)
      • Official Release: Embedded Software Design
      • Developing Machine-Learning Applications on the Raspberry Pi Pico
      • 5 Software Architecture Killers
    • ► September (4)
      • Firmware Error Handling using Do while Loops
      • Are Multiple Languages Needed for Embedded Systems?
      • 4 Tactics to Unit Test RTOS Tasks
      • A Simple Script to Automate C Module Creation
    • ► August (1)
      • 3 Tips for Evaluating your Codes Quality
    • ► June (3)
      • CEC - Embedded Software Design Techniques
      • 3 Tips for Data-Centric Software Design
      • 3 Tips for using Rapid Application Development (RAD) Tools
    • ► May (2)
      • How to Debug a Hard Fault on an Arm Cortex-M
      • 3 Tips for Embedded Software Configuration Management
    • ► April (2)
      • 5 Tips for Versioning Embedded Software
      • 3 Overlooked Embedded Software Elements
    • ► March (2)
      • 5 Tips for Rapid Prototyping with the Raspberry Pi Pico
      • 5 C++ Tricks for C Programmers
    • ► February (1)
      • 5 RTOS Design Best Practices
    • ► January (1)
      • 3 Tips for Successfully Simulating Embedded Software
  • ► 2021 (12)
    • ► December (1)
      • Using Docker to Setup an STM32 Build Environment
    • ► November (1)
      • CEC- Embedded Software Development Tools and Techniques
    • ► October (1)
      • CEC - UML-Based Software Architecture Design
    • ► September (1)
      • 5 Skills Every Embedded GUI Developer Needs
    • ► July (1)
      • 3 More Tips for Speeding Up Framework Interrupt Handlers
    • ► June (2)
      • CEC - Best Practices for Designing Real-Time Embedded Systems
      • 3 Tips for Speeding Up Interrupt Handlers
    • ► May (1)
      • There is No Hardware
    • ► April (1)
      • Finding a Buffer Overflow issue using a Map File
    • ► March (1)
      • A Simple, Scalable RTOS Initialization Design Pattern
    • ► January (2)
      • 3 Tips for Writing External Device Drivers
      • Simulating Your Way to Embedded Software Success
  • ► 2020 (17)
    • ► December (2)
      • 5 Best Practices for Over-the-Air (OTA) Updates
      • Over-the-Air (OTA) Updates with AWS and FreeRTOS
    • ► November (1)
      • 3 Common Challenges Facing RTOS Application Developers
    • ► October (2)
      • 5 Tips for Developing an RTOS Application Software Architecture
      • 5 Tips for Building a Modern Telemetry GUI
    • ► August (3)
      • Simplified Software Development using MCU Configurators
      • One “RTOS” to Rule them All
      • 7 Tips for Mastering Git
    • ► July (1)
      • 5 Best Practices for Utilizing Open Source Software
    • ► June (1)
      • 5 Keys to Successfully Managing Legacy Code
    • ► May (1)
      • 4 Uses for Assembly Language
    • ► April (2)
      • Book Review: MicroPython Projects
      • Using Callbacks with Interrupts
    • ► March (2)
      • 7 Steps to Create a Stack Monitor
      • 5 Tips for Designing a Smart Watchdog
    • ► January (2)
      • 7 Steps to Create a Reusable Debounce Algorithm
      • 3 Advantages to using a Multicore Microcontroller
  • ► 2019 (10)
    • ► December (1)
      • 5 Tips for Modernizing Legacy Code
    • ► November (1)
      • 5 Tips for Versioning Embedded Systems
    • ► October (2)
      • Developing an Embedded Software Build Pipeline
      • 5 Roles for Python in Real-time Embedded Systems
    • ► July (1)
      • 10 Pain-free Steps to Configure an Interrupt Controller
    • ► May (1)
      • CEC - Designing Embedded Systems using MicroPython
    • ► February (3)
      • 5 Tips for Getting Started with Digital Signal Processing (DSP) on Arm Cortex®-M CPUs
      • 5 Embedded System Characteristics Every Engineer Should Monitor
      • The Hardware Abstraction Layer Design Process
    • ► January (1)
      • 5 Benefits to replacing analog components with DSP software
  • ► 2018 (11)
    • ► November (1)
      • 7 Tips for Getting Started with TrustZone for MCU’s
    • ► September (1)
      • The Firmware Conundrum: Build or Buy
    • ► August (1)
      • Writing a Multi-Port ITM Function to Improve Debugging
    • ► July (1)
      • 7 Tips for Developing Great API’s
    • ► June (3)
      • Getting Started using Arm® TrustZone® for Cortex®-M Processors
      • Improve Debug Efficiency with the ITM
      • 3 Ways to Perform a Worst-Case Stack Analysis
    • ► May (1)
      • Evaluating and Mastering Real-Time Debugging Techniques
    • ► April (1)
      • Amazon FreeRTOS: Behind the Scenes
    • ► January (2)
      • Bugs and Errors and Defects, Oh My!
      • 5 Challenges facing over-the-air updates using MCUs
  • ► 2017 (15)
    • ► November (2)
      • Embedded Basics - Hash Fundamentals
      • Tools - Getting a grip on Semi-hosting
    • ► October (1)
      • CEC - Transitioning from C to C++
    • ► September (2)
      • Tips and Tricks - 5 Tips for Developing Real-time C++ Applications
      • Developing Reusable Firmware - A Practical Guide to API's, HAL's and Drivers
    • ► August (4)
      • Embedded Basics - The Difference between Restart and Reset
      • Tips and Tricks – Jumping from the Bootloader to the Application Code Cleanly
      • Getting Started Writing Portable Firmware
      • Embedded Basics - Callback Functions
    • ► June (1)
      • 5 Forbidden C Features that just might not be
    • ► May (1)
      • Managing the Heap Space in Micro Python
    • ► April (3)
      • Embedded Basics - Setting up Tracealyzer to Debug FreeRTOS Applications
      • Tips and Tricks - 7 Cardinal Sins of Embedded Software Development
      • Tools - The RTOS Selection KT Marix
    • ► January (1)
      • Tips and Tricks – 7 Tips for Meeting Real-time Deadlines
  • ► 2016 (10)
    • ► December (1)
      • Tools – The Device Firmware Update (DFU) Utility
    • ► October (1)
      • Slowing Down to Go Faster
    • ► August (1)
      • Ternary Operator versus the if/else statement ...
    • ► July (2)
      • 7 Tips for using an RTOS
      • Tools - Optimizing Firmware using DRT
    • ► May (1)
      • Tools - Percepio Tracealyzer
    • ► April (1)
      • Mastering the 8 Pillars of Embedded Software
    • ► February (2)
      • Tools - Embedded Software Start-up Checklist
      • Understanding Embedded System Failure Rates
    • ► January (1)
      • Tips and Tricks - Writing Portable Code using Compiler Intrinsics
  • ► 2015 (20)
    • ► December (1)
      • Understanding volatile access warnings
    • ► November (1)
      • Tips and Tricks - 7 Tips for creating and using portable types
    • ► October (1)
      • Using Conditional Complexity to Test Embedded Software
    • ► September (1)
      • Embedded Basics - Values and Side Effects
    • ► August (2)
      • CEC - Writing Portable and Robust Firmware in C
      • Tips and Tricks - When to ASSERT or not ASSERT ...
    • ► July (2)
      • Tips and Tricks - Introduction to ARM CMSIS
      • Tools - Open Source Circular Buffers
    • ► June (3)
      • 7 Steps to Customizing printf with a Circular Buffer
      • Embedded Basics - 5 Tips for using portable types
      • Tips and Tricks - MicroPython
    • ► May (2)
      • Design News CEC - Mastering the ARM Cortex-M Processor
      • Tips and Tricks - Taking Advantage of Templates
    • ► April (3)
      • A Reusable Button Debounce Module
      • Embedded Basics - Blocking vs Non-Blocking Drivers
      • Tips and Tricks - An API for Interrupts
    • ► February (2)
      • Improving Code Integrity with a Stack Guard
      • Design News CEC - Baremetal C Programming for Embedded Systems
    • ► January (2)
      • Tips and Tricks - 8 Reserved Words to Avoid in C
      • Improving Code Integrity Using FILL
  • ► 2014 (9)
    • ► December (2)
      • Device Drivers Whitepaper
      • CEC Introduction to Embedded Software Architecture Materials
    • ► November (2)
      • Embedded Basics - Using Pointer Arrays to Map Peripherals
      • Tips and Tricks - Using enum over #define
    • ► October (1)
      • Bootloader Design Resources
    • ► September (1)
      • Tips and Tricks - Sleep on Exit
    • ► August (1)
      • Embedded Software with Python and the Raspberry Pi
    • ► February (1)
      • NXP Kinetis-L Framework Example
    • ► January (1)
      • Understanding Portable Types
  • ► 2013 (11)
    • ► September (1)
      • State Machines with Function Pointers
    • ► August (1)
      • Task Scheduling with Function Pointers
    • ► July (2)
      • A Review of for Loops
      • The World's Shortest C Program
    • ► May (1)
      • An Introduction to Function Pointers
    • ► April (6)
      • Pointer Arrays - A Timer Driver Part 2
      • Pointer Arrays - A Timer Driver Part 1
      • Using the Static Keyword in C
      • Creating Configuration Tables to initialize Peripherals
      • A few pointers - Part 3
      • A few pointers - Part 2
  • ► 2012 (1)
    • ► December (1)
      • A few pointers - Part 1

Latest Blogs

  • CEC – Embedded Software using Rust
  • The differences you need to know about OSEK Compliant RTOS
  • Expert Best Practices For Developing A Coding Style Guide
  • Everything You Need To Know About Semaphores And Mutexes
  • 5 Simple Embedded Software Classifications You Need to Know
© 2023 Beningo Embedded Group. All Rights Reserved.
Privacy Policy

GET EXPERT TIPS & ADVICE DIRECTLY FROM JACOB

Sign Up for Exclusive News and Updates

×
 

Loading Comments...