tinyplc.c

单片PLC,AT2581实现梯形图功能,可作为参考

#endif
   }

/* initialize all logic variables */
void init_logic(void)
   {
   WORD i;

   program_ip = 0;

   for (i = 0; i < PLC_MEMORY_LOCS; i++)
      dataregs[i].v = 0;

   service_outputs();  /* start with outputs OFF */
   }

void nop()
   {
   program_ip++;
   }

void setlinetrue()
   {
   program_ip++;
   linetrue = TRUE;
   }

void pushlinetrue()
   {
   program_ip++;
   if (initstackptr == STACKSIZE)
      {
      program_valid = FALSE;
      runflag = FALSE;
      program_ip = program_len;  /* stop program immediately */
      dataregs[STATUSREG].b.b0 |= STATUS_STK;
      linetrue = FALSE;
      }
   initstack[initstackptr++] = linetrue;
   }

void orbranch()
   {
   program_ip++;
   if ((resultstackptr == STACKSIZE) || (initstackptr == 0))
      {
      program_valid = FALSE;
      runflag = FALSE;
      program_ip = program_len;  /* stop program immediately */
      dataregs[STATUSREG].b.b0 |= STATUS_STK;
      linetrue = FALSE;
      }
   resultstack[resultstackptr++] = linetrue;
   linetrue = initstack[initstackptr - 1];
   }

void orpoplinetrue()
   {
   program_ip++;
   if ((initstackptr == 0) || (resultstackptr == 0))
      {
      program_valid = FALSE;
      runflag = FALSE;
      program_ip = program_len;  /* stop program immediately */
      dataregs[STATUSREG].b.b0 |= STATUS_STK;
      linetrue = FALSE;
      }
   linetrue |= resultstack[--resultstackptr];
   initstackptr--;
   }

void inp()
   {
   if (linetrue)
      linetrue = dataregs[r1].v ? TRUE : FALSE;
   program_ip += 2;
   }

void ninp()
   {
   if (linetrue)
      linetrue = dataregs[r1].v ? FALSE : TRUE;
   program_ip += 2;
   }

void out()
   {
   dataregs[r1].v = linetrue;
   program_ip += 2;
   }

void nout()
   {
   dataregs[r1].v = !linetrue;
   program_ip += 2;
   }

void lout()
   {
   if (linetrue)
      dataregs[r1].v = TRUE;
   program_ip += 2;
   }

void uout()
   {
   if (linetrue)
      dataregs[r1].v = FALSE;
   program_ip += 2;
   }

void setmathflags()  /* set status flags for math op */
   {
   dataregs[STATUSREG].b.b0 &= ~(STATUS_CY | STATUS_ZR | STATUS_OV | STATUS_NG);
   if (!valdest.v)
      dataregs[STATUSREG].b.b0 |= STATUS_ZR;
   if (valdest.b.b3 & SIGNBIT)
      {
      dataregs[STATUSREG].b.b0 |= STATUS_NG;
      if ((!(val1.b.b3 & SIGNBIT)) && (!(val2.b.b3 & SIGNBIT)))
         dataregs[STATUSREG].b.b0 |= STATUS_OV;
      }
   if ((valdest.v < val1.v) && (valdest.v < val2.v))
      dataregs[STATUSREG].b.b0 |= STATUS_CY;
   }

void add()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           + (val2.v = dataregs[r2].v);
      setmathflags();
      }
   program_ip += 4;
   }

void addb()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           + (val2.v = (DWORD)r2);
      setmathflags();
      }
   program_ip += 4;
   }

void sub()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           - (val2.v = dataregs[r2].v);
      setmathflags();
      }
   program_ip += 4;
   }

void subb()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           - (val2.v = (DWORD)r2);
      setmathflags();
      }
   program_ip += 4;
   }

void mul()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           * (val2.v = dataregs[r2].v);
      setmathflags();
      }
   program_ip += 4;
   }

void mulb()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           * (val2.v = (DWORD)r2);
      setmathflags();
      }
   program_ip += 4;
   }

void div()
   {
   if (linetrue)
      {
      if ((val2.v = dataregs[r2].v) == 0)
         {
         dataregs[STATUSREG].b.b0 = STATUS_DIV;
         linetrue = FALSE;
         }
      else
         {
         valdest.v =
         dataregs[program[program_ip+3]].v =
                (val1.v = dataregs[r1].v)
              / val2.v;
         setmathflags();
         }
      }
   program_ip += 4;
   }

void divb()
   {
   if (linetrue)
      {
      if ((val2.v = (DWORD)r2) == 0)
         {
         dataregs[STATUSREG].b.b0 = STATUS_DIV;
         linetrue = FALSE;
         }
      else
         {
         valdest.v =
         dataregs[program[program_ip+3]].v =
                (val1.v = dataregs[r1].v)
              / val2.v;
         setmathflags();
         }
      }
   program_ip += 4;
   }

