The computer language “immediate C”

The programming language “immediate C” or iC is a declarative, event-driven extension of the procedural language C – useful for machine control, robotics and for dealing with events generated in a GUI.

iC utilizes the syntax of C to give meaning to statements that have no semantic support in C. In addition to standard variables, which are modified by the flow of instructions, iC provides so-called ‘immediate‘ variables, whose values are updated, whenever a change of input calls for an immediate change in output. An efficient Data Flow technique implements this strategy.

iC provides programmers with built-in operators, whose function is closely modelled on integrated circuits. The name iC is a reminder of this fact. Logical AND, OR, EXCLUSIVE-OR and NOT as well as D flip-flops, SR flip-flops, shift registers and many others are implemented in such a way, that their use in iC follows the same design rules, which apply to their hardware counterparts. These rules have led to a well-developed hardware technology, whose effectiveness is demonstrated by the success of today’s complex computer hardware. Particularly the concept of clocked functions plays an important role in the language iC. It gives the same protection against timing races in iC programs, as it provides for hardware IC designs. But iC is not a hardware description language nor a simulation language – it provides the functionality and some of the speed of field-programmable gate arrays with a language, which is pre-compiled into straight C code, which is portable and produces efficient machine code.

Writing programs in the language iC has the added quality, that many simple ideas and relationships, which should result in direct actions, can be written down immediately in one line. The coding of call back routines and other overhead is not required. It was this thought, which also prompted the name “immediate C“. The following is a fully working iC program. The output message is triggered by the external switch IX0.0.

 if (IX0.0) { printf(“hello, world\n”); }

The design of immediate C was very much influenced by thinking about biological neural networks in the brain. How is it possible that such relatively slow chemical components as neurons and synapses can process such vast amounts of information at the speed that they do? The algorithms at the heart of the iC system are based directly on synapses and biological neural networks – not for artificial learning, but simply to gain speed.

An iC program consists mostly of a series of logical and arithmetic expressions, each expression declaring the relationship between some external inputs and/or intermediate variables on either another intermediate variable or on an external output. This type of program and functionality is very similar to that of an industrial “Programmable Logic Controller (PLC)”. In iC, these expressions are not executed in sequence as is the case for all instruction flow languages, including PLCs, but only when an input to one of the expressions changes. This feature makes immediate C a ‘declarative’ computer language and is the basis of its event-driven strategy. The fundamental assumption for iC is, that the output of an expression does not change if none of its inputs has changed and therefore does not need to be executed until one of its inputs does change – but then it should be executed immediately (at least as soon as possible). This event-driven strategy gives iC an enormous speed advantage over PLC’s, which execute every instruction in the program over and over sequentially – independent of whether the instruction causes a change or not.

Here is an example of a simple iC control program for a water heater with external inputs on, waterLevel, temperature; intermediate variables waterLo, tempLo and external outputs fill, heat, ready:

 imm bit on; // & is AND, ~ is NOT in iC
 imm int waterLevel, temperature;

 imm bit waterLo = waterLevel < 90;
 imm bit tempLo  = temperature < 98;

 imm bit fill    = on &  waterLo;
 imm bit heat    = on & ~waterLo & tempLo;
 imm bit ready   = on & ~tempLo;

If these expressions were placed in an instruction flow environment, each of the expressions would have to be executed over and over at regular intervals, because that is the only way to catch a change in any of the inputs to an expression. This is what an industrial Programmable Logic Controller (PLC) does. The polling interval determines the maximum response time of the controller. But this response time must always be a compromise between the total number of control expressions, an acceptable response time and an acceptable CPU loading. For PLC’s the CPU is 100% compute-bound and even then there is a limit to the number of expressions that can be tolerated before such a controller becomes too slow.

Each of the above variables in the iC environment is an immediate variable. bit and int immediate variables are objects, which have a value, but each such variable also has a list of pointers to those expressions in which the variable occurs. Each of these variables, which have one assignment expression to determine their value or are an external interrupt input, is called a Node and the pointers associated with each immediate variable Node object link these nodes into a network, much like a neural network, where the expression nodes are the synapses and the pointers to other expression nodes are the dendrites. This forward action of signals from one expression node to the next constitutes the basic data flow strategy of the iC system, which was copied from biological neural networks.

The Analogy to neural networks is even closer. Synapses fire when a certain input threshold is exceeded at which time signals flow through dendrites to other synapses. Each AND or OR bit expression in iC is implemented by majority logic in which the number of hi inputs are counted. When the number of hi inputs reaches a threshold (just like in a synapse) the expression node fires, at which point it executes a similar action in all the expression nodes on which it acts (in which it is an input). The only difference between an AND majority node and an OR majority node is the threshold, which is set once at the initialisation of the system. The threshold for an OR expression node is 1 – only 1 input hi fires the node. The threshold for an AND node is the number n of its inputs. All n inputs of an AND node must be hi for it to fire. It only takes a few machine instructions to execute this algorithm. The upshot is, that the internal response time of the iC system to one change is in the order of nanoseconds for modern CPU’s, even for control programs with thousands of immediate expressions. Most of the real response time is in the drivers, getting inputs and outputs from and to their electronic connections. The CPU loading is generally well under 1%.

