path: root/ldmicro/ldinterpret.c

//-----------------------------------------------------------------------------
// A sample interpreter for the .int files generate by LDmicro. These files
// represent a ladder logic program for a simple 'virtual machine.' The
// interpreter must simulate the virtual machine and for proper timing the
// program must be run over and over, with the period specified when it was
// compiled (in Settings -> MCU Parameters).
//
// This method of running the ladder logic code would be useful if you wanted
// to embed a ladder logic interpreter inside another program. LDmicro has
// converted all variables into addresses, for speed of execution. However,
// the .int file includes the mapping between variable names (same names
// that the user specifies, that are visible on the ladder diagram) and
// addresses. You can use this to establish specially-named variables that
// define the interface between your ladder code and the rest of your program.
//
// In this example, I use this mechanism to print the value of the integer
// variable 'a' after every cycle, and to generate a square wave with period
// 2*Tcycle on the input 'Xosc'. That is only for demonstration purposes, of
// course.
//
// In a real application you would need some way to get the information in the
// .int file into your device; this would be very application-dependent. Then
// you would need something like the InterpretOneCycle() routine to actually
// run the code. You can redefine the program and data memory sizes to
// whatever you think is practical; there are no particular constraints.
//
// The disassembler is just for debugging, of course. Note the unintuitive
// names for the condition ops; the INT_IFs are backwards, and the INT_ELSE
// is actually an unconditional jump! This is because I reused the names
// from the intermediate code that LDmicro uses, in which the if/then/else
// constructs have not yet been resolved into (possibly conditional)
// absolute jumps. It makes a lot of sense to me, but probably not so much
// to you; oh well.
//
// Jonathan Westhues, Aug 2005
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <ctype.h>
#include <unistd.h>

#define INTCODE_H_CONSTANTS_ONLY
#include "intcode.h"

typedef unsigned char BYTE;     // 8-bit unsigned
typedef unsigned short WORD;    // 16-bit unsigned
typedef signed short SWORD;     // 16-bit signed

// Some arbitrary limits on the program and data size
#define MAX_OPS                 1024
#define MAX_VARIABLES           128
#define MAX_INTERNAL_RELAYS     128

// This data structure represents a single instruction for the 'virtual
// machine.' The .op field gives the opcode, and the other fields give
// arguments. I have defined all of these as 16-bit fields for generality,
// but if you want then you can crunch them down to 8-bit fields (and
// limit yourself to 256 of each type of variable, of course). If you
// crunch down .op then nothing bad happens at all. If you crunch down
// .literal then you only have 8-bit literals now (so you can't move
// 300 into 'var'). If you crunch down .name3 then that limits your code size,
// because that is the field used to encode the jump addresses.
// 
// A more compact encoding is very possible if space is a problem for
// you. You will probably need some kind of translator regardless, though,
// to put it in whatever format you're going to pack in flash or whatever,
// and also to pick out the name <-> address mappings for those variables
// that you're going to use for your interface out. I will therefore leave
// that up to you.
typedef struct {
    WORD    op;
    WORD    name1;
    WORD    name2;
    WORD    name3;
    SWORD   literal;
} BinOp;

BinOp Program[MAX_OPS];
SWORD Integers[MAX_VARIABLES];
BYTE Bits[MAX_INTERNAL_RELAYS];

// This are addresses (indices into Integers[] or Bits[]) used so that your
// C code can get at some of the ladder variables, by remembering the
// mapping between some ladder names and their addresses.
int SpecialAddrForA;
int SpecialAddrForXosc;

