diff options
Diffstat (limited to 'ldmicro/ldinterpret.c')
| -rw-r--r-- | ldmicro/ldinterpret.c | 380 |
1 files changed, 380 insertions, 0 deletions
diff --git a/ldmicro/ldinterpret.c b/ldmicro/ldinterpret.c new file mode 100644 index 0000000..a37ff09 --- /dev/null +++ b/ldmicro/ldinterpret.c @@ -0,0 +1,380 @@ +//----------------------------------------------------------------------------- +// 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; +} |