plc2.c

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

   BYTE str[12];
   BYTE type;
   DWORD reg;

   get_values("NEG variable","Variable ? ",NULL,NULL,str,NULL,NULL);
   if (parse_io_str(str,&type,&reg))
      {
      if (type == VAR_TYPE)
         {
         nodeptr->opcode[0] = NEG;
         nodeptr->opcode[1] = reg;
         nodeptr->opflags[1] = type;
         }
      else
         beep();
      }
   }

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

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

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

void cmp_node(nodeptr, label, opcode, opcodeb, swapop, swapopb, swapobj)
   struct logic_element *nodeptr;
   BYTE *label, opcode, opcodeb, swapop, swapopb;
   WORD swapobj;
   {
   BYTE str1[12], str2[12];
   BYTE type1,type2;
   DWORD reg1,reg2;
   DWORD tempreg;

   get_values(label,
              "First op    ? ",
              "Second op   ? ",
              NULL,
              str1,
              str2,
              NULL);
   if ((parse_io_str(str1,&type1,&reg1))
          && (parse_io_str(str2,&type2,&reg2)))
      {
      if ((type1 == LABEL_TYPE) || (type2 == LABEL_TYPE))
         {
         beep();
         return;
         }
      if (type1 == BYTEVAL_TYPE)
         {
         if (type2 == BYTEVAL_TYPE)
            {
            return;
            beep();
            }
         tempreg = reg1;
         type1 = type2;
         reg1 = reg2;
         type2 = BYTEVAL_TYPE;
         reg2 = tempreg;
         opcode = swapop;
         opcodeb = swapopb;
         nodeptr->objindex = swapobj;
         }
      nodeptr->opcode[0] = (type2 == BYTEVAL_TYPE) ? opcodeb : opcode;
      nodeptr->opcode[1] = reg1;
      nodeptr->opcode[2] = reg2;
      nodeptr->opflags[1] = type1;
      nodeptr->opflags[2] = type2;
      }
   }

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

void equ_init(nodeptr)
   struct logic_element *nodeptr;
   {
   cmp_node(nodeptr, "EQU:  (1) == (2)", EQU, EQUB, EQU, EQUB, EQU_OBJ);
   }

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

void equ_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[EQU_OBJ].label,fg,bg);
   coverlay(r,c,objs[EQU_OBJ].overlay,fg);
   cmp_draw(r,c,nodeptr,"=");
   }

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

void neq_init(nodeptr)
   struct logic_element *nodeptr;
   {
   cmp_node(nodeptr, "NEQ:  (1) != (2)", NEQ, NEQB, NEQ, NEQB, NEQ_OBJ);
   }

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

void neq_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[NEQ_OBJ].label,fg,bg);
   coverlay(r,c,objs[NEQ_OBJ].overlay,fg);
   cmp_draw(r,c,nodeptr,"!=");
   }

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

void grt_init(nodeptr)
   struct logic_element *nodeptr;
   {
   cmp_node(nodeptr, "GRT:  (1) > (2)", GRT, GRTB, LES, LESB, LES_OBJ);
   }

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

void grt_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[GRT_OBJ].label,fg,bg);
   coverlay(r,c,objs[GRT_OBJ].overlay,fg);
   cmp_draw(r,c,nodeptr,">");
   }

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

void geq_init(nodeptr)
   struct logic_element *nodeptr;
   {
   cmp_node(nodeptr, "GEQ:  (1) >= (2)", GEQ, GEQB, LEQ, LEQB, LEQ_OBJ);
   }

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

void geq_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[GEQ_OBJ].label,fg,bg);
   coverlay(r,c,objs[GEQ_OBJ].overlay,fg);
   cmp_draw(r,c,nodeptr,">=");
   }

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

void les_init(nodeptr)
   struct logic_element *nodeptr;
   {
   cmp_node(nodeptr, "LES:  (1) < (2)", LES, LESB, GRT, GRTB, GRT_OBJ);
   }

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

void les_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[LES_OBJ].label,fg,bg);
   coverlay(r,c,objs[LES_OBJ].overlay,fg);
   cmp_draw(r,c,nodeptr,"<");
   }

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

void leq_init(nodeptr)
   struct logic_element *nodeptr;
   {
   cmp_node(nodeptr, "LEQ:  (1) <= (2)", LEQ, LEQB, GEQ, GEQB, GEQ_OBJ);
   }

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

void leq_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[LEQ_OBJ].label,fg,bg);
   coverlay(r,c,objs[LEQ_OBJ].overlay,fg);
   cmp_draw(r,c,nodeptr,"<=");
   }

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