//-----------------------------------------------------------------------------
// What follows are just routines to load the program, which I represent as
// hex bytes, one instruction per line, into memory. You don't need to
// remember the length of the program because the last instruction is a
// special marker (INT_END_OF_PROGRAM).
//
void BadFormat(void)
{
    fprintf(stderr, "Bad program format.\n");
    exit(-1);
}
int HexDigit(int c)
{
    c = tolower(c);
    if(isdigit(c)) {
        return c - '0';
    } else if(c >= 'a' && c <= 'f') {
        return (c - 'a') + 10;
    } else {
        BadFormat();
    }
    return 0;
}
void LoadProgram(char *fileName)
{
    int pc;
    FILE *f = fopen(fileName, "r");
    char line[80];

    // This is not suitable for untrusted input.

    if(!f) {
        fprintf(stderr, "couldn't open '%s'\n", f);
        exit(-1);
    }

    if(!fgets(line, sizeof(line), f)) BadFormat();
    if(strcmp(line, "$$LDcode\n")!=0) BadFormat();

    for(pc = 0; ; pc++) {
        char *t, i;
        BYTE *b;

        if(!fgets(line, sizeof(line), f)) BadFormat();
        if(strcmp(line, "$$bits\n")==0) break;
        if(strlen(line) != sizeof(BinOp)*2 + 1) BadFormat();

        t = line;
        b = (BYTE *)&Program[pc];

        for(i = 0; i < sizeof(BinOp); i++) {
            b[i] = HexDigit(t[1]) | (HexDigit(t[0]) << 4);
            t += 2;
        }
    }

    SpecialAddrForA = -1;
    SpecialAddrForXosc = -1;
    while(fgets(line, sizeof(line), f)) {
        if(memcmp(line, "a,", 2)==0) {
            SpecialAddrForA = atoi(line+2);
        }
        if(memcmp(line, "Xosc,", 5)==0) {
            SpecialAddrForXosc = atoi(line+5);
        }
        if(memcmp(line, "$$cycle", 7)==0) {
            if(atoi(line + 7) != 10*1000) {
                fprintf(stderr, "cycle time was not 10 ms when compiled; "
                    "please fix that.\n");
                exit(-1);
            }
        }
    }

    if(SpecialAddrForA < 0 || SpecialAddrForXosc < 0) {
        fprintf(stderr, "special interface variables 'a' or 'Xosc' not "
            "used in prog.\n");
        exit(-1);
    }

    fclose(f);
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Disassemble the program and pretty-print it. This is just for debugging,
// and it is also the only documentation for what each op does. The bit
// variables (internal relays or whatever) live in a separate space from the
// integer variables; I refer to those as bits[addr] and int16s[addr]
// respectively.
//-----------------------------------------------------------------------------
void Disassemble(void)
{
    int pc;
    for(pc = 0; ; pc++) {
        BinOp *p = &Program[pc];
        printf("%03x: ", pc);

        switch(Program[pc].op) {
            case INT_SET_BIT:
                printf("bits[%03x] := 1", p->name1);
                break;

            case INT_CLEAR_BIT:
                printf("bits[%03x] := 0", p->name1);
                break;

            case INT_COPY_BIT_TO_BIT:
                printf("bits[%03x] := bits[%03x]", p->name1, p->name2);
                break;

            case INT_SET_VARIABLE_TO_LITERAL:
                printf("int16s[%03x] := %d (0x%04x)", p->name1, p->literal,
                    p->literal);
                break;

            case INT_SET_VARIABLE_TO_VARIABLE:
                printf("int16s[%03x] := int16s[%03x]", p->name1, p->name2);
                break;

            case INT_INCREMENT_VARIABLE:
                printf("(int16s[%03x])++", p->name1);
                break;

            {
                char c;
                case INT_SET_VARIABLE_ADD: c = '+'; goto arith;
                case INT_SET_VARIABLE_SUBTRACT: c = '-'; goto arith;
                case INT_SET_VARIABLE_MULTIPLY: c = '*'; goto arith;
                case INT_SET_VARIABLE_DIVIDE: c = '/'; goto arith;
arith:
                    printf("int16s[%03x] := int16s[%03x] %c int16s[%03x]",
                        p->name1, p->name2, c, p->name3);
                    break;
            }

            case INT_IF_BIT_SET:
                printf("unless (bits[%03x] set)", p->name1);
                goto cond;
            case INT_IF_BIT_CLEAR:
                printf("unless (bits[%03x] clear)", p->name1);
                goto cond;
            case INT_IF_VARIABLE_LES_LITERAL:
                printf("unless (int16s[%03x] < %d)", p->name1, p->literal);
                goto cond;
            case INT_IF_VARIABLE_EQUALS_VARIABLE:
                printf("unless (int16s[%03x] == int16s[%03x])", p->name1,
                    p->name2);
                goto cond;
            case INT_IF_VARIABLE_GRT_VARIABLE:
                printf("unless (int16s[%03x] > int16s[%03x])", p->name1,
                    p->name2);
                goto cond;
cond:
                printf(" jump %03x+1", p->name3);
                break;

            case INT_ELSE:
                printf("jump %03x+1", p->name3);
                break;

            case INT_END_OF_PROGRAM:
                printf("<end of program>\n");
                return;

            default:
                BadFormat();
                break;
        }
        printf("\n");
    }
}

//-----------------------------------------------------------------------------
// This is the actual interpreter. It runs the program, and needs no state
// other than that kept in Bits[] and Integers[]. If you specified a cycle
// time of 10 ms when you compiled the program, then you would have to
// call this function 100 times per second for the timing to be correct.
//
// The execution time of this function depends mostly on the length of the
// program. It will be a little bit data-dependent but not very.
//-----------------------------------------------------------------------------
void InterpretOneCycle(void)
{
    int pc;
    for(pc = 0; ; pc++) {
        BinOp *p = &Program[pc];

        switch(Program[pc].op) {
            case INT_SET_BIT:
                Bits[p->name1] = 1;
                break;

            case INT_CLEAR_BIT:
                Bits[p->name1] = 0;
                break;

            case INT_COPY_BIT_TO_BIT:
                Bits[p->name1] = Bits[p->name2];
                break;

            case INT_SET_VARIABLE_TO_LITERAL:
                Integers[p->name1] = p->literal;
                break;

            case INT_SET_VARIABLE_TO_VARIABLE:
                Integers[p->name1] = Integers[p->name2];
                break;

            case INT_INCREMENT_VARIABLE:
                (Integers[p->name1])++;
                break;

            case INT_SET_VARIABLE_ADD:
                Integers[p->name1] = Integers[p->name2] + Integers[p->name3];
                break;

            case INT_SET_VARIABLE_SUBTRACT:
                Integers[p->name1] = Integers[p->name2] - Integers[p->name3];
                break;

            case INT_SET_VARIABLE_MULTIPLY:
                Integers[p->name1] = Integers[p->name2] * Integers[p->name3];
                break;

            case INT_SET_VARIABLE_DIVIDE:
                if(Integers[p->name3] != 0) {
                    Integers[p->name1] = Integers[p->name2] /
                                                Integers[p->name3];
                }
                break;

            case INT_IF_BIT_SET:
                if(!Bits[p->name1]) pc = p->name3;
                break;

            case INT_IF_BIT_CLEAR:
                if(Bits[p->name1]) pc = p->name3;
                break;

            case INT_IF_VARIABLE_LES_LITERAL:
                if(!(Integers[p->name1] < p->literal)) pc = p->name3;
                break;

            case INT_IF_VARIABLE_EQUALS_VARIABLE:
                if(!(Integers[p->name1] == Integers[p->name2])) pc = p->name3;
                break;

            case INT_IF_VARIABLE_GRT_VARIABLE:
                if(!(Integers[p->name1] > Integers[p->name2])) pc = p->name3;
                break;

            case INT_ELSE:
                pc = p->name3;
                break;

            case INT_END_OF_PROGRAM:
                return;
        }
    }
}


int main(int argc, char **argv)
{
    int i;

    if(argc != 2) {
        fprintf(stderr, "usage: %s xxx.int\n", argv[0]);
        return -1;
    }

    LoadProgram(argv[1]);
    memset(Integers, 0, sizeof(Integers));
    memset(Bits, 0, sizeof(Bits));

    // 1000 cycles times 10 ms gives 10 seconds execution
    for(i = 0; i < 1000; i++) {
        InterpretOneCycle();

        // Example for reaching in and reading a variable: just print it.
        printf("a = %d              \r", Integers[SpecialAddrForA]);

        // Example for reaching in and writing a variable.
        Bits[SpecialAddrForXosc] = !Bits[SpecialAddrForXosc];

        // XXX, nonportable; replace with whatever timing functions are
        // available on your target.
        usleep(10000);
    }

    return 0;
}