Request a firmware review
Menu

How to choose a microcontroller for a connected product

Reader question: Which microcontroller family should a startup pick for its first connected product, once radio, power, update and security needs are on the table?

Micrograph-style illustration of a small cluster of mineral grains, clear quartz, blocky feldspar and thin mica flakes, with one feldspar grain tinted amber.

Pick the microcontroller family that meets your radio and power needs and also has room for a bootloader plus two copies of your firmware, storage for more than one secure boot key or a way to revoke one, a debug port you can lock, an SDK you can ship on, and a published supply commitment that outlasts your production run. Radio and peripherals narrow the field to a few families. The update and security checks decide between them, because those properties are fixed in silicon and cannot be changed on units already in the field.

Fumbar is a Denver firm that writes embedded firmware and over-the-air update systems for hardware startups, so this guide reads chip choice through the update path. It recommends no chip by brand. The facts below come from vendor and open-source project documentation checked in November 2026, every example is labeled fictional or hypothetical, and the scorecard near the end is meant to be filled in for your own candidates.

This article assumes you have already decided that a microcontroller or wireless system-on-chip (SoC), rather than a Linux-class processor, is right for the product. The choice of kernel that runs on it is a separate decision, covered in Zephyr, FreeRTOS or bare metal.

Why update and security features belong in chip selection

Update and security features belong in the selection because they are the properties a firmware update cannot change. You can rewrite every line of application code after launch, but you cannot add flash, key storage or a lockable debug port to a board that is already in a customer’s hands.

Most published selection guides compare cores, clock speeds, peripherals and radios. Those matter, but a wrong radio choice usually shows up on the bench in the first weeks of bring-up, when changing course is cheap. A wrong flash size shows up when the image outgrows its slot, often after the first units have shipped.

The table below sorts common product decisions by when they can still be changed.

Decision Changed by a firmware update? Changed by a board revision?
Application features and bug fixes Yes Not needed
Bootloader configuration and update method Rarely, and with risk Yes
Flash available for two image slots No Yes, for new units only
Number of secure boot keys the chip can hold No Only by changing the chip
Hardware anti-rollback counter size No Only by changing the chip
Debug lock mechanism the silicon offers No Only by changing the chip
Supply commitment and silicon revision No Only by changing the chip

The lower the row, the earlier the decision has to be right. That is why this guide treats the update path and the security features as selection criteria with the same weight as the radio, and why a Fumbar firmware review reads the flash layout and the update plan alongside the schematics and the code.

Start with the radio, the power budget and the peripherals

The radio, the power budget and the peripheral count narrow hundreds of parts to a handful of families. Do this step quickly, write each answer down as a requirement you can test, and move on to the checks that actually separate the finalists.

Radio and certification route

The wireless protocol decides most of the shortlist. Bluetooth LE to a phone, home Wi-Fi and LTE-M cellular need different silicon, and some products need two radios. Decide which protocols are must-haves for the first release.

Then decide between an integrated wireless SoC on your own board (“chip-down”) and a pre-built radio module. Under the FCC’s rules for modular transmitters (47 CFR 15.212), a module can carry its own approval: “All single or split modular transmitters are approved with an antenna,” and a host product that hides the module’s label must carry an outside label such as “Contains FCC ID”. A module narrows your chip choice to what module makers build; chip-down gives more freedom and a longer path through radio testing. The connectivity service page describes the radio work; here you only need to know which route you are on.

Power

For battery products, compare sleep current with the conditions the datasheet states next to it: which memory stays powered, whether the real-time clock runs, the supply voltage and the temperature. Two parts with similar headline sleep figures can differ once you add the RAM retention and timer your firmware actually needs. Treat datasheet figures as a filter, then measure a development kit running your radio stack before you commit. The battery life calculator turns measured currents into a life estimate you can test against the requirement.

Peripherals, pins and package

