Microchip launches PIC16 microcontroller with integrated micro FPGA, priced at less than 50 cents

Compiled from EEJOURNAL

Microchip now offers a flash-based microcontroller with integrated programmable logic blocks for less than 50 cents. The nine new products in Microchip's PIC16F13145 series use the same 8-bit RISC microprocessor architecture as other models in the 16F series, but they also integrate a new block of programmable logic called the Configurable Logic Block (CLB). Devices in the PIC16F13145 microcontroller family are available in 8-, 14-, and 20-pin packages with 3.5 to 14 KB of Flash memory and 256 to 1024 bytes of RAM.

The nine members of Microchip's PIC1613145 microcontroller family share the same internal architecture but have varying amounts of RAM and Flash memory and are available in different packages, depending on your application's I/O needs. Image source: Microchip

Devices in this family have the same type and number of peripherals, but vary in the number of external I/O pins, depending on the package. More than a decade ago, Microchip introduced a programmable logic peripheral called a configurable logic cell (CLC) in its microcontrollers. The CLB in the PIC16F13145 series is a larger, more complex block of programmable logic than the CLC integrated in earlier Microchip PIC and AVR microcontrollers, and we may see larger CLBs in future PIC16 products. For backward compatibility, the PIC16F13145 microcontroller also integrates four CLCs.

Before delving into the complex internals of the PIC16F13145 device, I think it is important to explain how to use the CLB and provide some example usage, as understanding why a 32-LUT programmable logic block on an 8-bit low-end microprocessor core can be somewhat difficult . CLB is a handy way to implement a small amount of hardware-level real-time processing when the PIC16F13145 microcontroller's CPU is too slow to perform a task, or when you need some form of simple parallel processing that exceeds the microcontroller's multitasking capabilities.

Applications like these are the basis on which we started using FPGAs, and Microchip has now ported the tiny FPGAs (albeit larger than the older CLCs) into one of its microcontroller sub-families. You can use CLBs to implement state machines or "high-speed" peripherals such as software-driven signal multiplexers, counters, quadrature decoders, stepper motor controllers, or high-speed PWMs (pulse width modulators). CLB can make logical decisions while the CPU is in sleep mode, thereby reducing overall system power consumption. The output of the CLB can drive external device pins or inputs to other peripherals of the microcontroller.

The CLB itself looks very much like the programmable logic fabric in an FPGA. The 32 basic logic elements (BLEs) that make up the CLB are very similar to the logic cells in the first FPGA - the Xilinx XC2064 launched by Xilinx in 1985. Each BLE consists of a 4-input LUT and a D flip-flop. A wide multiplexer feeds 16 input select latches, which then drive the CLB using one of 40 different input signals drawn from external input pins, bits of internal registers, and output pins of internal peripherals. LUT input. The outputs of the 16 input selection latches are fed into programmable edge detectors. These edge detectors are triggered by positive edges by default but can be programmed to be triggered by negative edges or bypassed completely. An additional eight multiplexers route the eight CLB output bits to external pins, internal registers, or inputs to internal peripherals. For example, the CLB also contains a 3-bit hardware counter to aid in building state machines using the CLB.

Microchip's documentation does not discuss the CLB's internal wiring, switch matrix, or its configuration bits, and you don't need to know about them. Instead, MPLAB Code Configurator (MCC) is a free software plug-in in the company's MPLAB X integrated development environment (IDE) software that handles CLB configuration details based on the designer's schematics. You can use the integrated schematic editor in MPLAB IDE to create a design for the CLB of the PIC16F13145.

All FPGA designs are initially captured using schematics until the FPGA becomes too large and complex to implement the schematic. In the early 1990s, as FPGAs became larger, HDL encoding in Verilog or VHDL began to replace schematic input. My good friend Robert Bielby recalls that by the early 2000s, hierarchical, text-based HDL descriptions had largely replaced schematic input for FPGA designs, when the maximum capacity of FPGAs had reached thousands of LUTs. . (Bielby worked at Altera and Xilinx for about twenty-five years, and few engineers can remember when designers used schematics to define FPGAs. But Bielby and I do.)

