New generations of RISC based micro-controllers, like the Microchip PIC series, have changed the landscape of controller design and application. Over the past five to ten years, controller designing has gone from the exclusive technical domain of assembly language programmers to the all inclusive domain of virtually anyone with a desire to control something. Managers, artists, scientists, hobbyists, farmers, etc. are now controlling everything from lights to heavy machinery with small upper-level language controllers. Traditionally, there was a separation of the people responsible for the conception of a controller application and the people implementing the concept. Today, as often as not, non-technical persons are implementing their own concepts with as few "tools" as a PC compatible computer and a soldering iron.
What is causing this change? Fundamentally it has been the increased availability and awareness of processors pre-programmed with upper-level language interpreters. This whole revolution started over a decade ago with the introduction of Intel BASIC versions of popular single chip computers. Devices like the Z8 and 8051 freed would-be controller designers from the need to understand processor architectures, memory busses, interrupt handling, and assembly level coding. Suddenly, a simple controller design consisted of just a few ICs and some cookbook interconnection.
This strain of controller technology has continued to the present day to produce controllers like the Protean Logic FBASIC TICkit, and the Parallax BASIC STAMP. These products utilize the increased I/O capabilities and RISC speed of the PIC processors to create virtual interpreting engines that perform amazingly well.
Many of the new upper-level languages do not even implement a traditional address and data buss in the design. This concept is not all that new, single chip processors have been around for some time. What is new is that pre-programmed processors no longer have address and data buss connections to EPROM, RAM and I/O peripherals. The new trend is to utilize serial devices to reduce the number of device interconnections, shrink the physical size of the circuit, and simplify the design and programming of the controllers.
Traditional controller designers might scoff at this method, but consider how much time is routinely wasted drawing the 8 data lines, 16 address lines, and address decoding on a schematic of a typical controller. This time and space is wasted again during layout and finally in the assembly of the product.
To the non-technical, or experienced designer for that matter, the small number of interconnections is far easier to conceptualize and implement than the traditional rats-nest of buss connections.
2-wire and 3-wire products made by Phillips, National Semiconductor, Microchip, Dallas Semiconductor, and SGS Thompson (to name a few) include EEprom, Flash ROM, A/D converters, D/A converters, LED and LCD controllers, Temperature sensors, and many other devices.
The application of these small RISC processors is not just limited to programmable control either. The low cost, relative high speed and small physical size of these RISC controllers has led them to be used as monolithic solutions to common peripheral problems. For example, a product manufactured by Scott Edward's Electronics enables a simple one wire RS232 connection to control any HD44780 based LCD module. Because LCD panels are so often located off-board, the wiring saved by using the S.E.E. product is often worth the cost of the peripheral IC.
Protean Logic Inc. offers the Xtender Product which utilizes a 2-wire I2C connection to access a specially pre-programmed PIC16C73. This single 28 pin package, connected to the host processor by only 2-wires, gives the controller five 8 bit A/D channels, 128 bytes of SRAM, 8 general purpose I/O lines, RS232 drivers buffered 16 bytes deep, an intelligent stepper motor controller, a real-time clock, a 16 bit counter/timer, and two PWM outputs, not to mention the other less important features. Protean Logic Inc. and other companies offer processors pre-programmed to handle a variety of tasks including X-10 control, battery monitoring and charging, IBM style keyboard interfaces, infrared Remote protocol controllers, RS232 buffered transceivers, tiny-buss and other small network controllers, pulse measuring and generating ICs, etc. Many of these are implemented in Microchip 12C50x controllers which are 8 pin ICs.
This growing list of monolithic solutions frees controller applications from many of the more difficult concurrent tasks. Time dependent tasks are simply being turned over to other ICs instead of using interrupts and fast code on the main processor.
Obviously, interpreted high-level language code cannot be as fast as native processor code. Peripheral ICs cannot transfer information as fast as hardware shift registers either. However, the performance loss is not as great as might be expected. Most of these controllers have a fairly complete library of I/O functions that operate at full native code speed. As long as the user application consists primarily of a sequence of functions implemented in the internal library of these processors, there is very little performance degradation.
What these processors actually represent is a whole new paradigm of instruction set design. We have already heard of CISC and RISC. These processors are virtual CPUs with instruction sets that can be characterized as VCISC or Very Complex Instruction Set Computing. A normal CISC instruction might be capable of indexing into an array of bytes using a register and load the accumulator. A single VCISC "instruction" might take several pointers and execute a pulse out instruction, or an EEprom write instruction. This philosophy is basically the anti-RISC philosophy. Instead of dealing with things on the atomic or even "molecular" level, VCISC narrows the available options, but offers the programming language a whole host of relatively complex compound functions to choose from. Variable and parameter reference schemes are hard-coded into the instruction set of these processors. Protean Logic Inc. is currently developing firmware to implement a complete multi-tasking operating system in a PIC16C74. In this case, what would traditionally be a collection of interrupt calls to the operating system is being implemented as VCISC instructions in the processor firmware.
Other advantages are gained by controller applications that utilize these new processors. Most of these processors have some sort of built in debugging kernel. This means that additional hardware or tools are not required to step through code and examine variables. Also, most of these processors are "self-programming". This means that only a serial cable is required to download a program into the controller. Thereby the lengthy plugging and un-plugging of UV erasable EEPROMS. Field upgrades also become very easy. A field technician can simply plug a laptop into a controller and download the new coding. By definition, these products are in-circuit programmable.
The simplicity of programming allows the life of a controller to be extended. Often, the original programmer for a project is unavailable a year or more after a product is created. Upper-level languages are so much more readable and modifiable, that older designs can easily be upgraded instead of trashed when market or user needs change. Another advantage, which is not immediately obvious, is that the user interface for controller products can now even include some programming. Say a controller needs to perform an action on the basis of input stimulus. Traditionally, the controller designer would need to foresee all such conditions and reduce the user programming to simple set point modifications. With upper-level language control, schemes can be developed which actually allow the user to modify parts of the control program for the unforeseen requirement.
The relative ease of development on these controllers also presents some plain dollars and cents advantages as well. Less experienced programmers can be used for new designs. Concept to market times are reduced. Design, prototyping, and layout all occur faster without the buss interconnections. New ideas can be explored easier and with less initial investment. Many manager level engineers are utilizing these products for mock-ups and initial concept proofs. This allows them to keep their skilled people working on the money making projects and, at the same time, allows the future to be explored more completely. Of course, working models are also much easier to explain to both sales departments and engineers.
There are many, many applications which require more processing speed, or unique functionality that simply cannot be accommodated by the function libraries of these pre-programmed interpreters. For applications that do not require unique types of I/O or high speed operation, however, these controllers may very well be the best way to go. At least for prototyping, and possibly for final production as well, depending on the number of units to be produced.
As more capable RISC based processors become available, the power and flexibility of both virtual processors and intelligent peripherals will increase. The RISC one time programmable controller (OTP) has literally opened a Pandora's box with regard to unique off the shelf pre-programmed solutions and building blocks. Every software engineer out there with a good generic solution is now free to package that solution in an OTP processor and offer it to us at a very affordable price! So, for your next controller design or application, consider basing it on one of the upper-level interpreter processors.
Protean Logic Inc. Copyright 09/30/04 Top of Page