Another way to view the run-time model for iC is to think of expression nodes as digital or analog IC components, interconnected by their forward pointers. Keeping this view in mind may make programming iC easier. Even such concepts as Large Scale Integration (LSI) are catered for with so-called ‘function blocks’, which allow the programming of groups of interconnected expression nodes into a sub-assembly with a list of parameters for connecting to the rest of the iC program. Such function blocks look very similar to C functions, but their execution is very different. C functions execute their instructions each time they are called. iC function blocks are templates, which are cloned for every instance in which the function block is used (not called). Each instance has its own internal expression nodes which only execute when one of their inputs changes.

A full Integrated Development Environment (IDE) called iClive, with a full editor with emacs bindings, buttons to build iC programs and run one or more of them in parallel as well as debugging facilities, is included in the distribution. A special debugging facility called ‘Live display’ shows the state of iC variables of a running program by changing the colour of those variables in the program text. (This facility is standard for PLC’s and factory personnel would be very familiar with it). Another debugging facility is Watchpoints, which stop execution when any marked immediate variable changes or reaches a certain value and the ability to single-step the code a single change at a time. This is more common for instruction flow language debuggers with Breakpoints, but the ability to freeze an iC program and look at its state while things are not changing makes testing iC code much easier.

The Header picture of this post shows iClive loaded with a simple program andOrXor.ic and running it in ‘Live’ mode, showing some values Hi (yellow/red) and some values LO (green/black). I/O is taken from a separate virtual app iCbox (shown on the left of the Header picture).

iCbox allows the generation of inputs and the display of outputs while an application is running. The screen hardcopy on the right shows the iCbox window for the sample program demo.ic, which is written in the iC language and which is part of the software distribution. To start the program simply type “iClive demo.ic” and click “Build”, “Run” and “Live”. The documentation contains full instructions on how to install and use the software.

iClive is both a text editor and an online debugger, which can display the live state of variables as an iC program is running. This is shown on the right using the same demo.ic program as above, with different variables changing from LO (green/black) to HI (yellow/red).

To start with immediate C, have a look at the immediate C Programming Manual in the Books section of this site, which starts with a tutorial introduction of the language in the style of the K&R C Programming Language, building up from there discussing all the features added to C. The immediate C Reference Manual describes the iC language and its built-in function blocks in detail. Several small but important features have been added to the language in the last year and both manuals reflect these changes.

On a Linux system and particularly on a Raspberry Pi you can clone the whole GIT repository from  https://github.com/JohnWulff/immediatec.git or download the ZIP file of the latest release from the same GitHub site and try your own iC code very quickly.

immediate C is built with the usual configure – make – make test – make install commands. The README explains the details and how to make, run and debug iC apps.

immediate C can execute direct Input/Output on a Raspberry Pi computer. Drivers are included for digital I/O on GPIO’s and PiFace cards as well as a driver for PWM analog output on GPIO’s and analog input from an MCP3008 A/D converter. See README.RPi for details.

A number of interesting machine control projects have been realised with Raspberry Pi’s and their associated peripherals. The most realistic was a one metre high Meccano model of a lift system built by Keith Burston. This lift services four floors with a moving cage and counterweight driven by an electric motor and motor-driven inside doors, which mechanically engage with the outside doors at each floor to open both together. It has outside floor buttons and a box with inside floor buttons as well as floor indicators. Keith Burston’s original controller was made from miniature relays and a rotating sequencer.

Keith built an electronic interface to his lift based on PiFace hardware. The iC control program kbLift.ic uses iCpiFace as a driver. It does proper queuing of floor requests from both outside and inside the lift and follows a regular sequence of up and down movements to the nearest floor in the current direction, which is not necessarily the sequence in which floor request buttons were pressed.

To run the lift control program without the Meccano model, I have a virtual lift system based on a GUI called iClift, generated with a Perl/Tk canvas. It has a simulated cage and doors and all the right buttons. The GUI simply communicates with the iC control program with the same message protocol as all other iC drivers like iCpiFace for connection to real I/O or iCbox, which is a virtual I/O.

The screen below shows iClift with all its controls and an iClive screen showing the “request floor” logic.

The full video of the virtual lift with sound can be shown from here.

All iC support programs, such as iCmake and the iC pre-compiler immcc, iClive, iCbox, iCserver as well as drivers iCpiFace and iCpiPWM and even iClift have man pages, which can be shown with the standard Linux program ‘man‘. A good way to show man pages is the man page viewer iCman, which is part of the immediate C distribution. This image shows the man page for iClive displayed by iCman with the search word ‘Text’ highlighted.