The Microchip SAM D and SAM L Positioning

The SAM D and SAM L are two Cortex-M lines Microchip inherited from Atmel. They split one family into two roles: the SAM D for general-purpose work, the SAM L for the low-power and secure end. Both run the same peripherals and the same tools, so a design moves between them with little friction.

Where the SAM line came from

Microchip bought Atmel in 2016. The SAM line of Arm microcontrollers was part of the deal. Atmel had built the SAM parts around the Cortex-M, with a peripheral set and a development style of its own. Microchip kept the line, the tools, and the engineers behind it. A design that knew Atmel found the same parts under a new name. Atmel had a long history in microcontrollers before the sale. The company built the 8-bit AVR line that runs the older Arduino boards. It then moved into Arm, first with the ARM7 and ARM9 SAM7 and SAM9 parts, later with the Cortex-M SAM3, SAM4, and SAM D families. The SAM name itself stands for Smart Arm Microcontroller. Microchip paid around 3.6 billion dollars for that catalogue and the customer base behind it. The deal made Microchip one of the largest microcontroller vendors in the world. It joined the SAM Arm parts to Microchip’s own PIC and AVR lines under one roof. A buyer now reaches 8-bit, 16-bit, and 32-bit parts through a single vendor.

The SAM parts run on Arm Cortex-M cores. The general-purpose SAM D parts use the Cortex-M0+, the smallest and lowest-power of the Cortex-M cores. The higher SAM D5x and SAM E5x parts step up to the Cortex-M4F at 120 MHz. The low-power SAM L parts use the Cortex-M0+ and the Cortex-M23. Across the range, the core is a stock Arm design, so the code and the compilers are the same as any other Cortex-M. The Cortex-M0+ is the workhorse of the line. It runs a two-stage pipeline and a single-cycle I/O port, both tuned for low power and fast response. The Cortex-M4F on the SAM D5x adds a floating-point unit and DSP instructions, for audio and signal work. The Cortex-M23 on the SAM L11 carries a security architecture, with TrustZone built into the core. Each core is a standard Arm part, so a developer reuses the same knowledge across all three.

The SAM line found its widest audience through Arduino. The SAM D21 sat at the heart of the Arduino Zero and the MKR boards. Those boards put the part in front of a large community of makers and engineers. That exposure built a base of people who reach for a SAM part by habit. The line carries a maker following the bare datasheet does not show. The Arduino link runs deep. The Arduino Zero came out of a joint project between Arduino and Atmel. The MKR range then carried the SAM D21 into small, IoT-shaped boards with batteries and radios. A generation of engineers learned 32-bit work on those boards. They carry that familiarity into professional designs. The SAM D21 reaches a designer who already knows its quirks and its libraries.

SAM D, the general-purpose line

The SAM D is the everyday SAM part. The SAM D21 anchors the line, a Cortex-M0+ at 48 MHz with flash from 32 KB to 256 KB. Smaller SAM D11 and SAM D10 parts drop to tiny packages and low pin counts. The SAM D5x parts climb to a 120 MHz Cortex-M4F with more memory and a richer peripheral set. A design picks a point on that range and keeps the same architecture as its needs grow. The SAM D21 packs a useful peripheral count for its class. It carries up to six SERCOM serial blocks, a 12-channel DMA controller, a USB port, a 12-bit ADC, and a DAC. The flash runs from 32 KB on the small D11 to 256 KB on the D21, with the RAM to match. The SAM D5x and E5x parts go further, with a second flash bank, a QSPI interface for external memory, a CAN-FD controller, and an SD-card host. A design grows from a simple D11 to a feature-rich E54 inside one family. The clock system on the SAM D is flexible in its own right. A design routes any of several oscillators through a set of generic clock generators to each peripheral. A design gives each peripheral its own clock rate. Power drops when only part of the chip runs fast.

