plc2.c

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

void nout_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[NOUT_OBJ].label,fg,bg);
   coverlay(r,c,objs[NOUT_OBJ].overlay,fg);
   showregtype(r-TEXTHEIGHTSMALL,c+2*TEXTWIDTH,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   }

WORD nout_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 2;
   return(compile_node(nodeptr,*len,buf));
   }

void lout_init(nodeptr)
   struct logic_element *nodeptr;
   {
   BYTE str[12];
   BYTE type;
   DWORD reg;

   get_values("Latch Output","Output ? ",NULL,NULL,str,NULL,NULL);
   if (parse_io_str(str,&type,&reg))
      {
      if ((type == VAR_TYPE) || (type == OUTPUT_TYPE))
         {
         nodeptr->opcode[0] = LOUT;
         nodeptr->opcode[1] = reg;
         nodeptr->opflags[1] = type;
         }
      else
         beep();
      }
   }

void lout_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void lout_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[LOUT_OBJ].label,fg,bg);
   coverlay(r,c,objs[LOUT_OBJ].overlay,fg);
   showregtype(r-TEXTHEIGHTSMALL,c+TEXTWIDTH,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   }

WORD lout_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 2;
   return(compile_node(nodeptr,*len,buf));
   }

void uout_init(nodeptr)
   struct logic_element *nodeptr;
   {
   BYTE str[12];
   BYTE type;
   DWORD reg;

   get_values("Unlatch Output","Output ? ",NULL,NULL,str,NULL,NULL);
   if (parse_io_str(str,&type,&reg))
      {
      if ((type == VAR_TYPE) || (type == OUTPUT_TYPE))
         {
         nodeptr->opcode[0] = UOUT;
         nodeptr->opcode[1] = reg;
         nodeptr->opflags[1] = type;
         }
      else
         beep();
      }
   }

void uout_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void uout_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[UOUT_OBJ].label,fg,bg);
   coverlay(r,c,objs[UOUT_OBJ].overlay,fg);
   showregtype(r-TEXTHEIGHTSMALL,c+TEXTWIDTH,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   }

WORD uout_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 2;
   return(compile_node(nodeptr,*len,buf));
   }

void math_node(nodeptr, label, opcode, opcodeb,swapok)
   struct logic_element *nodeptr;
   BYTE *label, opcode, opcodeb;
   {
   BYTE str1[12], str2[12], strdest[12];
   BYTE type1,type2,typedest;
   DWORD reg1,reg2,regdest;
   DWORD tempreg;

   get_values(label,
              "Destination ? ",
              "First op    ? ",
              "Second op   ? ",
              strdest,
              str1,
              str2);
   if ((parse_io_str(str1,&type1,&reg1))
          && (parse_io_str(str2,&type2,&reg2))
          && (parse_io_str(strdest,&typedest,&regdest)))
      {
      if ((typedest != VAR_TYPE) && (typedest != OUTPUT_TYPE))
         {
         beep();
         return;
         }
      if ((type1 == LABEL_TYPE) || (type2 == LABEL_TYPE))
         {
         beep();
         return;
         }
      if (type1 == BYTEVAL_TYPE)
         {
         if (!swapok)
            {
            beep();
            return;
            }
         if (type2 == BYTEVAL_TYPE)
            {
            beep();
            return;
            }
         tempreg = reg1;
         type1 = type2;
         reg1 = reg2;
         type2 = BYTEVAL_TYPE;
         reg2 = tempreg;
         }
      nodeptr->opcode[0] = (type2 == BYTEVAL_TYPE) ? opcodeb : opcode;
      nodeptr->opcode[1] = reg1;
      nodeptr->opcode[2] = reg2;
      nodeptr->opcode[3] = regdest;
      nodeptr->opflags[1] = type1;
      nodeptr->opflags[2] = type2;
      nodeptr->opflags[3] = typedest;
      }
   }

math_draw(r,c,nodeptr,symbol)
   WORD r, c;
   struct logic_element *nodeptr;
   BYTE *symbol;
   {
   showregtype(r-TEXTHEIGHTSMALL,c,nodeptr->opflags[3],(DWORD)nodeptr->opcode[3]);
   smallstrout(r-TEXTHEIGHTSMALL,c+4*TEXTWIDTH,"=");
   showregtype(r+TEXTHEIGHT,c,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   smallstrout(r+TEXTHEIGHT,c+3*TEXTWIDTH,symbol);
   showregtype(r+TEXTHEIGHT,c+4*TEXTWIDTH,nodeptr->opflags[2],(DWORD)nodeptr->opcode[2]);
   }

void add_init(nodeptr)
   struct logic_element *nodeptr;
   {
   math_node(nodeptr,"Add: dest = (1) + (2)",ADD,ADDB,TRUE);
   }

void add_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void add_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[ADD_OBJ].label,fg,bg);
   coverlay(r,c,objs[ADD_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"+");
   }