Count every interface the schematic needs (I2C, SPI, UART, ADC channels, timers, USB) and add margin for the next board revision. Check ADC accuracy against your sensor, the temperature range against where the product will live, and the package against what your assembler can place.

Write each answer as a testable line in the firmware requirements worksheet, with the way you will verify it. A requirement such as “runs three years on two AA lithium cells” is only useful with its test next to it.

Example (fictional). Loamwick’s LW-1 soil probe measures soil moisture and temperature every 5 minutes, runs on two AA lithium cells and talks Bluetooth LE to a solar-powered gateway. Its requirements sheet lists FW-002, “Run 3 years on two AA lithium cells”, verified by “Measured average current on 5 boards, battery life calculator”, and FW-003, “Accept signed updates from the gateway and roll back on a failed self-test”, verified by pulling power at 10 points in the transfer. The first line filters by sleep current; the second drives the rest of this guide.

How much flash does an updatable product need

An updatable product needs enough flash for a bootloader, two image slots that are each larger than the biggest image you expect to ship, and the storage your application keeps (settings, logs, keys). In practice that means internal flash of a little more than twice your largest expected image, or an external flash chip for the second slot planned from the first board.

Why two slots

MCUboot, the open-source bootloader used with Zephyr and other systems, divides an image area into “a primary slot and a secondary slot”. The new image is downloaded into the secondary slot while the running image stays intact in the primary slot. The bootloader then checks the new image and installs it, either by swapping the two images or by overwriting the primary slot. MCUboot must be “configured at build time to choose one of these two strategies”. Espressif’s own update scheme works on the same principle: ESP-IDF OTA requires “at least two OTA app slot partitions” plus an OTA data partition of two flash sectors.

Each strategy costs flash differently and puts different demands on the chip:

MCUboot strategy Flash layout What to check on the candidate chip
Swap using scratch Two equal slots plus a scratch area Scratch must hold “at least the largest sector”; MCUboot notes this algorithm “may be removed in the coming future”
Swap using offset Secondary slot ideally one sector larger than the primary All slot sectors the same size; MCUboot prefers it over swap using move for new products
Swap using move Primary slot one sector larger, plus swap status All slot sectors the same size
Overwrite only Two slots, primary overwritten Simplest; the old image is gone once it is overwritten
Direct-XIP Image runs from either slot Images “built to be executed from the corresponding slot”; no on-the-fly encryption
RAM load Newest image copied to RAM RAM large enough to hold the whole image

Sector layout and endurance

Two lines in the MCUboot design document turn into datasheet checks. First, flash sector geometry: “Many devices have small equally sized flash sectors, eg 4K, while others have variable sized sectors where the largest sectors might be 128K or 256K.” The swap-using-offset and swap-using-move algorithms require that “All slot’s sectors should be of the same size”, and the scratch method needs a scratch area as large as the largest sector it swaps. A part whose flash is divided into a few large, uneven sectors can make a two-slot layout expensive. Open the reference manual’s flash organization table for each candidate and write down the sector sizes in the region you would use for slots.

Second, endurance. MCUboot gives a formula for the scratch method: the number of upgrades before the scratch area exceeds its rated erase cycles is the rated cycles divided by (image size / scratch size). Its own worked example uses 10,000 erase cycles, a 150 KB image and a 4 KB scratch, which gives about 267 upgrades; a 16 KB scratch raises that to about 1,067. So the rated erase cycles in each candidate’s datasheet are part of the update design, not a footnote.

The arithmetic, worked

Example (fictional). Loamwick’s probe uses a Bluetooth LE microcontroller with 1 MB (1,024 KB) of internal flash. The flash budget calculator takes a 48 KB MCUboot partition, no scratch, 32 KB of settings, 48 KB of logs, 4 KB erase sectors and a 4 KB header and trailer allowance. That leaves 896 KB for the two slots, so each slot is 448 KB and the largest image that fits is 444 KB. The current application image is 412 KB, which fills 92.8% of its slot and leaves 32 KB of room. With the 25% growth the team wants to allow for, the image would reach 515 KB: 71 KB too big. The team’s plan is to move the second slot to an external flash chip on the Rev E board.