The draw of the SAM D is the peripheral set. Each part carries the SERCOM blocks, the Event System, and the touch controller Atmel built into the line. Those make the SAM D strong for sensor interfaces, capacitive touch, and low-pin-count control. The Arduino heritage adds free tools and a deep store of example code. For a general-purpose 32-bit design, the SAM D is a known, well-supported part. The peripheral blocks set the SAM D apart in daily use. The SERCOM is a single block that a developer configures as a UART, an SPI master, an SPI slave, or an I2C port. One part covers a mix of serial devices with no fixed pin roles. The peripheral touch controller drives capacitive buttons, sliders, and wheels from the chip itself. A product adds a touch interface with no separate touch IC. The combination keeps the bill of materials short on a small consumer or industrial board. A small motor controller or a sensor hub fits the SAM D well, since the peripherals cover the interfaces and the touch in one chip.

SAM L, low power and security

The SAM L line turns the same architecture toward battery life. The SAM L21 uses the Cortex-M0+ with Atmel’s low-power technology, branded PicoPower. It holds deep sleep currents in the hundreds of nanoamps. A sensor or a wearable on a coin cell runs for years on that budget. The peripherals keep working in the low-power modes, so the part senses and counts while the core sleeps. The power numbers tell the story. The SAM L21 draws on the order of 35 microamps per megahertz in active mode. Its deep sleep modes fall to the hundreds of nanoamps, with the real-time clock and the RAM still alive. An integrated buck regulator raises the efficiency at the higher clocks. For a design measured in years of coin-cell life, those figures decide the part. The SAM L21 was the low-power answer in the SAM range before the security parts arrived. The SAM L21 names its low-power states in a clear ladder, from idle through standby to backup. Each step down shuts off more of the chip. The current drops at each step. A design parks the part in the deepest state the job allows between events. The wake time from those states stays short enough for a sensor duty cycle.

Low power changes how a part is built. The SAM L21 carries an event system and a sleep-walking controller, so peripherals run a measurement and store the result while the core stays asleep. A design wakes the processor only when the data needs work. That pattern is where the years of battery life come from. The SAM L is the SAM part for a product that lives on a battery. The sleep-walking idea deserves a closer look. A peripheral wakes on its own, takes a reading, runs it through the DMA, and checks it against a threshold. The core stays asleep through all of it. The processor wakes only when a reading crosses the line a design has set. A temperature logger or an environmental sensor spends nearly all its life in that state. The active core is the costly part, so keeping it asleep is what stretches the battery.

The SAM L11 adds hardware security to the low-power line. It uses the Arm Cortex-M23. That core puts TrustZone security into a small, low-power profile. Arm documents the Cortex-M23 as the smallest and lowest-power processor with TrustZone security. TrustZone splits the chip into a secure world and a normal world, so the keys and the trusted code sit apart from the application. The SAM L11 wraps that with tamper detection, secure boot, and an on-chip crypto accelerator. TrustZone for the Armv8-M architecture is the heart of it. The core keeps a secure side and a non-secure side, with its own stacks and its own memory regions for each. Calls cross the boundary only through defined gateways. A device stores its keys and its trusted routines on the secure side. The application code stays on the non-secure side, with no direct path to the secrets. Microchip ships a provisioning flow so a team locks the secure region at production.

Security at this size opens specific markets. A smart lock, a metering module, a medical wearable, or a disposable authentication tag needs both a long battery life and a protected key. The SAM L11 carries both on one low-power part. A design that would otherwise add a separate secure element can fold that function onto the microcontroller. The cost case is just as clear. The SAM L11 holds the key store, the crypto, and the low-power core on one die. A design folds the secure function into the microcontroller. The board space, the extra bus, and the second supplier a separate secure element needs all disappear. For a small connected product on a tight budget, that consolidation is a real draw. The saving shows up three ways: in board area, in unit cost, and in the qualification work for one part.

The shared peripheral toolbox

