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: Embedded Basics

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 >>>
January 12, 2023

Everything You Need To Know About Semaphores And Mutexes

post will explore everything you need to know about Semaphores and Mutexes. You'll learn what they are, where to use them, and how to avoid common issues. Continue reading →

Read More >>>
January 5, 2023

5 Simple Embedded Software Classifications You Need to Know

Have you ever had a conversation with your boss or a colleague about embedded software only to discover that you were talking past each other?...

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 1, 2022

5 Elements to a Secure Embedded System – Part #5 Secure Storage

In “5 Elements to a Secure Embedded System – Part 4 Secure Bootloaders,” we continued...

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 17, 2022

5 Tips for Adopting Agile in Embedded Systems

You’ve probably heard many times that Agile doesn’t work for embedded software development. Embedded software...

Read More >>>
November 10, 2022

5 Recommendations for Selecting the Right Embedded Programming Langauge

Over the past few years, the number of programming languages used for embedded development has...

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 >>>
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 8, 2022

A Simple Script to Automate C Module Creation

During development, a very common activity is to create new C modules. Creating a new C module often comes with a bunch of repetitive work....

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
  • Security
  • Software
  • Software Techniques
  • Testing
  • Tips and Tricks
  • Tools
  • Uncategorized
  • Webinars
  • White Papers