512 KB internal flash, two slots (hypothetical): largest image 188 KB Slot 1: 192 Slot 2: 192 1 MB internal flash, two slots (Loamwick LW-1, fictional): largest image 444 KB Primary slot: 448 KB Secondary slot: 448 KB 1 MB internal plus external flash (hypothetical): largest image 892 KB Primary slot: 896 KB (internal flash) Secondary slot: 896 KB (external SPI flash chip) Bootloader 48 KB Primary slot Secondary slot Settings 32 KB Logs 48 KB
Figure 1. The same bootloader, settings and logs on three flash sizes, drawn to one scale. Each largest image is the slot size minus a 4 KB header and trailer allowance, rounded to 4 KB sectors. The 1 MB row uses the fictional Loamwick LW-1 numbers from the flash budget calculator; the other two rows are hypothetical. Slot model: MCUboot design documentation, checked November 2026.

With the same 128 KB of bootloader, settings and logs, a 512 KB part leaves room for an image of only 188 KB per slot, while a 1 MB part holds 444 KB. Run this arithmetic on the part number in your bill of materials, not on a development kit or module that may carry more memory.

External flash for the second slot

An external SPI flash chip is a reasonable answer when no candidate with enough internal flash meets the other requirements. It adds a part, pins and sleep current, and an image waiting in external flash can be read by anyone with a probe on the board. MCUboot’s encrypted images feature exists for this case. It provides confidentiality “while in transport to the device or while residing on an external flash”, but it “does not protect against the possibility of attaching a JTAG and reading the internal flash memory”. The decryption key has to live inside the chip where it cannot be extracted, which leads straight back to the debug lock question below.

Some families keep all firmware in an off-chip flash part by design. Espressif’s ESP32-S3 security overview describes Flash Encryption as the feature that “helps to encrypt the contents on the off-chip flash memory”. If a candidate works this way, flash encryption becomes a must-have row in your scorecard, not an option.

A decision rule that follows from all this: choose a part whose internal flash holds the bootloader, two slots sized for your current image plus at least 25% growth, and your storage. If none of your finalists can, put the external flash footprint on the first board revision rather than the third.

Which secure boot features should you check?

Check where the chip stores the root public key, how many keys it can hold, whether a key can be permanently revoked, which signature algorithms the boot code verifies, and whether there is a hardware counter for anti-rollback. Two chips from the same vendor can give different answers to every one of those questions.

Key slots and revocation: one vendor, two answers

Espressif documents Secure Boot v2 separately for each chip, and the differences are a clear example of why this row exists.

  • ESP32. Secure Boot v2 is “supported on ESP32 (v3.0 onwards)”; earlier chip revisions only have the older Secure Boot scheme. Under the advantages listed in the ESP32 Secure Boot v2 guide: “Only one public key can be generated and stored in the chip during manufacturing.”
  • ESP32-S3. The ESP32-S3 guide says “Up to three public keys can be generated and stored in the chip during manufacturing” and “ESP32-S3 provides the facility to permanently revoke individual public keys”, either conservatively (after the bootloader and application have moved to a new key) or aggressively (as soon as verification with a key fails).

Both use RSA-PSS signatures with an RSA-3072 public key whose digest is stored in eFuse, one-time programmable bits inside the chip. The practical difference is what happens if a private signing key leaks or is lost. With one key slot and no revocation, a device that has burned that key’s digest has no way to stop accepting images signed with it. With three slots and revocation, you can move the fleet to a second key and permanently refuse the first. How you store, rotate and retire keys is covered in firmware signing keys: storage, rotation and revocation; the chip decides whether rotation is possible at all.

