Rabbit Semiconductor

Rabbit Semiconductor is the company which designs and sells the Rabbit family of microcontrollers and microcontroller modules.For development, it provides Dynamic C, a limited, largely incompatible dialect of C with proprietary structures for multitasking.

Rabbit Semiconductor was purchased in 2006 by Digi International. Before the purchase, Rabbit Semiconductor was a division of Z-World, Inc. Z-World developed and manufactured embedded controller products as well as embedded software development environments.

The Rabbit processor family shares many features with the Zilog Z80/Z180 processors. For example, the registers of a Rabbit 2000/3000 processor are almost the same as the registers of a Z80/Z180 processor. The Rabbit 4000 processor expands to include the use of 32-bit registers. The instruction set of Rabbit processors also closely resembles the instruction set of the Z80/Z180 family. It should be noted that while the opcode of many instructions are the same between the Rabbit 2000/3000 processors and Z80/Z180 processors, the two families of processors are not binary compatible.

The Rabbit processor family has unique features. For example, the Z80/Z180 family disables interrupts once an interrupt is serviced by an interrupt service routine. However, the Rabbit processors permit interrupts to interrupt service routines according to priorities (a total of 4).

As with the Z80/Z180 family, the Rabbit processors are CISC processors, as opposed to RISC competitors like the Atmel AVR processors. A comparison of clocks per instruction of the Rabbit processor against a typical RISC processor like the AVR reveals that even though the Rabbit processors can use a faster clock (up to 60MHz), the effective processing power is comparable to that of a similarly-priced AVR processor using a slower clock (up to 32MHz). For example, the "INC (IX+d)" instruction requires 12 clocks on a Rabbit processor. The equivalent instruction sequence (LDD, INC, STD) on an AVR requires 5 cycles. Another example is the "CALL" instruction. It requires 12 cycles on a Rabbit processor, versus 4 to 5 cycles on an AVR processor.

This difference, in part, is due to the AVR using on-chip memory for both instructions and data, whereas the Rabbit uses off-chip memory for both instructions and data.

Rabbit Semiconductor claims that the instruction set of Rabbit processors is optimized for C code. A similar claim is made by Atmel for their AVR processors. The two architectures actually have very similar addressing modes, such as literal, register, indirect and indirect plus displacement. Furthermore, both architectures have specialized 16-bit registers. The Rabbit has the IX, IY and SP, whereas the AVR has X, Y and Z.

The main difference is that the Rabbit instructions place more constraints on register usage compared to the AVR instructions. For example, the 8-bit Rabbit "ADD" instruction permits only the A-register be the destination. However, the "ADD" instruction of the AVR permits the use any one of the 32 8-bit registers as the source or destination. Generally speaking, an instruction set that is less register restrictive is more optimizable because there is less need to save-and-reload the content of a register.

Perhaps the most notable part of the Rabbit processor is not the processor itself, but the development tool. Dynamic C, a product of Rabbit Semiconductor, has additions, deletions and inconsistencies compared to the ANSI-C standard.

As an example of addition, Dynamic C has a "chaining" mechanism to chain fragments of code from different subroutines to an arbitrary number of chains. This extension permits the use of not only initialized variables, but any arbitrary code to execute before a program starts execution in the main function.

An an example of deletion, Dynamic C does not support block scope variables, as of version 8. Other features, such as bit fields and enum types are also missing from Dynamic C. The development toolchain does not include separate preprocessor and linker, which makes porting existing C programs complicated.

As an example of inconsistency, Dynamic C treats all initialized variables as "const". Furthermore, all "const" variables reside in flash memory. Earlier versions of Dynamic C did not check the use of "const" in parameters. This means it is possible to pass the pointer of a "const" object to a parameter that expects a pointer to a non-const object. This can potentially lead to somewhat mysterious run-time errors because of attempts to write to flash memory. It is not known whether the current version of Dynamic C enforces "const" constraints.

External links

* [http://www.rabbitsemiconductor.com Rabbit Semiconductor]
* [http://www.rabbitsemiconductor.com/documentation/docs/manuals/DC/DCUserManual/index.htm Dynamic C User's Manual]
* [http://www.digi.com Digi International]
* [http://www.rabbit.com/documentation/docs/refs/TN203/TN203.pdf Porting a Program to Dynamic C]
* [http://www.rabbit.com/documentation/docs/manuals/Rabbit4000/InstructionReference/ Rabbit Family Instruction Reference]
* [http://www.atmel.com/atmel/acrobat/doc0856.pdf AVR Instruction Set (includes clocks per instruction)]