Archives

  • ► 2023 (3)
    • ► January (3)
      • 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
  • ► 2022 (23)
    • ► December (3)
      • Embedded Software Trends to Watch in 2023
      • 5 Tips for Designing an Interface in C
      • 5 Elements to a Secure Embedded System – Part #5 Secure Storage
    • ► November (4)
      • 5 C++ Tricks for C Programmers
      • 5 Tips for Adopting Agile in Embedded Systems
      • 5 Recommendations for Selecting the Right Embedded Programming Langauge
      • Considerations for using an RTOS in a Bootloader
    • ► September (2)
      • Firmware Error Handling using Do while Loops
      • A Simple Script to Automate C Module Creation
    • ► August (2)
      • 3 Tips for Evaluating your Codes Quality
      • The Secret Embedded Software Definition Experts Use
    • ► July (1)
      • CEC - How to Select the Right Microcontroller for an Application
    • ► June (2)
      • 5 Strategies for Minimizing Debug Time
      • 3 Tips for Data-Centric Software Design
    • ► May (3)
      • How to Debug a Hard Fault on an Arm Cortex-M
      • Simple Tricks to Minimize “Crossed-Wire” PCB Rework
      • 3 Tips for Embedded Software Configuration Management
    • ► April (3)
      • 5 Tips for Versioning Embedded Software
      • 3 Overlooked Embedded Software Elements
      • 5 Tips for Becoming More Agile
    • ► March (2)
      • The Ternary Operator Revisited
      • 3 Strategies for Embedded Software Error Handling
    • ► February (1)
      • Getting Started with Cpputest for Embedded Applications
  • ► 2021 (12)
    • ► November (1)
      • 5 Tips for Optimizing GUIs in Industrial Applications
    • ► July (2)
      • Programming the STM32 Option Bytes using SEGGER J-Flash
      • 3 More Tips for Speeding Up Framework Interrupt Handlers
    • ► June (2)
      • 3 Tips for Speeding Up Interrupt Handlers
      • Understanding Weak Symbols
    • ► May (1)
      • There is No Hardware
    • ► April (1)
      • Finding a Buffer Overflow issue using a Map File
    • ► March (2)
      • Celebrating the Microprocessors 50th Birthday
      • A Simple, Scalable RTOS Initialization Design Pattern
    • ► February (2)
      • 3 Strategies for Handling Errors in Embedded Software
      • Announcing the 2021 Embedded Online Conference
    • ► January (1)
      • 3 Tips for Writing External Device Drivers
  • ► 2020 (15)
    • ► December (1)
      • 5 Best Practices for Over-the-Air (OTA) Updates
    • ► November (2)
      • How to Organize a Firmware Project
      • 3 Tips for Validating Sensor and Communication Data in Embedded Systems
    • ► August (3)
      • Simplified Software Development using MCU Configurators
      • One “RTOS” to Rule them All
      • 7 Tips for Mastering Git
    • ► July (2)
      • Cyclomatic Complexity Measurements with pmccabe
      • 5 Best Practices for Utilizing Open Source Software
    • ► June (1)
      • Is the war between C and C++ Over?
    • ► May (2)
      • 4 Uses for Assembly Language
      • A Microchip PIC16F84 LED Sequencer – Part 1
    • ► April (2)
      • Using Callbacks with Interrupts
      • 5 Techniques to Delay Code Execution
    • ► March (1)
      • 5 Tips for Designing a Smart Watchdog
    • ► January (1)
      • 7 Steps to Create a Reusable Debounce Algorithm
  • ► 2019 (11)
    • ► November (3)
      • 3 Painless Tips for Writing Documentation
      • 5 Tips for Versioning Embedded Systems
      • The 8 Pillars of Embedded Software
    • ► October (2)
      • Developing an Embedded Software Build Pipeline
      • 5 Roles for Python in Real-time Embedded Systems
    • ► September (1)
      • 7 Sections Every Company Coding Standard Should Include
    • ► July (2)
      • Getting Started with JSON for Embedded Developers
      • 10 Pain-free Steps to Configure an Interrupt Controller
    • ► April (1)
      • 7 Tips for Creating a Reliable Embedded System
    • ► February (1)
      • The Hardware Abstraction Layer Design Process
    • ► January (1)
      • 10 Tricks for Documenting Embedded Software
  • ► 2018 (4)
    • ► July (1)
      • 7 Tips for Developing Great API’s
    • ► June (1)
      • 3 Ways to Perform a Worst-Case Stack Analysis
    • ► May (1)
      • Evaluating and Mastering Real-Time Debugging Techniques
    • ► January (1)
      • 7 Essential skills for firmware engineers
  • ► 2017 (14)
    • ► December (1)
      • Embedded Basics - Firmware Beautification
    • ► November (1)
      • Embedded Basics - Hash Fundamentals
    • ► October (1)
      • Embedded Basics - The Arm Security Manifesto
    • ► September (2)
      • Embedded Basics - 7 Tips for Managing RTOS Memory Performance and Usage
      • Developing Reusable Firmware - A Practical Guide to API's, HAL's and Drivers
    • ► August (3)
      • Embedded Basics - The Difference between Restart and Reset
      • Getting Started Writing Portable Firmware
      • Embedded Basics - Callback Functions
    • ► June (1)
      • 5 Revision Control Best Practices
    • ► May (1)
      • Embedded Basics - Developing Reusable Firmware
    • ► April (1)
      • Embedded Basics - Setting up Tracealyzer to Debug FreeRTOS Applications
    • ► March (1)
      • Embedded Basics - 7 Skills Every Engineering Graduate Needs to be Successful
    • ► February (1)
      • Embedded Basics – Hardware and Software Breakpoints
    • ► January (1)
      • Embedded Basics – Don’t Forget about Real-time
  • ► 2016 (12)
    • ► October (1)
      • Embedded Basics – Selecting the Right Watchdog Strategy
    • ► September (1)
      • Embedded Basics - Threads vs Tasks
    • ► August (2)
      • 10 Questions for a Successful Code Review
      • Ternary Operator versus the if/else statement ...
    • ► July (1)
      • Open Source versus Commercial Compilers
    • ► June (1)
      • Embedded Basics - 7 Silent Project Killers
    • ► May (1)
      • Embedded Basics - Becoming a firmware expert
    • ► April (2)
      • Embedded Basics - Back to basic best practices ...
      • Embedded Basics - API's vs HAL's
    • ► March (1)
      • Embedded Basics - Classifying Software Bugs
    • ► February (1)
      • Embedded Basics - 3 Simple Way to Create a File Listing
    • ► January (1)
      • Embedded Basics - 10 Suggestions to kick-off a firmware project right
  • ► 2015 (10)
    • ► November (1)
      • Embedded Basics - 10 Qualities of Portable Firmware
    • ► October (1)
      • Embedded Basics - Squirrel
    • ► September (1)
      • Embedded Basics - Values and Side Effects
    • ► August (1)
      • Embedded Basics - Peculiarities of the keyword const  
    • ► July (1)
      • Embedded Basics - The difference of ' ' and " "
    • ► June (1)
      • Embedded Basics - 5 Tips for using portable types
    • ► May (1)
      • Embedded Basics - Header Guards
    • ► April (1)
      • Embedded Basics - Blocking vs Non-Blocking Drivers
    • ► March (1)
      • Embedded Basics - Code and Data Space Demystyfied
    • ► January (1)
      • Embedded Basics - Understanding the Microcontroller Boot Process
  • ► 2014 (4)
    • ► December (2)
      • Embedded Basics - A few Array Misconceptions
      • Device Drivers Whitepaper
    • ► October (1)
      • Embedded Basics - Understanding the Software Design Cycle
    • ► September (1)
      • Embedded Basics - Linear Dynamic Current

Latest Blogs

  • 3 Epic Ways AI and ChatGPT are Transforming Embedded
  • 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
  • Embedded Software Trends to Watch in 2023
© 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...