The ESP32 note carries a second lesson: a security feature may exist only on a newer silicon revision. Put the minimum revision in the requirements and on the purchase order.

Signature algorithms

The boot code can only verify the algorithms it was built for. MCUboot’s imgtool “currently supports rsa-2048, rsa-3072, ecdsa-p256 and ed25519 keys”, and “The key type used should match what MCUboot is configured to verify.” A chip whose boot ROM verifies RSA-3072 signatures, as in the Espressif examples above, fixes the algorithm your signing service and any hardware security module must support.

MCUboot’s documentation adds a warning that belongs in every bring-up plan: “There is a development key distributed with MCUboot that can be used for testing. Since this private key is widely distributed, it should never be used for production.”

Anti-rollback counters

Downgrade prevention stops anyone installing an older, vulnerable image that is still validly signed. MCUboot offers two forms. Software-based prevention compares version numbers and “is only available when the overwrite-based image update strategy is used”. Hardware-based prevention compares a security counter in the image with “the currently active security counter value which must be stored in a non-volatile and trusted component of the device”, and the target platform must provide that counter. So the question for each candidate is: does it have one-time programmable bits or a protected monotonic counter, and how many increments does it allow?

Espressif states the limit plainly for its anti-rollback scheme on ESP32-S3: “The number of bits in the secure_version field is limited to 16 bits. This means that only 16 times you can do an anti-rollback.” Sixteen increments last if you raise the counter only for releases that fix a security vulnerability; raised on every monthly release, they are gone in under a year and a half.

Isolation for keys and secure services

Some Arm Cortex-M parts built on the Armv8-M architecture separate a secure and a non-secure processing environment, which the Zephyr documentation notes is “usually by means of Arm TrustZone on Armv8-M processors”. Trusted Firmware-M (TF-M) runs on the secure side and provides, among other services, “Management of device secrets (keys, etc.)”, “Firmware verification (and encryption)” and “Proof of device identity (device attestation)”. The Zephyr documentation gives a direct check for whether a given board can use it: “check that CONFIG_TRUSTED_EXECUTION_NONSECURE is set to y in that board’s default configuration.” Its TF-M requirements page lists example boards, including the nRF5340 DK, the LPCXPRESSO55S69 and the B-U585I-IOT02A Discovery kit.

The secure image takes its own flash and RAM (“Resource allocation for Zephyr relies on choices made in the secure image”), so add its partitions to the flash budget before you compare parts.

The secure boot checklist lists the tests that prove these features work on a finished unit, such as an unsigned image refused and a downgrade refused.

Can you lock the debug port and still recover a returned unit?

Production units need the debug port closed and the firmware unreadable, and you will still want a way to examine units that come back from the field. Check which lock levels each candidate offers, whether each level is permanent, and whether it can be re-opened, and by whom.

The debug port (JTAG, for example) lets anyone with a probe halt the processor, read memory and write flash. During development that is exactly what you want. On a shipped unit it is a direct route to your firmware and to any keys stored in readable memory. The EU Cyber Resilience Act, Regulation (EU) 2024/2847, lists among its essential requirements that products be “designed, developed and produced to limit attack surfaces, including external interfaces” (Annex I, EUR-Lex). This article is not legal advice, but a lockable debug port is one of the plainest ways to show that requirement was considered.

The mechanisms differ more between families than the datasheets’ one-line summaries suggest. Espressif’s ESP32-S3 security overview describes three layers:

  • “JTAG interface stays disabled if any of the security features are enabled,” and it “can also be disabled in the absence of any other security features using eFuse API”.
  • “ESP32-S3 supports soft disabling the JTAG interface and it can be re-enabled by programming a secret key through HMAC.”
  • The ROM’s UART download mode switches to a restricted secure mode when security features are on, and can be disabled permanently.