The largest schematic design Bielby remembers seeing required more than 30 sheets of D-size paper. This is too large for the schematic. Microchip's schematic-based approach to CLB design harkens back to a distant era in the electronics industry, but it's still perfectly suited for FPGAs with 32 LUTs. The 32-LUT CLB for the PIC16F13145 microcontroller is very simple and requires only schematic input.

CLB's schematic entries use basic symbols such as 2-, 3-, and 4-input logic gates, D or JK flip-flops, 2- or 4-input multiplexers, and simple integer constants. You can also directly use the CLB's 4 LUTs, which are its basic logic elements. Some of the microcontroller's hardened peripherals can also be included in the design so that the CLB can interact with those on-chip peripherals. The CLB can also interact with the microcontroller's CPU through a register interface, with software-accessible input and output registers shown on the schematic as bit-level inputs and outputs.

Microchip's CLB synthesizer for PIC16F13145 microcontroller programmable logic accepts schematic-level design (left) and can also accept HDL code (top right). Image source: Microchip

MPLAB converts the schematic design into a Verilog HDL description before synthesizing the design using MPLAB Code Configurator (MCC). Microchip allows you to insert your own Verilog code into CLB schematics through block-level containers. After synthesis, MPLAB maps the design to the CLB, places and routes the design, and generates a configuration bitstream that can be integrated with the microcontroller's compiled object code. The CLB configuration is stored in the microcontroller's flash memory as a constant sequence and automatically transferred to the CLB via DMA at startup. The RAM-based CLB is reconfigurable, so multiple CLB configurations can be stored in the microcontroller's flash memory. The microcontroller can reconfigure the CLB under software control with a reconfiguration time of 206 instruction cycles, which is just under 26 microseconds at the microcontroller's maximum 32MHz clock rate.

MCC also provides a GUI-based method to configure other peripherals in the PIC16F13145 microcontroller subfamily. In addition to the programmable logic CLB, the PIC16F13145 microcontroller integrates many other peripherals. All PIC16F13145 microcontrollers contain four older and simpler programmable logic CLCs for backward compatibility with other Microchip microcontrollers. In addition, the PIC16F13145 microcontroller has a long list of internal peripherals, including:

A 10-bit, 100ksamples/sec ADC with 22-input analog multiplexer

1 8-bit DAC

Two analog comparators

Two capture/compare/PWM modules with 16-bit resolution for timing and event triggering and 10-bit resolution for PWM

Two 10-bit PWM modules

1 configurable 8/16-bit timer, 1 16-bit timer and 1 8-bit timer

1 serial port

1 synchronous serial peripheral with SPI and I2C modes

1 external interrupt pin

Two selectable voltage references for internal use by the ADC

Microchip has developed the Curiosity Nano evaluation board for the PIC16F13145 microcontroller. It's about the size of a 40-pin DIP and comes with solderable pin headers. The board connects to the host system via a USB cable and can self-program the flash memory of the onboard PIC16F13145 microcontroller.

The low-cost Curiosity Nano PIC16F13145 Evaluation Board allows you to explore the capabilities of your microcontroller and program the flash memory on the microcontroller through the evaluation board's USB port. Image source: Microchip

Microchip's PIC16F13145 microcontroller is priced at $0.47 for the smallest device. The FPGA fabric in the PIC16F13145 microcontroller family has only 32 LUTs, approximately half the size of the original Xilinx XC2064 FPGA introduced in 1985. But if Microchip decides to make a $2 product, it should add more LUTs.

Although this is a very unfair comparison, you can think of the Microchip PIC16F13145 as AMD versus Intel. These chips contain multiple 32-bit or 64-bit Arm processors and thousands of FPGA LUTs. Many embedded designs don't require that much processing power, but when they often require more performance than a software-driven 8-bit microcontroller, that's where the low-cost Microchip PIC16F13145 and its small integrated FPGA can give you what you need The place.