void mov_init(nodeptr)
   struct logic_element *nodeptr;
   {
   BYTE str1[12], strdest[12];
   BYTE type1, typedest;
   DWORD reg1, regdest;

   get_values("MOV dest = Value",
              "Destination ? ",
              "Value       ? ",
              NULL,
              strdest,
              str1,
              NULL);
   if ((parse_io_str(str1,&type1,&reg1))
           && (parse_io_str(strdest,&typedest,&regdest)))
      {
      if ((typedest == VAR_TYPE)
             && ((type1 == VAR_TYPE) || (type1 == BYTEVAL_TYPE) || (type1 == WORDVAL_TYPE) || (type1 == DWORDVAL_TYPE)))
         {
         nodeptr->opcode[0] = (type1 == VAR_TYPE) ? MOV : MOVD;
         nodeptr->opcode[1] = regdest;
         nodeptr->opflags[1] = typedest;
         *(DWORD *)&nodeptr->opcode[2] = 0;  /* clear all bytes */
         if (type1 == VAR_TYPE)
            {
            nodeptr->opflags[2] = VAR_TYPE;
            nodeptr->opcode[2] = reg1 & 0xff;
            }
         else
            {
            nodeptr->opflags[2] = DWORDVAL_TYPE;  /* this always wants to be a DWORD */
            *(DWORD *)&nodeptr->opcode[2] = reg1;
            }
         }
      else
         beep();
      }
   }

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

void mov_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   cstrout(r,c,objs[MOV_OBJ].label,fg,bg);
   coverlay(r,c,objs[MOV_OBJ].overlay,fg);
   showregtype(r-TEXTHEIGHTSMALL,c,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   smallstrout(r+TEXTHEIGHT,c,"=");
   showregtype(r+TEXTHEIGHT,c+2*TEXTWIDTH,nodeptr->opflags[2],*(DWORD *)&nodeptr->opcode[2]);
   }

WORD mov_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   *len = 3;  /* MOV is 3 bytes:  MOV <DEST> <R> */
   if (nodeptr->opcode[0] == MOV)
      return(compile_node(nodeptr,*len,buf));
   *len = 6;  /* MOVD is 6 bytes:  MOV <DEST> <DWORDVAL> */
   return(compile_endian_node(nodeptr,2,buf,4));
   }

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

   get_values("JMP label","Label number ? ",NULL,NULL,str,NULL,NULL);
   if (parse_io_str(str,&type,&reg))
      {
      if (type == LABEL_TYPE)
         {
         nodeptr->opcode[0] = JMP;
         nodeptr->opcode[1] = reg;
         nodeptr->opflags[1] = type;
         }
      else
         beep();
      }
   }

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

void jmp_draw(r,c,nodeptr,fg,bg)
   WORD r,c;
   struct logic_element *nodeptr;
   WORD fg,bg;
   {
   BYTE abuf[12];

   cstrout(r,c,objs[JMP_OBJ].label,fg,bg);
   coverlay(r,c,objs[JMP_OBJ].overlay,fg);
   showregtype(r-TEXTHEIGHTSMALL,c+2*TEXTWIDTH,nodeptr->opflags[1],(DWORD)nodeptr->opcode[1]);
   }

WORD jmp_comp(nodeptr,len,buf)
   struct logic_element *nodeptr;
   WORD *len;
   BYTE *buf;
   {
   if (nodeptr->opflags[1] == UNUSED_TYPE)  /* input type not known */
      return(COMPILE_UNKNOWN_PARAMS);
   buf[0] = nodeptr->opcode[0];
   if (is_littleendian)
      {
      buf[1] = label_addresses[nodeptr->opcode[1]] & 0xff;  /* little-endian */
      buf[2] = label_addresses[nodeptr->opcode[1]] >> 8;
      }
   else
      {
      buf[1] = label_addresses[nodeptr->opcode[1]] >> 8;  /* big-endian */
      buf[2] = label_addresses[nodeptr->opcode[1]] & 0xff;
      }
   *len = 3;
   return(COMPILE_OK);
   }

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

   get_values("ONESHOT","oneshot Register ? ",NULL,NULL,str,NULL,NULL);
   if (parse_io_str(str,&type,&reg))
      {
      if (type == ONESHOT_TYPE)
         {
         nodeptr->opcode[0] = OSR;
         nodeptr->opcode[1] = reg;
         nodeptr->opflags[1] = type;
         }
      else
         beep();
      }
   }

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

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

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

void ctt_init(nodeptr)
   struct logic_element *nodeptr;
   {
   BYTE strr[12], strlimit[12];
   BYTE typer, typelimit;
   DWORD regr, reglimit;

   get_values("Counter FALSE->TRUE",
              "Counter register ? ",
              "Preset limit     ? ",
              NULL,
              strr,
              strlimit,
              NULL);
   if ((parse_io_str(strr,&typer,&regr))
           && (parse_io_str(strlimit,&typelimit,&reglimit)))
      {
      if (((typelimit == WORDVAL_TYPE) || (typelimit == BYTEVAL_TYPE))
                      && (typer == COUNTER_TYPE))
         {
         nodeptr->opcode[0] = CTT;
         nodeptr->opcode[1] = regr;
         nodeptr->opflags[1] = typer;
         nodeptr->opcode[2] = reglimit & 0xff;
         nodeptr->opflags[2] = WORDVAL_TYPE;  /* this always wants to be a WORD */
         nodeptr->opcode[3] = (reglimit >> 8);
         }
      else
         beep();
      }
   }