That middle option is worth looking for on every candidate: a lock that a holder of a secret can re-open lets you analyze a returned unit without leaving the port open on every other unit. Other vendors describe their locks in their own terms and with their own trade-offs, so ask the same questions of each:

  1. What lock levels exist, and which of them are permanent?
  2. Can a locked port be re-opened with a key, only with a full erase, or never?
  3. Does a full erase also wipe the stored keys and the anti-rollback counter?
  4. Can the factory still program and test a unit after the lock is set, or must locking be the last station?
  5. Does the lock also block the ROM’s serial or USB download path, or is that a separate setting?

Whatever the answers, plan to read the firmware version, the boot count and the last crash record through the product’s own interface, so that a support engineer does not need the debug port to diagnose a returned unit.

Is the SDK and bootloader support good enough to ship on?

A chip is only as usable as the software that supports it. Check that the vendor SDK or the RTOS you intend to use supports this exact part, with the radio stack, power management and bootloader you need, at release quality and with a stated support window.

Board support is not the same as feature support

The Zephyr supported boards catalog is organized by vendor, and each board page has a “Supported Features” section. A board appearing in the catalog tells you the kernel boots on that part; the features section tells you whether the drivers you need (the radio, the ADC, the low-power modes, the flash controller) are there. Read the features section for your actual part, not for a sibling with a similar name.

As of its v2.4.0 documentation, MCUboot works with Zephyr, Apache Mynewt, Apache NuttX, RIOT (“supported only as a boot target”), Mbed OS, Espressif and Cypress/Infineon (MCUboot overview). Some vendors ship their own bootloader and update scheme instead, such as ESP-IDF’s. Either can work if the port for your part is maintained and you know by whom.

Support windows

The software on the chip needs security fixes for as long as you support the product. Zephyr Long Term Support releases are “maintained independently from the main tree for approximately 5 years”, and the next one is planned as Zephyr 4.6 in April 2027, according to the Zephyr releases page as of November 2026. FreeRTOS LTS libraries receive “security updates and critical bug fixes” for two years per release, per the FreeRTOS-LTS repository. Vendor SDKs publish their own policies; find the page that states how long a release receives fixes and copy the dates into your scorecard.

The trade-offs between kernels are covered in Zephyr, FreeRTOS or bare metal, and the RTOS selection worksheet scores them for your case. If you want to keep the option of changing chips later, the code structure that makes that affordable is described in portable firmware architecture.

The first-week test on a development kit

Before you commit, build the bootloader for each finalist’s development kit, sign two versions of a minimal application with a test key, update from one to the other, force a failed self-test and watch it roll back, then lock the debug port and confirm you can still update over the product interface. That result is worth more than any feature table, and it is the same sequence a board bring-up repeats later on your own boards.

How long can you buy the chip and get fixes for its software?

There are two clocks. The silicon supply commitment has to cover your production years plus spares for repairs. The software support window has to cover the support period you promise customers. Read the vendor’s longevity page for the first and the SDK or RTOS policy for the second, and note the start date of each.

Supply commitments count from the vendor’s date, not yours

Espressif’s Longevity Commitment page, read in November 2026, lists a minimum term and a start date per series, and notes: “The commitment years start from the date shown above.” Some entries:

Series Commitment Start date Commitment reaches
ESP32 At least 15 years January 1, 2016 January 2031
ESP32-S3 At least 12 years January 1, 2021 January 2033
ESP32-C3 At least 12 years January 1, 2021 January 2033
ESP32-C6 At least 12 years January 1, 2023 January 2035
ESP32-H2 At least 12 years January 1, 2023 January 2035

The last column is simple arithmetic, and it is the column that matters. A product launched in 2027 on a series whose commitment started in 2021 has about six years of committed supply left, not twelve. The same page also defines “Not recommended for new designs (NRND)”, a status for parts that are still made but that the vendor steers new designs away from. Check that status for every candidate before you lay out a board around it.

