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

Monthly Archives: September 2014

September 26, 2014

Embedded Basics – Linear Dynamic Current

When it comes time to start optimizing an embedded device for energy consumption it is often really tempting to start out by adjusting the operating...

Read More >>>
September 26, 2014

Tips and Tricks – Sleep on Exit

One of the software architectures for a low power system is to keep the system in a sleep mode at all times and only wake-up...

Read More >>>
September 26, 2014

Tools – TRAC Software Project Management

Keeping track of a software development project, even one that is relatively small can quickly become a challenging task.  Identifying development tasks, progress, bugs and...

Read More >>>
September 8, 2014

Simple Cooperative Scheduler Download

Fill in the below information to accept the terms and conditions of downloading the “Simple Cooperative Scheduler”.  This scheduler includes example modules for Cooperative scheduler...

Read More >>>

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 (5)
    • ► February (2)
      • CEC - Embedded Software using Rust
      • The differences you need to know about OSEK Compliant RTOS
    • ► 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 (47)
    • ► December (5)
      • Embedded Software Trends to Watch in 2023
      • 5 Tips for Designing an Interface in C
      • 3 Tips for Successfully Transitioning Away From C
      • C++ Project Setup using STM32 Microcontrollers
      • 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
    • ► October (4)
      • Official Release: Embedded Software Design
      • Tools - The Raspberry Pi Pico
      • 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 (4)
      • Book: Embedded Software Design
      • 3 Tips for Evaluating your Codes Quality
      • The Secret Embedded Software Definition Experts Use
      • Tools - SciTools Understand
    • ► July (1)
      • CEC - How to Select the Right Microcontroller for an Application
    • ► June (4)
      • 5 Strategies for Minimizing Debug Time
      • CEC - Embedded Software Design Techniques
      • 3 Tips for Data-Centric Software Design
      • 3 Tips for using Rapid Application Development (RAD) Tools
    • ► May (4)
      • How to Debug a Hard Fault on an Arm Cortex-M
      • 3 Tips for Avoiding “Reactive” Engineering
      • Simple Tricks to Minimize “Crossed-Wire” PCB Rework
      • 3 Tips for Embedded Software Configuration Management
    • ► April (4)
      • 5 Tips for Versioning Embedded Software
      • 3 Overlooked Embedded Software Elements
      • 5 Tips for Becoming More Agile
      • 2022 FIRST Robotics Competition - Team 7769
    • ► March (5)
      • 5 Tips for Rapid Prototyping with the Raspberry Pi Pico
      • The Ternary Operator Revisited
      • 5 C++ Tricks for C Programmers
      • Solutions to the 7 Silent Project Killers
      • 3 Strategies for Embedded Software Error Handling
    • ► February (4)
      • 5 Tips for Selecting the Right Embedded Programming Language
      • Getting Started with Cpputest for Embedded Applications
      • 5 RTOS Design Best Practices
      • 5 Tips to Successfully Manage Engineering Talent Shortages
    • ► January (4)
      • Embedded Software Development using Gitlab
      • 3 Tips for Successfully Simulating Embedded Software
      • CEC - Getting Started with the Raspberry Pi Pico
      • 5 Embedded Technologies to Master in 2022
  • ► 2021 (40)
    • ► December (1)
      • Using Docker to Setup an STM32 Build Environment
    • ► November (4)
      • CEC- Embedded Software Development Tools and Techniques
      • 5 Tips for Optimizing GUIs in Industrial Applications
      • 3 Elements to Successful Embedded Software Development
      • Introduction to Docker for Embedded Software Developers
    • ► October (4)
      • The IoT Online Conference (2021)
      • Embedded Development using Visual Studio Code
      • 3 Tips for Unit Testing Embedded Software
      • CEC - UML-Based Software Architecture Design
    • ► September (1)
      • 5 Skills Every Embedded GUI Developer Needs
    • ► August (2)
      • 5 Elements to Secure Embedded Systems – Part #4 Secure Bootloaders
      • 3 Use Cases for Multicore Microcontrollers
    • ► July (5)
      • Is It a Bug or Feature?
      • Programming the STM32 Option Bytes using SEGGER J-Flash
      • 3 Development Boards to Get Started with TrustZone for Cortex-M Microcontrollers
      • 5 Elements to Secure Embedded Systems - Part #3 Secure Boot
      • 3 More Tips for Speeding Up Framework Interrupt Handlers
    • ► June (4)
      • 5 Elements to Secure Embedded System – Part #2 Root-of-Trust (RoT)
      • CEC - Best Practices for Designing Real-Time Embedded Systems
      • 3 Tips for Speeding Up Interrupt Handlers
      • Understanding Weak Symbols
    • ► May (4)
      • 5 Elements to Secure Embedded Systems – Part #1 Hardware Based Isolation
      • There is No Hardware
      • Tips, Tricks and Best Practices, so What’s the Deal?
      • 3 Tips for Delivering Software Projects On-Time Every Time
    • ► April (3)
      • CEC - Machine Learning Application Design using STM32 MCUs
      • Finding a Buffer Overflow issue using a Map File
      • The Siglent SDG 2042X Arbitrary Waveform Generator
    • ► March (4)
      • Tools - STM32Cube.AI
      • Book Review: TinyML - Machine Learning with TensorFlow Lite
      • Celebrating the Microprocessors 50th Birthday
      • A Simple, Scalable RTOS Initialization Design Pattern
    • ► February (4)
      • 3 Strategies for Handling Errors in Embedded Software
      • CEC - Introduction to Multicore RTOS-based Application Development
      • 3 Explicit Programming Tips C Developers Should Follow
      • Announcing the 2021 Embedded Online Conference
    • ► January (4)
      • 3 Tips for Writing External Device Drivers
      • 5 Tips for Adding an Audio Codec to an Embedded System
      • Simulating Your Way to Embedded Software Success
      • Jacob's Most Popular Blogs (circa 2021)
  • ► 2020 (48)
    • ► December (5)
      • 3 Engineering Resolutions to Kick-off 2021
      • 5 Skills Every Developer Needs in 2021
      • 5 Best Practices for Over-the-Air (OTA) Updates
      • CEC - Designing Embedded Systems using the ESP32
      • Over-the-Air (OTA) Updates with AWS and FreeRTOS
    • ► November (4)
      • How to Organize a Firmware Project
      • 3 Common Challenges Facing RTOS Application Developers
      • 3 Tips for Repurposing Development Boards for Testing
      • 3 Tips for Validating Sensor and Communication Data in Embedded Systems
    • ► October (5)
      • 5 Tips for Developing an RTOS Application Software Architecture
      • 5 Tips for Building a Modern Telemetry GUI
      • CEC - Techniques for interfacing with Modern Sensors
      • 4 Key Take-A-Ways from Arm Dev Summit 2020
      • Code Quality over Quantity
    • ► August (4)
      • Simplified Software Development using MCU Configurators
      • 3 Mistakes Businesses make in a Crisis
      • One “RTOS” to Rule them All
      • 7 Tips for Mastering Git
    • ► July (5)
      • Book Review: Test-Driven Development for Embedded C
      • Cyclomatic Complexity Measurements with pmccabe
      • 5 Boards that Make Rapid Prototyping Easy
      • 5 Reasons to Develop a Software Architecture
      • 5 Best Practices for Utilizing Open Source Software
    • ► June (4)
      • 5 Reasons the ESP32 is an Intriguing Solution for the IoT
      • Webinar - An Introduction to Secure Product Lifecycle Management (sPLM)
      • Is the war between C and C++ Over?
      • 5 Keys to Successfully Managing Legacy Code
    • ► May (4)
      • Building Machine Vision Applications using OpenMV
      • The 3 Stages in Secure Product Lifecycle Management
      • 4 Uses for Assembly Language
      • A Microchip PIC16F84 LED Sequencer – Part 1
    • ► April (5)
      • The Embedded Online Conference - May 20 - 21, 2020
      • Book Review: MicroPython Projects
      • CEC - Getting Started with Secure Software
      • Using Callbacks with Interrupts
      • 5 Techniques to Delay Code Execution
    • ► March (4)
      • Jacob's Ideas and Adjustments for Shelter-In-Place
      • 5 Tips for Expanding your Embedded Skills
      • 7 Steps to Create a Stack Monitor
      • 5 Tips for Designing a Smart Watchdog
    • ► February (4)
      • Book Review: Microcontroller Basics with PIC
      • Simplify Debugging using RTOS Aware Debugging
      • 5 Reasons the new Arm Cortex-M55 will transform the IoT
      • 5 RTOS Best Practices for Designing RTOS-Based Applications
    • ► January (4)
      • 7 Steps to Create a Reusable Debounce Algorithm
      • 5 Keys to Successfully Managing Legacy Code
      • Book Review: Embedded Systems Architecture
      • 3 Advantages to using a Multicore Microcontroller
  • ► 2019 (52)
    • ► December (4)
      • 5 Tips for Improving Embedded Development (in 2020)
      • 2 Game Changing Trends that will Define Embedded Systems in the 2020’s
      • 5 Tips for Modernizing Legacy Code
      • 3 Lessons Learned from an Embedded Systems Security Breach
    • ► November (4)
      • 3 Painless Tips for Writing Documentation
      • 5 Tips for Versioning Embedded Systems
      • CEC - Designing and Launching an Embedded Product
      • The 8 Pillars of Embedded Software
    • ► October (5)
      • 5 Tips for using Open Source Software Successfully
      • 3 Trends from Arm Techcon 2019
      • Developing an Embedded Software Build Pipeline
      • 5 Roles for Python in Real-time Embedded Systems
      • 5 Tips for Growing Your Embedded Software Skills
    • ► September (4)
      • 5 Engineering Lessons from Playing League of Legends
      • 7 Sections Every Company Coding Standard Should Include
      • ASN Filter Designer
      • 2 Techniques to Version Embedded Hardware
    • ► August (5)
      • 7 Tips for Getting to Market Faster
      • 7 Reasons Open Source Software can be Evil
      • 5 Tips for Setting Realistic Project Expectations
      • 5 Advantages of using Micro Python for Embedded Software
      • The Top 5 Causes for Project Fatigue
    • ► July (4)
      • The Silent Firmware Revolution
      • Using strstr to Parse JSON Messages
      • Getting Started with JSON for Embedded Developers
      • 10 Pain-free Steps to Configure an Interrupt Controller
    • ► June (4)
      • The Key Factor Being Ignored by IoT Developers
      • Designing Embedded Systems using MicroPython
      • 5 Tips for using Arm TrustZone in Cortex-M Processors
      • 5 Resources for learning Python
    • ► May (5)
      • CEC - Designing Embedded Systems using MicroPython
      • The Big Tech Cloud Wars Ramifications on the Embedded Industry
      • An Ingenious Arduino to Breadboard Adapter
      • 5 Tips for Optimizing the Heap in MicroPython
      • 5 Lessons to Learn from the Boeing 737 MAX Fiasco
    • ► April (4)
      • 7 Tips for Creating a Reliable Embedded System
      • CEC - Machine Learning for Embedded Software Engineers
      • The MicroPython Pyboard Series-D Module
      • 5 Techniques for Accelerating Engineering Development
    • ► March (4)
      • Defining the Meaning of Software Quality
      • Webinar - Running DSP Algorithms on the Arm Cortex-M Processors
      • Protect Your Tools when the Hardware Bites Back
      • 3 Trends from Embedded World 2019
    • ► February (4)
      • 5 Cool Products from Embedded World 2019
      • 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 (5)
      • Defining the Software Development Life Cycle (SDLC)
      • The 3 Transformative Technologies in Food Services Automation
      • 10 Tricks for Documenting Embedded Software
      • The 5 Biggest Challenges Facing Embedded Software Developers in IoT
      • 5 Benefits to replacing analog components with DSP software
  • ► 2018 (52)
    • ► December (4)
      • 5 Technologies Embedded System Engineers Should Master in 2019
      • 7 Tips for using assertions in C
      • The Biggest Embedded Software Issue Is …
      • 5 Tips for Accelerating Embedded System Design
    • ► November (5)
      • CEC - Jump Starting Code Development to Minimize Defects
      • CEC - Securing IoT Devices using arm TrustZone
      • Tools - SWD Adapters every Developer should have
      • 7 Tips for Getting Started with TrustZone for MCU’s
      • 7 Tips for Getting Started with Amazon FreeRTOS
    • ► October (4)
      • 5 Tips for maintaining effective design processes
      • 5 Key Take-A-Ways from Arm TechCon 2018
      • Creating an SWD Adapter for STM32 Development Boards (Part 3)
      • PCB Shops for Rapid Prototyping
    • ► September (4)
      • Understanding firmware total ownership development costs
      • The Firmware Conundrum: Build or Buy
      • Creating an SWD Adapter for STM32 Development Boards (Part 2)
      • Creating an SWD Adapter for STM32 Development Boards (Part 1)
    • ► August (5)
      • 7 Tips for engineering students
      • Where oh Where are My Test Points!
      • Writing a Multi-Port ITM Function to Improve Debugging
      • Getting Started with Amazon FreeRTOS
      • Tools - Real-time Application Visualization Using Tracealyzer 4.2
    • ► July (4)
      • Webinar - Secure Bootloader Design Techniques for MCU's
      • 5 Embedded System Tools to Decrease Costs and Time to Market
      • 5 Tips for standing out in an engineering interview
      • 7 Tips for Developing Great API’s
    • ► June (4)
      • Getting Started using Arm® TrustZone® for Cortex®-M Processors
      • Improve Debug Efficiency with the ITM
      • The first ARMv8-M MCU with TrustZone Support
      • 3 Ways to Perform a Worst-Case Stack Analysis
    • ► May (5)
      • Evaluating and Mastering Real-Time Debugging Techniques
      • Embedded Online 2018 - Video and Presentation Links
      • Getting the most performance from printf
      • 5 Debugging Techniques for the ARM Cortex-M MCU
      • How well do you know your debugger?
    • ► April (4)
      • Amazon FreeRTOS: Behind the Scenes
      • 7 Tips for Securing an Embedded System
      • Unboxing the arm ULINKplus Programmer
      • CEC - Building Your Own Internet Connected PLC
    • ► March (5)
      • Know thy compiler toolchain
      • 5 Dangerous Assumptions Embedded Software Engineers Make
      • Tools - The Otii Arc, a Smart Power Supply for Optimizing Embedded Systems
      • CEC - Connecting Edge Devices to the IoT using Amazon FreeRTOS
      • 5 Trends from Embedded World 2018
    • ► February (4)
      • Designing and Debugging RTOS based IoT Applications
      • 5 Reasons to start using C++ over C
      • 5 Tips for standing out in an engineering interview
      • A Guide to Securing your IoT Device using Arm TrustZone for Cortex-M
    • ► January (4)
      • Bugs and Errors and Defects, Oh My!
      • Tools - Connecting to the IoT with the Electric Imp
      • 5 Challenges facing over-the-air updates using MCUs
      • 7 Essential skills for firmware engineers
  • ► 2017 (46)
    • ► December (3)
      • Embedded Basics - Firmware Beautification
      • 7 Tips for Optimizing Embedded Software
      • Tools - 10 Engineering Notebook Best Practices
    • ► November (5)
      • Q&A - Secure Bootloader Webinar Nov 29, 2017
      • Embedded Basics - Hash Fundamentals
      • 7 Tips for Selecting a Secure Microcontroller
      • Tools - Getting a grip on Semi-hosting
      • Transitioning to a Modern Day Engineering Notebook
    • ► October (4)
      • Embedded Basics - The Arm Security Manifesto
      • Tips and Tricks - 10 Steps for Selecting a Microcontroller (2017)
      • EETimes University - Fundamentals of IoT System Design
      • CEC - Transitioning from C to C++
    • ► September (4)
      • Embedded Basics - 7 Tips for Managing RTOS Memory Performance and Usage
      • Tips and Tricks - 5 Tips for Developing Real-time C++ Applications
      • Tools - OS-Aware Debugging
      • Developing Reusable Firmware - A Practical Guide to API's, HAL's and Drivers
    • ► August (5)
      • Embedded Basics - The Difference between Restart and Reset
      • Tips and Tricks – Jumping from the Bootloader to the Application Code Cleanly
      • Tools - A First Encounter with the SEGGER J-Trace
      • Getting Started Writing Portable Firmware
      • Embedded Basics - Callback Functions
    • ► July (4)
      • 7 Tricks for Estimating Battery Life
      • The Case of the Missing Professional Software Engineers
      • Hardware In-Loop Testing
      • CEC - Designing IoT Sensor Nodes using the ESP8266
    • ► June (3)
      • 5 Forbidden C Features that just might not be
      • 5 Revision Control Best Practices
      • 7 Reasons to Avoid Open Source Software
    • ► May (4)
      • Embedded Basics - Developing Reusable Firmware
      • Tips and Tricks - 7 Tips to Improve Embedded Software Code Quality
      • Tools – TortoiseHg
      • Managing the Heap Space in Micro Python
    • ► April (5)
      • 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
      • CEC - From Baremetal to RTOS
      • CEC - From Baremetal to RTOS
    • ► March (3)
      • Embedded Basics - 7 Skills Every Engineering Graduate Needs to be Successful
      • Tips and Tricks - 7 Reasons to Choose an RTOS
      • Tools - 5 Justifications for Purchasing a New Software Tool
    • ► February (2)
      • CEC - Designing API's and HAL's for Real-time Embedded Systems
      • Embedded Basics – Hardware and Software Breakpoints
    • ► January (4)
      • Tips and Tricks - 7 Tips for Memory Management
      • Tools - Renesas Synergy(TM) Configurator
      • Embedded Basics – Don’t Forget about Real-time
      • Tips and Tricks – 7 Tips for Meeting Real-time Deadlines
  • ► 2016 (44)
    • ► December (2)
      • Tools – The Device Firmware Update (DFU) Utility
      • 7 Tips to Accelerate Firmware Development
    • ► October (4)
      • Embedded Basics – Selecting the Right Watchdog Strategy
      • Tips and Tricks for Watchdog Design
      • Tools - Enter the Smart Watchdog
      • Slowing Down to Go Faster
    • ► September (4)
      • Embedded Basics - Threads vs Tasks
      • Tips and Tricks - Limiting Function Complexity shall be a Requirement!
      • Tools – My Top 10 Favorite Embedded Software Books
      • CEC - Getting Started Developing Professional Embedded Software
    • ► August (4)
      • 10 Questions for a Successful Code Review
      • 5 Tips for Getting Started with the Renesas Synergy(TM) Platform
      • Tools - Partitioning Flash Space with the Linker
      • Ternary Operator versus the if/else statement ...
    • ► July (4)
      • Open Source versus Commercial Compilers
      • 7 Tips for using an RTOS
      • Tools - Optimizing Firmware using DRT
      • It’s the end of C as we know it!
    • ► June (4)
      • Embedded Basics - 7 Silent Project Killers
      • Tips and Tricks - 7 Tips for Designing a Robust Bootloader
      • Tools - 10 Must Have Development Tools
      • CEC - Debugging Real-time Embedded Software - Hands-on
    • ► May (4)
      • Embedded Basics - Becoming a firmware expert
      • Tips and Tricks - Debugging Embedded Software
      • Tools - Percepio Tracealyzer
      • 7 Characteristics to Consider when Selecting an RTOS
    • ► April (5)
      • Embedded Basics - Back to basic best practices ...
      • Tips and Tricks - Best Practices for Programming Defensively in C
      • Mastering the 8 Pillars of Embedded Software
      • CEC - Rapid Prototyping Embedded Systems using MicroPython
      • Embedded Basics - API's vs HAL's
    • ► March (4)
      • Tips and Tricks - Build an Embedded Workbench for less than $1000
      • Tools - Promira Serial Platform
      • Writing Portable Optimizations in C
      • Embedded Basics - Classifying Software Bugs
    • ► February (4)
      • Tips and Tricks - An Overview of the PyBoard (MicroPython)
      • Tools - Embedded Software Start-up Checklist
      • Understanding Embedded System Failure Rates
      • Embedded Basics - 3 Simple Way to Create a File Listing
    • ► January (5)
      • Tips and Tricks - Writing Portable Code using Compiler Intrinsics
      • Tools - AstroGrep
      • CEC - Bootloader Design for Microcontrollers
      • Embedded Basics - 10 Suggestions to kick-off a firmware project right
      • Tips and Tricks - 8 tips for squashing bugs using assert in C
  • ► 2015 (41)
    • ► December (2)
      • Tools - Selecting the right emulator
      • Understanding volatile access warnings
    • ► November (2)
      • Embedded Basics - 10 Qualities of Portable Firmware
      • Tips and Tricks - 7 Tips for creating and using portable types
    • ► October (4)
      • Tools - Kinetis-L Freedom Boards
      • Using Conditional Complexity to Test Embedded Software
      • Embedded Basics - Squirrel
      • Tips and Tricks - Offload the I in IoT
    • ► September (5)
      • Tools - The April Board
      • CEC - Driver Design Patterns and the Internet
      • Embedded Basics - Values and Side Effects
      • Tips and Tricks - Learning to write portable code using ANSI-C
      • Tools - The Sandlot
    • ► August (3)
      • CEC - Writing Portable and Robust Firmware in C
      • Embedded Basics - Peculiarities of the keyword const  
      • Tips and Tricks - When to ASSERT or not ASSERT ...
    • ► July (4)
      • Tools - The ANSI-C Standard
      • Embedded Basics - The difference of ' ' and " "
      • Tips and Tricks - Introduction to ARM CMSIS
      • Tools - Open Source Circular Buffers
    • ► June (4)
      • 7 Steps to Customizing printf with a Circular Buffer
      • Embedded Basics - 5 Tips for using portable types
      • Tips and Tricks - MicroPython
      • Tools - Isolated USB to UART
    • ► May (4)
      • Embedded Software Design Tune-up Survey
      • Design News CEC - Mastering the ARM Cortex-M Processor
      • Embedded Basics - Header Guards
      • 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
    • ► March (4)
      • Tools - Sublime Text 3
      • A Review of Watchdog Architectures
      • Embedded Basics - Code and Data Space Demystyfied
      • Tips and Tricks - Fast Divide and Multiply
    • ► February (2)
      • Improving Code Integrity with a Stack Guard
      • Design News CEC - Baremetal C Programming for Embedded Systems
    • ► January (4)
      • Embedded Basics - Understanding the Microcontroller Boot Process
      • Tips and Tricks - 8 Reserved Words to Avoid in C
      • Improving Code Integrity Using FILL
      • Tools - Expanding Knowledge with Coursera
  • ► 2014 (26)
    • ► December (5)
      • Embedded Basics - A few Array Misconceptions
      • Tips and Tricks - Creating Successful Firmware Resolutions for 2015
      • Tools - The OWON Portable O-Scope
      • Device Drivers Whitepaper
      • CEC Introduction to Embedded Software Architecture Materials
    • ► November (4)
      • Embedded Basics - Using Pointer Arrays to Map Peripherals
      • Tips and Tricks - Using enum over #define
      • Tools - Beyond Compare
      • An Engineering Resume Template
    • ► October (4)
      • Embedded Basics - Understanding the Software Design Cycle
      • Tips and Tricks - Testing for Equivalence
      • Tools - STM32Cube
      • Bootloader Design Resources
    • ► September (4)
      • Embedded Basics - Linear Dynamic Current
      • Tips and Tricks - Sleep on Exit
      • Tools - TRAC Software Project Management
      • Simple Cooperative Scheduler Download
    • ► August (5)
      • The Top 10 Programming Languages of 2014
      • Turn a Low Cost Dev Kit into a Programmer in 3 Easy Steps
      • Tools - The Raspberry Pi
      • Raspberry Pi - Connecting Remotely using SSH
      • Embedded Software with Python and the Raspberry Pi
    • ► April (1)
      • Mastering the Embedded Design Cycle Templates
    • ► February (1)
      • NXP Kinetis-L Framework Example
    • ► January (2)
      • Understanding Portable Types
      • The Secrets to Becoming a Great Programmer
  • ► 2013 (34)
    • ► December (1)
      • 10 Tips for a Successful Engineering Resume
    • ► October (3)
      • Embedded Linux - Shell Scripting 102
      • Doxygen Code Templates
      • Function Generator Experiments
    • ► September (2)
      • Embedded Linux - Shell Scripting 101
      • State Machines with Function Pointers
    • ► August (3)
      • What is a Logic Analyzer
      • MISRA 2012 Compliance
      • Task Scheduling with Function Pointers
    • ► July (3)
      • A Review of for Loops
      • The World's Shortest C Program
      • Incubator and Co-working Space
    • ► June (2)
      • 10 Tips for Mastering Version Control Systems
      • A simple buffer circuit
    • ► May (8)
      • Beningo Engineering Becomes ARM Connected Community Partner
      • Beningo Engineering Partners with USA Firmware to provide the Embedded Software Store with driver frameworks
      • Jacob Beningo Elected Chair of the South Eastern Michigan Consultants Group
      • Choosing the Right Business Structure
      • An Introduction to Function Pointers
      • Battery Power Budget
      • Turn a Smart Phone into a Signal Generator
      • 2013 Design West Embedded Basics
    • ► April (8)
      • 10 Software Tips for Hardware Engineers
      • Pointer Arrays - A Timer Driver Part 2
      • Pointer Arrays - A Timer Driver Part 1
      • Time Is of the Essence
      • Using the Static Keyword in C
      • Creating Configuration Tables to initialize Peripherals
      • A few pointers - Part 3
      • A few pointers - Part 2
    • ► March (4)
      • Beningo Engineering now an Approved Microchip Design Partner
      • IEEE Consultant Group Forming
      • Developing Reusable Device Drivers for MCU's
      • Bootloader Design for Microcontrollers in Embedded Systems
  • ► 2012 (11)
    • ► December (6)
      • A few pointers - Part 1
      • Pricing and Licensing
      • Other Frameworks
      • Common Framework API's eases application development and porting
      • SPO2 module hardware and software now available for medical applications
      • Beningo Engineering releases MISRA compliant framework for NXP Kinetis-L
    • ► November (1)
      • Beningo Engineering launches Cubesat Application Framework compliant with MISRA
    • ► October (1)
      • Beningo Engineering launches framework for Texas Instruments MSP430 Family
    • ► September (1)
      • Cubesat Framework
    • ► March (1)
      • Bootloader Products
    • ► February (1)
      • Start-ups and Small Businesses - A baptism of Fire
  • ► 2011 (3)
    • ► March (2)
      • Differentiating Yourself as an Engineer
      • Documenting Code the Easy Way - Part 2
    • ► February (1)
      • Documenting Code the Easy Way - 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...