Both lines run the same Atmel-built peripherals. That shared toolbox is the reason a move between them stays cheap. The SERCOM block configures as a UART, an SPI, or an I2C port, so one peripheral covers several serial roles. The Event System lets peripherals trigger each other directly, with no CPU in the loop. That saves both time and power. The peripheral touch controller reads capacitive buttons and sliders without an external chip. Configurable custom logic places small logic functions on-chip. A design learns these blocks once and reuses them across every SAM D and SAM L part. The tools match the hardware. Atmel START and MPLAB Harmony generate the peripheral setup from a graphical view. Microchip Studio carries the old Atmel Studio environment forward for the teams that grew up on it. The Xplained Pro boards give each SAM family a low-cost evaluation platform with an on-board debugger. A design moves from an evaluation board to a custom board on the same code. The peripheral toolbox and the tool flow are the reason a team stays inside the SAM family once it learns the parts. The DMA controller ties into the same fabric, moving data between memory and peripherals with no core involvement. A linked-descriptor mode chains several transfers in sequence. Together with the Event System, the DMA carries whole data paths in hardware. A design offloads the routine movement and keeps the core free for the work that matters.

Choosing a SAM part

The choice between the two lines starts with the product. If a product runs on wall power or a large battery and needs general-purpose compute, the SAM D fits. If it runs on a coin cell, or has to protect a key, the SAM L fits. The split is clean. Each line has one job. The product decides before the datasheet does. A team reads the power source and the security need, then opens the matching line. A wall-powered controller, a motor driver, or a connected appliance rarely counts nanoamps, so it sits well on the SAM D. A coin-cell sensor, a wearable, or a wireless tag lives on its power budget, so it sits well on the SAM L. The need decides.

Many SAM designs do not need to choose at all. A team picks the SAM D for general work. It reaches for the SAM L only when the power or the security demands it. The two share a footprint family, a peripheral set, and a toolchain, so a later move costs little. A design can even start on the SAM D and shift to the SAM L if a battery target tightens. That portability is a real part of the line’s appeal. The pin layouts share a family pattern across many parts. The peripherals carry the same registers and the same driver code. A firmware base built on one SAM part ports to another with small changes. A team treats the SAM D and the SAM L as one toolbox to learn, two lines under one set of habits.

The SAM line also answers a question a team asks when it looks past the STM32. The SAM D matches the STM32 on general-purpose 32-bit work. It brings the Event System and the touch controller as its own draw. The SAM L reaches a lower sleep current than much of the STM32 range. The SAM L11 adds the Cortex-M23 security on top. A design that needs those specific strengths has a concrete reason to pick the SAM part. The Event System is the clearest example of that reason. It links peripherals directly: a timer triggers an ADC, the ADC triggers the DMA, the core stays out of the chain. A control loop runs in hardware at a fixed latency. The STM32 reaches similar ends through its own interconnect, so a team weighs this as one factor among several. The touch controller and the ultra-low-power modes are the SAM strengths that more often settle the choice. The capacitive touch is a clear case. A product with buttons or a slider drives them from the SAM part itself, with no separate touch controller on the board. The library and the tuning tools come with the SAM ecosystem. For a small appliance or a remote, that single saving can decide the part.

The case against the SAM line is the same as for any non-ST part. The STM32 has a larger catalogue, a wider third-party tool base, and more parts in distribution. The SAM part earns the move for one specific need: the low power, the security, or the peripheral set. Without one of those, the broad STM32 ecosystem stays the simpler default. The supply side carries weight here too. Microchip runs its own fabs and a long product-longevity program, so the SAM parts come with a written availability commitment. An industrial design that needs a ten-year or fifteen-year horizon reads that as a reason to commit. The single-vendor purchasing across Microchip’s analog, memory, and microcontroller catalogue adds to the draw. For a shop already buying from Microchip, the SAM line folds into one relationship.

The SAM D and the SAM L are not the broadest lines on the market. They are a focused pair with clear strengths. Between them, the two lines bring a strong peripheral set, a deep maker base, ultra-low power, and on-chip security. A design that reads its own needs first lands on the right one of the two without much trouble. The pair covers a wide span: the SAM D across the general-purpose middle, from a tiny D11 to a 120 MHz E54; the SAM L across the low-power and secure edge, from the PicoPower L21 to the TrustZone L11. One family, one toolchain, one set of habits spans both. A team that has read its power budget and its security need knows which line to open before it opens the datasheet. That clarity is the real value of a focused, two-line family.