Other vendors publish longevity terms in different forms. Find each candidate’s page or ask for a written statement, and subscribe to product change notifications.

2016 2020 2024 2028 2032 2036 ESP32 At least 15 years, to 2031 ESP32-S3 At least 12 years, to 2033 ESP32-C6 At least 12 years, to 2035 Product on sale 2027 to 2030 Product updates Updates to end of 2035 November 2026
Figure 2. Supply and support are two clocks. Amber bars: Espressif's published minimum longevity commitments for three series, counted from the start dates it lists. Dashed bars: a hypothetical product sold from 2027 to 2030 with security updates for five years after the last sale. Source: Espressif Longevity Commitment page, checked November 2026; the product bars are hypothetical.

Software support and the CRA support period

For products sold in the EU, the Cyber Resilience Act turns the software clock into an obligation. Its main obligations apply from December 11, 2027. Under Article 13(8), the support period “shall be at least five years”, and “Where the product with digital elements is expected to be in use for less than five years, the support period shall correspond to the expected use time.” When setting it, manufacturers may take into account, among other things, “the support periods of integrated components that provide core functions and are sourced from third parties”. Your microcontroller’s SDK, radio stack and bootloader are such components. Again, this is not legal advice; read the Regulation itself, or have counsel read it, before you set the period.

If you intend to promise five years of security updates, list who will supply fixes for each software component the chip depends on. Where a vendor SDK’s window is shorter, plan a platform upgrade during the support period and leave flash for it.

What does PSA Certified tell you about a chip?

Third-party certification of a chip’s root of trust is evidence that its security features exist and were evaluated by a lab at a stated level. It does not secure your product on its own, and it does not certify your device. Use it to shorten the list and to reuse evidence, then still test the features yourself.

PSA Certified, a scheme whose name and logos are trademarks of GlobalPlatform, offers certification at several levels. Its silicon vendor page describes them, in summary:

Level What it shows, per PSA Certified
Level 1 Basic security principles applied and relevant features present for the device manufacturer
Level 2 Lab evaluation of the root of trust against “scalable, remote software attacks”
Level 3 Lab evidence of “substantial security capabilities” of the root of trust
Level 2 or 3 plus Secure Element Added physical protection for key storage and cryptographic operations
Level 4 iSE/SE High protection of secret keys and crypto functions from physical and software attacks

Certification is composite. According to the device manufacturer page, “The easiest route to achieving PSA Certified Level 1 is by selecting pre-certified silicon and a pre-certified software platform for your device”, after which “only the ‘device’ questions in the PSA Certified Level 1 questionnaire need to be answered, that is less than 20 questions.” The Zephyr documentation states that “Zephyr RTOS has been PSA Certified since Zephyr 2.0.0 with TF-M 1.0.”

As of November 2026 the PSA Certified home page reported 319 certifications from 124 companies in its database. Certificates name specific parts and versions, so search for the exact part number you would buy, not the family name. A certified root of trust is evidence to start from; it does not replace your own threat model, your update testing or your obligations as the manufacturer.

A scorecard you can fill in for each candidate

Put each criterion in a row, mark the must-haves, look up every answer in vendor or project documentation and paste the link next to it, then test the must-haves on a development kit. A candidate that fails any must-have row is out, however good the rest of its row looks.

