Just uploaded a few vidos to YouTube of an application that uses the MCL51, the microsequencer-based 8051 core.  It is a Lockstep Quad Modular Redundant System.

There are the links:

Lockstep QMR – Artix-7

Lockstep QMR – Spartan-6

The system consists of four modules that have independent voters and the ability to rebuild themselves using data broadcast from neighboring modules. The demonstration videos show modules rebuilding themselves and rejoining the lockstep after receiving multiple types of errors that are injected into each of them.

Because the modules use the microsequencer-based MCL51 processor, the footprint is very small. The complete system consumes around 12% of a Xilinx Artix-7 xc7a35 and about half of a xc6slx9 FPGA.

Please visit us at: www.MicroCoreLabs.com for more information.

I recently picked up a Spartan-6 FPGA board from ebay (for $32!) so I thought it would be fun to load the MCL86 core and wire it up to an IBM PC 5150.  The Xilinx Spartan-6 LX9 costs close to $10 which is significantly cheaper than the $150+ Kintex-7.

Voltage dividers were used to translate between 5V and 3.3V and the FPGA’s IO drivers were set to PCI33 so the VCC clamp diodes would be enabled.  Around 10% of the FPGA’s logic was used by the MCL86 which implemented the 8088 Maximum Mode bus interface.

I read that back in the 80’s two software packages were used to judge if a computer was 100% IBM compatible. One was Lotus-123 and the other was Microsoft’s Flight Simulator. I have already run Lotus-123 successfully on the MCL86 but have not tried Flight Simulator until now.  I was not sure which version of the simulator was used, so I tried both!

Here it is:

Please visit us at: www.MicroCoreLabs.com for more information.

We just posted a video demonstration of a Quad Core MCL51 on YouTube:

 

Each core is running an independent application program.

Core-0: Parallel Port Blaster
Core-1: MIDI music player
Core-2: Sine wave generator using a R-2R DAC
Core-3: 115,200 UART Blaster

Four MCL51 8051 cores are instantiated along with a dual 24-bit timer and a UART.

A total of 1227 Artix-7 LUTs are consumed by this quad core processor which is less logic than most single core gate-based 8051 cores!

Please visit us at: www.MicroCoreLabs.com for more information.

We just uploaded a video to YouTube of the MCL51 playing “Flight of the Bumblebee” in MIDI format.  Here it is:

 

The program is entirely interrupt driven so the only “work” it does is either load a note into timer-0 or a delay into timer-1, after which controls passes back to the main loop. The music data takes about 2KB of Program ROM.

Below is the FPGA utilization using an Xilinx Atrix-7.  It is a little bigger than usual because we are translating the MIDI notes into thirty separate 24-bit counter registers.

 

Please visit us at: www.MicroCoreLabs.com for more information.

Having some fun with the MCL51 and an R-2R DAC.

We have two, eight-channel DACs made with a resistor ladder connected to the PMOD connectors of the Arty Xilinx Artix-7 test board.

The first picture uses the oscilloscope’s X-Y mode to display a 256×256 bit-mapped image.

The second and third images are made by sending the results of a lookup table to the PMOD connectors.

Please visit us at: www.MicroCoreLabs.com for more information.

 

I just uploaded a video of the MCL51 Intel-Hex loader program. The loader is pre-programmed into the FPGA so it will always run when the FPGA is powered up. It prints a splash screen and then waits for the user to halt the CPU, load the Intel-Hex program code, and then unreset the CPU. The process from updating the user’s code, compiling, loading into the FPGA, and then running it takes a matter of seconds!

 

 

Please visit us at: www.MicroCoreLabs.com for more information.

Utilization of the MCL51 Execution Unit which contains the microsequencer and the associated registers and logic which are a bulk of the MCL51 core. This does not include the SFR registers, peripherals, or code and data memories.

Xilinx Kintex  XC7K70T :       194 LUTS and one RAMB

 

Please visit us at: www.MicroCoreLabs.com for more information.

The MicroCore Labs MCL51 was tested in three stages:

During the first stage, an exhaustive set of tests was written in assembly code which would exercise each 8051 opcode and then observe the results. PSW flags were checked whether or not the instruction generated a change in their status and all four register banks were cleared and rechecked to guarantee that the opcode did not affect registers or memory outside of the intended destination. Each boolean instruction was run on multiple memory ranges that support bit-mapped operations while mathematic and string  instruction were run against all possible data values.

After these tests were developed they were run against multiple simulation tools, some of them major vendors. I was interested to find that some of the tools were not 100% correct for every 8051 instruction!  Who the vendors are and what are the errors? I’m not telling. 🙂

Once the tests were validated against multiple vendor simulators I then wired up a system to run the tests on real silicon. I chose a ROM-less 8051 variant that came in a 40-pin package and had 3.3V IOs.  This allowed be to connect it directly to an FPGA test board which you see below:

 

The test code uses simple loops when it reaches a failure, so it was easy to run the test and simply look at the scope to see if it was running in any infinite loops. When it looped to a final address it showed that all of the tests had run successfully. The test code is nearly 6KB so it was divided into three sections and tested independantly.

After the test code was validated by known correct simulators and real silicon I was then ready to run it against the MCL51 core in my Verilog simulation environment. I am pleased that while a few subtle bugs were corrected in the MCL51 core using this test suite, I am now very confident that the core is 100% compatible and correctly implements the 8051 instruction set!

Please visit us at: www.MicroCoreLabs.com for more information.

The MicroCore Labs MCL51 is now available!

The MCL51 is an ultra-small footprint, microsequencer-based, 8051 instruction-set compatible, embedded processor core that can be implemented in any FPGA or ASIC technology.

Key Features:

• 100% Compatible with 8051 instruction set
• Vectored interrupts with up to 128 sources
• Proxy addressing for peripherals to allow any bus size
• Bus Interface Unit allows high degree of peripheral customization

The MCL51 is an embedded processor core implemented with a high performance 32-bit microsequencer which utilizes less than 200 Xilinx LUTS and a single block RAM. It is 100% compatible with the classic 8051 instruction set and has a Bus Interface Unit (BIU) that provides the maximum degree of flexibility to implemented SFR registers and peripherals customized to the user’s design. Improvements to the original 8051 include up to 128 vectored interrupts as well as a proxy addressing system which allows the user to connect peripherals of any bus width to the core.

The core was run against a rigorous suite of tests which were validated using a major simulation tool as well as on genuine 8051 hardware.

The demonstration video of the MCL86 core running on the Lattice XO2 Breakout Board has been posted to YouTube. The FPGA is the XO2-7000 which is around $10 USD.

Here it is:   MCL86 8086 core running on Lattice XO2 Breakout Board

 

 

The video demonstrates how the MCL86 core, 2KB of RAM and a UART are all that is needed to create a practical embedded control processor with a host interface.

The total register utilization is a modest 8% of the $10 Lattice XO2-7000 which leaves most of the FPGA’s registers available for important user logic.

The MCL86 is about as small as you can get when it comes to embedded processor cores that support a practical instruction set.

Please visit us at: www.MicroCoreLabs.com