WORD add_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void sub_init(nodeptr)
   struct logic_element *nodeptr;
   {
   math_node(nodeptr,"Sub: dest = (1) - (2)",SUB,SUBB,FALSE);
   }

void sub_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void sub_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[SUB_OBJ].label,fg,bg);
   coverlay(r,c,objs[SUB_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"-");
   }

WORD sub_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void mul_init(nodeptr)
   struct logic_element *nodeptr;
   {
   math_node(nodeptr,"Mul: dest = (1) * (2)",MUL,MULB,TRUE);
   }

void mul_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void mul_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[MUL_OBJ].label,fg,bg);
   coverlay(r,c,objs[MUL_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"*");
   }

WORD mul_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void div_init(nodeptr)
   struct logic_element *nodeptr;
   {
   WORD i;

   math_node(nodeptr,"Div: dest = (1) / (2)",DIV,DIVB,FALSE);
   if ((nodeptr->opflags[2] == BYTEVAL_TYPE) && (nodeptr->opcode[2] == 0))
      {
      for (i = 1; i < OPCODE_MAX; i++)
         nodeptr->opflags[i] = UNUSED_TYPE;
      beep();
      }
   }

void div_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void div_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[DIV_OBJ].label,fg,bg);
   coverlay(r,c,objs[DIV_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"/");
   }

WORD div_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void mod_init(nodeptr)
   struct logic_element *nodeptr;
   {
   WORD i;

   math_node(nodeptr,"Mod: dest = (1) % (2)",MOD,MODB,FALSE);
   if ((nodeptr->opflags[2] == BYTEVAL_TYPE) && (nodeptr->opcode[2] == 0))
      {
      for (i = 1; i < OPCODE_MAX; i++)
         nodeptr->opflags[i] = UNUSED_TYPE;
      beep();
      }
   }

void mod_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void mod_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[MOD_OBJ].label,fg,bg);
   coverlay(r,c,objs[MOD_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"%");
   }

WORD mod_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void and_init(nodeptr)
   struct logic_element *nodeptr;
   {
   math_node(nodeptr,"AND: dest = (1) & (2)",AND,ANDB,TRUE);
   }

void and_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void and_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[AND_OBJ].label,fg,bg);
   coverlay(r,c,objs[AND_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"&");
   }

WORD and_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void or_init(nodeptr)
   struct logic_element *nodeptr;
   {
   math_node(nodeptr,"OR: dest = (1) | (2)",OR,ORB,TRUE);
   }

void or_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void or_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[OR_OBJ].label,fg,bg);
   coverlay(r,c,objs[OR_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"|");
   }

WORD or_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void xor_init(nodeptr)
   struct logic_element *nodeptr;
   {
   math_node(nodeptr,"XOR: dest = (1) ^ (2)",XOR,XORB,TRUE);
   }

void xor_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void xor_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[XOR_OBJ].label,fg,bg);
   coverlay(r,c,objs[XOR_OBJ].overlay,fg);
   math_draw(r,c,nodeptr,"^");
   }

WORD xor_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 4;
   return(compile_node(nodeptr,*len,buf));
   }

void not_init(nodeptr)
   struct logic_element *nodeptr;
   {
   BYTE str[12];
   BYTE type;
   DWORD reg;

   get_values("NOT Output","Output / Var ? ",NULL,NULL,str,NULL,NULL);
   if (parse_io_str(str,&type,&reg))
      {
      if ((type == VAR_TYPE) || (type == OUTPUT_TYPE))
         {
         nodeptr->opcode[0] = NOT;
         nodeptr->opcode[1] = reg;
         nodeptr->opflags[1] = type;
         }
      else
         beep();
      }
   }

void not_del(r,c,nodeptr)
   WORD r,c;
   struct logic_element *nodeptr;
   {
   erase_node_notes(r,c);
   clear_node(nodeptr);
   }

void not_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[NOT_OBJ].label,fg,bg);
   coverlay(r,c,objs[NOT_OBJ].overlay,fg);
   showregtype(r-TEXTHEIGHTSMALL,c+TEXTWIDTH,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   }

WORD not_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 2;
   return(compile_node(nodeptr,*len,buf));
   }

void neg_init(nodeptr)
   struct logic_element *nodeptr;
   {