Criterion Question to answer Where to look Must-have rule (adjust to your product)
Radio and stack Required protocols with a maintained stack? Datasheet; SDK release notes Supported in a released SDK
Certification route Approved module, or chip-down? Module documentation Decided before layout
Sleep current Current in the sleep mode you will use? Datasheet; your measurement Meets the battery requirement
Peripherals and pins All interfaces on one package? Datasheet pin table All required, plus spares
Flash for two slots Bootloader, two slots with 25% growth, storage? Flash budget calculator Fits, or external flash planned
Flash sectors Uniform, small sectors in the slot region? Reference manual Matches the MCUboot strategy
Flash endurance Rated erase cycles? Datasheet Enough for the expected updates
Root of trust Where is the root key or its digest stored? Secure boot documentation One-time programmable or protected
Key slots and revocation How many keys; can one be revoked? Secure boot documentation Two or more, or a written plan
Signature algorithm Which algorithms are verified? Secure boot documentation Supported by your signing service
Anti-rollback counter Trusted counter; how many increments? Security or OTA documentation Covers the support period
Debug lock Lock levels; can a lock be re-opened? Security documentation Lockable; returns diagnosable
Firmware confidentiality Readout protection or flash encryption? Security documentation Required for external flash
Isolation TrustZone and TF-M support? Zephyr TF-M requirements Only if your threat model needs it
SDK and RTOS support This exact part, with your features? Zephyr “Supported Features”; vendor SDK Released, not experimental
Bootloader port Maintained port available? MCUboot overview; vendor SDK Yes
Software support window How long do fixes continue? Release policies Covers your support period, or upgrade planned
Silicon longevity When does supply commitment end? Vendor longevity page Covers production plus spares
Security certification Exact part certified, at what level? PSA Certified database Nice to have, unless required
Errata Silicon errata touching your features? Errata sheet for the revision None unworked on must-haves

Every cell carries the link and the date you read it, and every must-have row gets a test on the development kit before the decision is final: documentation describes intent, the kit shows behavior.

Example (fictional). A two-person team building a Wi-Fi water-leak sensor compares two fictional parts, Part A and Part B. Part A has 512 KB of internal flash; with the same bootloader and storage sizes as Figure 1, its 300 KB prototype image already exceeds the 188 KB a slot would hold, so it fails the flash row unless the team adds external flash. Part B keeps firmware in external flash and offers flash encryption, three secure boot key slots with revocation, a 16-step anti-rollback counter and a debug lock that a key holder can re-open. Its supply commitment started four years ago and has eight years left, which covers the planned five production years. The team picks Part B and records the counter rule “raise only for security fixes”.

Readers who searched “ESP32 vs nRF52 vs STM32” are usually looking for a winner. Those names are families, not parts, and the ESP32 and ESP32-S3 secure boot pages above show that two members of one vendor’s line can differ on exactly the rows that matter. The scorecard is the honest way to compare them, one exact part number per column.

What to do this week

Turn the criteria into a decision you can defend in a few days, with evidence attached. The steps below assume a team of one or two engineers and a shortlist that does not exist yet.

  1. Write the requirements. Put radio, power, peripherals, update and security needs into the firmware requirements worksheet, each with its verification method.
  2. Shortlist two or three families. Use the radio, power and peripheral rows only. Name an exact part number for each, including package and minimum silicon revision.
  3. Run the flash budget. Enter each candidate’s internal flash, your bootloader size, your storage needs and your current or estimated image size with 25% growth in the flash budget calculator. Note which candidates need external flash.
  4. Fill in the scorecard. Add one column per part number, with a link and a date in every cell and the must-have rows marked.
  5. Run the first-week test. On each finalist’s development kit: bootloader, two signed images, an update, a forced rollback and a debug lock, with notes on what was hard.
  6. Read the two clocks. Record the silicon supply commitment and each software component’s support window, and compare them with the production years and the support period you plan to promise.
  7. Decide and record why. Write a one-page decision record with the scorecard attached, so that the next engineer knows which rows drove the choice.

Then carry the chosen part into the first boards: the board bring-up service describes how first boards are powered, measured and handed back, and the firmware development service covers the application and driver work that follows. If you would like a second reader before you commit, a firmware review from Fumbar reads your schematics, any existing code, the flash layout and the update plan, and ends in a written plan with the risks and the order of work. You can request a firmware review with your shortlist attached.

Facing this decision on a real device?

If this article describes a choice in front of you, a firmware review puts it in writing for your board, your code and your update plan.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.