void mod()
   {
   if (linetrue)
      {
      if ((val2.v = dataregs[r2].v) == 0)
         {
         dataregs[STATUSREG].b.b0 = STATUS_DIV;
         linetrue = FALSE;
         }
      else
         {
         valdest.v =
         dataregs[program[program_ip+3]].v =
                (val1.v = dataregs[r1].v)
              % val2.v;
         setmathflags();
         }
      }
   program_ip += 4;
   }

void modb()
   {
   if (linetrue)
      {
      if ((val2.v = (DWORD)r2) == 0)
         {
         dataregs[STATUSREG].b.b0 = STATUS_DIV;
         linetrue = FALSE;
         }
      else
         {
         valdest.v =
         dataregs[program[program_ip+3]].v =
                (val1.v = dataregs[r1].v)
              % val2.v;
         setmathflags();
         }
      }
   program_ip += 4;
   }

void setlogicflags()  /* set status flags for logic op */
   {
   dataregs[STATUSREG].b.b0 &= ~(STATUS_CY | STATUS_ZR | STATUS_OV | STATUS_NG);
   if (!valdest.v)
      dataregs[STATUSREG].b.b0 |= STATUS_ZR;
   }

void and(void linetrue)
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           & (val2.v = dataregs[r2].v);
      setlogicflags();
      }
   program_ip += 4;
   }

void andb()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           & (val2.v = (DWORD)r2);
      setlogicflags();
      }
   program_ip += 4;
   }

void or()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           | (val2.v = dataregs[r2].v);
      setlogicflags();
      }
   program_ip += 4;
   }

void orb()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           | (val2.v = (DWORD)r2);
      setlogicflags();
      }
   program_ip += 4;
   }

void xor()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           ^ (val2.v = dataregs[r2].v);
      setlogicflags();
      }
   program_ip += 4;
   }

void xorb()
   {
   if (linetrue)
      {
      valdest.v =
      dataregs[program[program_ip+3]].v =
             (val1.v = dataregs[r1].v)
           ^ (val2.v = (DWORD)r2);
      setlogicflags();
      }
   program_ip += 4;
   }

void not()
   {
   if (linetrue)
      {
      val2.v = 0;
      val1.v =
      valdest.v =
      dataregs[r1].v = ~dataregs[r1].v;
      setlogicflags();
      }
   program_ip += 2;
   }

void neg()
   {
   if (linetrue)
      {
      val2.v = 0;
      val1.v =
      valdest.v =
      dataregs[r1].v = -dataregs[r1].v;
      setmathflags();
      }
   program_ip += 2;
   }

void equ()
   {
   linetrue = (dataregs[r1].v == dataregs[r2].v);
   program_ip += 3;
   }

void equb()
   {
   linetrue = (dataregs[r1].v == (DWORD)r2);
   program_ip += 3;
   }

void neq()
   {
   linetrue = (dataregs[r1].v != dataregs[r2].v);
   program_ip += 3;
   }

void neqb()
   {
   linetrue = (dataregs[r1].v != (DWORD)r2);
   program_ip += 3;
   }

void grt()
   {
   linetrue = (dataregs[r1].v > dataregs[r2].v);
   program_ip += 3;
   }

void grtb()
   {
   linetrue = (dataregs[r1].v > (DWORD)r2);
   program_ip += 3;
   }

void geq()
   {
   linetrue = (dataregs[r1].v >= dataregs[r2].v);
   program_ip += 3;
   }

void geqb()
   {
   linetrue = (dataregs[r1].v >= (DWORD)r2);
   program_ip += 3;
   }

void les()
   {
   linetrue = (dataregs[r1].v < dataregs[r2].v);
   program_ip += 3;
   }

void lesb()
   {
   linetrue = (dataregs[r1].v < (DWORD)r2);
   program_ip += 3;
   }

void leq()
   {
   linetrue = (dataregs[r1].v <= dataregs[r2].v);
   program_ip += 3;
   }

void leqb()
   {
   linetrue = (dataregs[r1].v <= (DWORD)r2);
   program_ip += 3;
   }

void mov()
   {
   if (linetrue)
      {
      dataregs[r1].v = dataregs[r2].v;
      }
   program_ip += 3;
   }

void movd()
   {
   if (linetrue)
      {
      dataregs[r1].v = *(DWORD *)&program[program_ip+2];
      }
   program_ip += 6;
   }

void jmp()
   {
   if (linetrue)
      {
      program_ip = *(WORD *)&program[program_ip+1];
      }
   else
      program_ip += 3;
   }

void osr()
   {
   tempvar = linetrue;  /* need to save this before we change it */
   if (linetrue)
      {
      if (dataregs[r1].b.b0)
         linetrue = FALSE;
      }
   dataregs[r1].b.b0 = tempvar;
   program_ip += 2;