2 Klassen miteinander verbinden

Steven19 · 31. Januar 2011

Guten Tag,

Ich habe zwei C Programme:
Einmal SMCMOT.C das ist meine Fachklasse und SMCMAIN.C das ist man Programm zum ausführen.

Das ganze ist von eine Schrittmotorenkarte und ich habe die zwei C Files vom Hersteller bekommen.

Jetzt muss ich nur noch die zwei Files miteinander verbinden.
Aber da ich in C so gut wie keine Ahnung habe bekomme ich das einfach nicht hin.
Zum die C Files zu öffnen benutze ich Dev c++.

Kann mir jemand sagen wie das geht oder das vielleicht machen.
Ich habe die 2 C Files im Anhang angehängt.

Danke!

ComFreek · 31. Januar 2011

Wieso willst denn du die verbinden?

Ich habe sie mir mal angeschaut, beide Dateien haben einen eigenen Einstiegspunkt (void main()).

Steven19 · 31. Januar 2011

Wie meinst du das?

Das SMCMAIN.C sollte ja die Werte an SMCMOT.C übergeben.
Sonst funktioniert das ganze nicht.

Steven19 · 31. Januar 2011

Sorry hab grad noch mal meinen Anhang angeschaut.
Hab die zwei falschen angehängt.

Das sind die richtigen...

ComFreek · 31. Januar 2011

Einfach das #include SMCMOT.C durch den Inhalt dieser Datei ersetzen.
So alles zusammengefügt:

C++:

/****************************************************************************/
/*								            */
/*  Funktion:  Beispiel zur Ansteuerung der Schrittmotorsteuerkarte SMC800  */
/*									    */
/****************************************************************************/


/**********************************************************************/
/*								      */
/*  Programm:    SMCMOT.C					      */
/*  Version :    2.1                                                  */
/*  Funktion:    Ansteuerung der Schrittmotorsteuerkarte SMC800       */
/*               mit Angabe der Ausgabefrequenz in Schritte/sec       */
/*  Datum:       20.08.1996					      */
/*  Letzte Žnd.: 06.05.1997                                           */
/*								      */
/**********************************************************************/


#include "dos.h"


/*-----Funktionsdeklaration-------------------------------------------*/

void Init_Timer(void);
unsigned int Get_Timer(void);
void Wait_Time(long zeit);
void Mout(unsigned char Next_Value);
void Delay(int SAkku);
void Vecout(int xStep,int yStep,int zStep);
void Referenz(int xR_Step,int yR_Step,int zR_Step);
void Tastatur(unsigned char F_Mode);
void Pen_down(void);
void Pen_up(void);


/*-----Globale Variable-----------------------------------------------*/

unsigned int _LPT;

long V_Startfreq;
long V_Arbeitsfreq, R_Arbeitsfreq;
long Beschleunigung, Bremsen;

unsigned char MptrX=0, MptrY=0, MptrZ=0;
unsigned char P_Mode=0, Reffahrt=0, Tastfahrt=0;
unsigned char Pen_aktl=0, Pen_akth=0;

long T_Arbeitsfreq=500;
long starttimer, stoptimer;
unsigned char BrAktiv=0;
double Startfreq=1.0, Bremsfreq;
double StartRampe, BremsRampe;
double aenderdiff=0.0;
long MerkAkku;
long Pitfaktor;


void Init_Timer(void)        /* Interrupt-Timer initialisieren */
{
  #define MODEMASK 0xE

  unsigned int pitstart, pitstop;
  long pitdiff;
  unsigned char mode;

  outp(0x43, 0xE2);
  mode = ((inp(0x40) & MODEMASK) >> 1);

  if (mode == 3)
  {
    Pitfaktor = 2;
  }
  else if (mode == 2)
  {
    Pitfaktor = 1;
  }
  else 				// Zeitabsch„tzung --> fr PC XT gedacht }
  {                             // da beim PC XT Status nicht existiert  }
    pitstart = Get_Timer();
    delay(14);
    pitstop = Get_Timer();

    if (pitstart < pitstop)
    {
      pitdiff = pitstart+(65535-pitstop);
    }
    else
    {
      pitdiff = pitstart-pitstop;
    }

    pitdiff = (pitdiff / 100) * 100;

    if (pitdiff > 30000)
    {
      Pitfaktor = 2;
    }
    else
    {
      Pitfaktor = 1;
    }
  }

  return;
}


unsigned int Get_Timer(void) /* Interrupt-Timer auslesen */
{
  unsigned int cnt_lo, cnt_hi;


  outp(0x43, 0);             /* Timer 0 */

  cnt_lo = inp(0x40);
  cnt_hi = inp(0x40);

  return (cnt_hi * 256 + cnt_lo);
}


void Wait_Time(long pitzeit)   /* Zeiteinheit 0.838 æs */
{
  long start, stop;
  long diff, merkdiff;
  long merkstop;
  long zeit;
  unsigned char durchlauf;


  zeit = pitzeit * Pitfaktor;
  durchlauf = 0;
  diff      = 0;
  merkdiff  = 0;
  merkstop  = 99999999;

  start = Get_Timer();
  stop  = Get_Timer();

  if (start < stop)
  {
    diff = start+(65535-stop);
    merkdiff = diff;
    diff = 0;
    start= stop;
  }
  else
  {
    diff = start-stop;
  }

  while ((diff + merkdiff) < zeit)
  {
    stop = Get_Timer();

    if (stop > merkstop)
      durchlauf = 1;

    if ((start < stop)||(durchlauf==1))
    {
      diff = start+(65535-stop);
      merkdiff = merkdiff + diff;
      diff = 0;
      durchlauf = 0;
      start= stop;
    }
    else
    {
      diff = start-stop;
    }

    merkstop = stop;
  }

  return;
}


void Mout(unsigned char Out_Val)       /* Portausgabe */
{
  extern unsigned int _LPT;
	 unsigned int _STB;


 _STB = _LPT + 2;
 outp(_LPT, Out_Val);

 Wait_Time(119);             /* Impulsbreite = 100 æs */

 outp(_STB, 1);
 outp(_STB, 0);

 return;
}


void Mdelay(int SAkku)       /* Verz”gerung bei Portausgabe */
{
  extern unsigned char BrAktiv;
  extern unsigned char Reffahrt;
  extern unsigned char Tastfahrt;
  extern double StartRampe, BremsRampe;
  extern double Startfreq, Bremsfreq;
  extern double aenderdiff;
  extern long R_Arbeitsfreq, T_Arbeitsfreq;
  extern long V_Arbeitsfreq, Beschleunigung;
  extern long MerkAkku;

  double Zeitbasis=0.000000838;        /* 0.838 æs */

  double wartezeit, aenderzeit;
  double diff, merkdiff;
  double merkstop, help;
  long   merklong;
  double merkreal;
  unsigned char durchlauf;


  if ((Reffahrt == 0)&&(Tastfahrt == 0))
  {
    if ((BrAktiv==0)&&(SAkku <= BremsRampe))
    {
      if (MerkAkku < StartRampe + BremsRampe)
      {
	if (SAkku > 0)
	{
	  Bremsfreq = ((Startfreq*Startfreq) / (2.0 * SAkku));
	  if (Bremsfreq <= 0.0)
	    Bremsfreq = 1.0;
	}
      }

      aenderdiff = 0.0;
      BrAktiv = 1;
    }
  }

  if (Reffahrt == 1)
  {
    help = R_Arbeitsfreq;
  }
  else
  {
    if (Tastfahrt == 1)
    {
      help = T_Arbeitsfreq;
    }
    else
    {
      help = Startfreq;
    }
  }

  if (help <= 0.0)
    help = 1.0;

  wartezeit = ((1.0 / help) / Zeitbasis);
  wartezeit = wartezeit * Pitfaktor;

  durchlauf = 0;
  diff      = 0.0;
  merkdiff  = 0.0;
  merkstop  = 99999999.0;

  stoptimer = Get_Timer();

  if (starttimer < stoptimer)
  {
    diff = starttimer+(65535-stoptimer);
    merkdiff = diff;
    diff = 0.0;
    starttimer= stoptimer;
  }
  else
  {
    diff = starttimer-stoptimer;
  }

  while ((diff + merkdiff) < wartezeit)
  {
    stoptimer = Get_Timer();

    if (stoptimer > merkstop)
      durchlauf = 1;

    if ((starttimer < stoptimer)||(durchlauf == 1))
    {
      diff = starttimer+(65535-stoptimer);
      merkdiff = merkdiff + diff;
      diff = 0.0;
      durchlauf = 0;
      starttimer= stoptimer;
    }
    else
    {
      diff = starttimer-stoptimer;
    }

    merkstop = stoptimer;
  }

  starttimer = stoptimer;

  if ((Reffahrt == 0)&&(Tastfahrt == 0))
  {
    if (BrAktiv == 1)
    {
      if (Startfreq > 0.0)
      {
	aenderzeit = ((1.0 / Bremsfreq) / Zeitbasis);
	aenderzeit = aenderzeit * Pitfaktor;
	if ((diff + merkdiff + aenderdiff) >= aenderzeit)
	{
	  if (aenderzeit == 0.0)
	    aenderzeit = 1.0;
	  merkstop  = ((diff + merkdiff + aenderdiff) / aenderzeit);
	  merklong  = (long) merkstop;
	  merkreal  = (double) merklong;
	  aenderdiff= merkstop-merkreal;
	  aenderdiff= aenderdiff * aenderzeit;
	  merkstop  = merkreal;
	  Startfreq = Startfreq - merkstop;
	}
	else
	{
	  aenderdiff = (aenderdiff + diff + merkdiff);
	}

	if (SAkku > 0)
	{
	  Bremsfreq = ((Startfreq*Startfreq) / (2.0 * SAkku));
	  if (Bremsfreq <= 0.0)
	    Bremsfreq = 1.0;
	}
      }
      else
      {
	Startfreq = Startfreq + merkstop;
      }
    }
    else
    {
      if (Startfreq < V_Arbeitsfreq)
      {
	aenderzeit = ((1.0 / Beschleunigung) / Zeitbasis);
	aenderzeit = aenderzeit * Pitfaktor;
	if ((diff + merkdiff + aenderdiff) >= aenderzeit)
	{
	  if (aenderzeit == 0.0)
	    aenderzeit = 1.0;
	  merkstop  = ((diff + merkdiff + aenderdiff) / aenderzeit);
	  merklong  = (long) merkstop;
	  merkreal  = (double) merklong;
	  aenderdiff= merkstop-merkreal;
	  aenderdiff= aenderdiff * aenderzeit;
	  merkstop  = merkreal;
	  Startfreq = Startfreq + merkstop;
	}
	else
	{
	  aenderdiff = (aenderdiff + diff + merkdiff);
	}
      }
    }
  }

  return;
}


void Pen_down(void)
{
  unsigned char Next_Value;


  Next_Value = 0x87;
  Mout(Next_Value);
  Wait_Time(196897);         /* Zeit:  196897 = 165 msec. */

  return;
}


void Pen_up(void)
{
  unsigned char Next_Value;


  Next_Value = 0x9B;
  Mout(Next_Value);
  Wait_Time(196897);         /* Zeit:  196897 = 165 msec. */

  return;
}


void Vecout(int xStep, int yStep, int zStep)
{
  extern long V_Startfreq, V_Arbeitsfreq;
  extern long Beschleunigung, Bremsen;
  extern double Startfreq, Bremsfreq;
  extern double StartRampe, BremsRampe;
  extern unsigned char BrAktiv, Reffahrt;
  extern long MerkAkku, starttimer;
  extern unsigned char MptrX, MptrY, MptrZ;
  extern unsigned char Pen_aktl, Pen_akth, P_Mode;

/*-----Konstante-------------------------------------------------------*/

const unsigned char MOTTAB[8]  = {0x27, 0x2D, 0x1C, 0x0D, 0x03, 0x09, 0x38, 0x29};
const unsigned char STANDBY[8] = {0x37, 0x36, 0x1E, 0x16, 0x13, 0x12, 0x3A, 0x32};   /* 20% vom Maximalstrom */
/*const unsigned char STANDBY[8] = {0x2F, 0x2D, 0x1D, 0x0D, 0x0B, 0x09, 0x39, 0x29}; */ /* 50% vom Maximalstrom */

union          REGS Register;

unsigned int   x, y, z, SKan, L1Kan, L2Kan, SAkku, L1Akku, L2Akku;
unsigned char  Next_Value, VorX, VorY, VorZ;
unsigned char  SMode, L1Mode, L2Mode, Pen;
int	       T_Zeichen, Flag;


  if ((zStep == -32000) || (zStep == 32000))
  {
    P_Mode = 1;
  }
  else
  {
    P_Mode = 0;
  }

  Pen = 3;

  if (xStep < 0)
  {
    VorX = 1;
    x = (~xStep) + 1;
  }
  else
  {
    VorX = 0;
    x = xStep;
  }

  if (yStep < 0)
  {
    VorY = 2;
    y = (~yStep) + 1;
  }
  else
  {
    VorY = 1;
    y = yStep;
  }

  if (zStep < 0)
  {
    if ((zStep == -32000) && (Reffahrt == 0))
    {
      Pen_up();
      Pen = 0;
      z = 0;
    }

    if (Reffahrt == 1)
    {
      if ((Pen_aktl == 0) && (zStep  == -32000))
      {
        Pen_up();
        Pen = 0;
        Pen_aktl = 1;
        z = 0;
      }
    }

    if ((zStep > -32000) && (zStep < 0))
    {
      VorZ = 3;
      z = (~zStep) + 1;
    }

    if (zStep == -32000)
      z = 0;
  }
  else
  {
    if ((zStep == 32000) && (Reffahrt == 0))
    {
      Pen_down();
      Pen = 1;
      z = 0;
    }

    if (Reffahrt == 1)
    {
      if ((Pen_akth == 0) && (zStep == 32000))
      {
        Pen_down();
        Pen = 0;
        Pen_akth = 1;
        z = 0;
      }
    }

    if (zStep == 32222)
    {
      Pen = 2;
      z = 0;
    }

    if ((zStep < 32000) && (zStep >= 0))
    {
      VorZ = 2;
      z = zStep;
    }

    if (zStep == 32000)
      z = 0;
  }

  if (x >= y)
  {
    if (x >= z)
    {
      SKan  = x;
      SAkku = x;
      L1Kan = y;
      L1Akku= y;
      L2Kan = z;
      L2Akku= z;
      SMode = (1 + VorX);
      L1Mode= (2 + VorY);
      L2Mode= (3 + VorZ);
    }
    else
    {
      SKan  = z;
      SAkku = z;
      L1Kan = x;
      L1Akku= x;
      L2Kan = y;
      L2Akku= y;
      SMode = (3 + VorZ);
      L1Mode= (1 + VorX);
      L2Mode= (2 + VorY);
    }
  }
  else
  {
    if (y >= z)
    {
      SKan  = y;
      SAkku = y;
      L1Kan = x;
      L1Akku= x;
      L2Kan = z;
      L2Akku= z;
      SMode = (2 + VorY);
      L1Mode= (1 + VorX);
      L2Mode= (3 + VorZ);
    }
    else
    {
      SKan  = z;
      SAkku = z;
      L1Kan = x;
      L1Akku= x;
      L2Kan = y;
      L2Akku= y;
      SMode = (3 + VorZ);
      L1Mode= (1 + VorX);
      L2Mode= (2 + VorY);
    }
  }

  if (SAkku > 0 && SAkku < 32000)
  {
    T_Zeichen = 0;
    BrAktiv = 0;

    if (V_Startfreq < 1)
      V_Startfreq = 1;
    if (V_Startfreq > 5000)
      V_Startfreq = 5000;

    if (V_Arbeitsfreq < 1)
      V_Arbeitsfreq = 1;
    if (V_Arbeitsfreq > 5000)
      V_Arbeitsfreq = 5000;

    if (Beschleunigung < 1)
      Beschleunigung = 1;
    if (Beschleunigung > 5000)
      Beschleunigung = 5000;

    if (Bremsen < 1)
      Bremsen = 1;
    if (Bremsen > 5000)
      Bremsen = 5000;

    Startfreq  = V_Startfreq;
    Bremsfreq  = Bremsen;
    StartRampe = (Beschleunigung / 2.0) * ((V_Arbeitsfreq / Beschleunigung)*(V_Arbeitsfreq / Beschleunigung));
    BremsRampe = (V_Arbeitsfreq*V_Arbeitsfreq) / (2.0 * Bremsen);

    MerkAkku = SAkku;

    if ((SAkku < StartRampe+BremsRampe)&&((SAkku / 2) < BremsRampe))
      BremsRampe = SAkku - BremsRampe;

    if (SAkku < StartRampe)
      BremsRampe = (SAkku / 2);


    starttimer = Get_Timer();     /* Zeitz„hler starten */


    while ((SAkku > 0) && (T_Zeichen != 27))
    {
      Register.h.ah = 1;
      int86(0x16, &Register, &Register);
      Flag = Register.x.cflag;
      if (Flag == 1)
      {
        T_Zeichen = Register.h.al;
      }

      switch (SMode)
      {
        case 1: { ++MptrX;
		  if (MptrX > 7)
		    MptrX = 0;
		  Next_Value = MOTTAB[MptrX];
		  Mout(Next_Value);
		}
	        break;
        case 2: { --MptrX;
		  if (MptrX > 7)
		    MptrX = 7;
		  Next_Value = MOTTAB[MptrX];
		  Mout(Next_Value);
	        }
	        break;
        case 3: { ++MptrY;
		  if (MptrY > 7)
     		    MptrY = 0;
		  Next_Value = MOTTAB[MptrY] + 64;
		  Mout(Next_Value);
 	        }
	        break;
        case 4: { --MptrY;
		  if (MptrY > 7)
		    MptrY = 7;
		  Next_Value = MOTTAB[MptrY] + 64;
		  Mout(Next_Value);
	        }
	        break;
        case 5: { ++MptrZ;
		  if (MptrZ > 7)
		    MptrZ = 0;
		  Next_Value = MOTTAB[MptrZ] + 128;
		  Mout(Next_Value);
	        }
	        break;
        case 6: { --MptrZ;
		  if (MptrZ > 7)
		    MptrZ = 7;
		  Next_Value = MOTTAB[MptrZ] + 128;
		  Mout(Next_Value);
	        }
	        break;
      }

      --SAkku;
      L1Akku += L1Kan;
      L2Akku += L2Kan;

      if (L1Akku >= SKan)
      {
        L1Akku -= SKan;

        switch (L1Mode)
	{
	  case 1: { ++MptrX;
		    if (MptrX > 7)
		      MptrX = 0;
		    Next_Value = MOTTAB[MptrX];
		    Mout(Next_Value);
		  }
		  break;
	  case 2: { --MptrX;
		    if (MptrX > 7)
		      MptrX = 7;
		    Next_Value = MOTTAB[MptrX];
		    Mout(Next_Value);
		  }
		  break;
	  case 3: { ++MptrY;
		    if (MptrY > 7)
		      MptrY = 0;
		    Next_Value = MOTTAB[MptrY] + 64;
		    Mout(Next_Value);
		  }
		  break;
	  case 4: { --MptrY;
		    if (MptrY > 7)
		      MptrY = 7;
		    Next_Value = MOTTAB[MptrY] + 64;
		    Mout(Next_Value);
		  }
		  break;
	  case 5: { ++MptrZ;
		    if (MptrZ > 7)
		      MptrZ = 0;
		    Next_Value = MOTTAB[MptrZ] + 128;
		    Mout(Next_Value);
		  }
		  break;
	  case 6: { --MptrZ;
		    if (MptrZ > 7)
		      MptrZ = 7;
		    Next_Value = MOTTAB[MptrZ] + 128;
		    Mout(Next_Value);
		  }
		  break;
        }
      }

      if (L2Akku >= SKan)
      {
	L2Akku -= SKan;

	switch (L2Mode)
	{
	  case 1: { ++MptrX;
		    if (MptrX > 7)
		      MptrX = 0;
		    Next_Value = MOTTAB[MptrX];
		    Mout(Next_Value);
		  }
		  break;
	  case 2: { --MptrX;
		    if (MptrX > 7)
		      MptrX = 7;
		    Next_Value = MOTTAB[MptrX];
		    Mout(Next_Value);
		  }
		  break;
	  case 3: { ++MptrY;
		    if (MptrY > 7)
		      MptrY = 0;
		    Next_Value = MOTTAB[MptrY] + 64;
		    Mout(Next_Value);
		  }
		  break;
	  case 4: { --MptrY;
		    if (MptrY > 7)
		      MptrY = 7;
		    Next_Value = MOTTAB[MptrY] + 64;
		    Mout(Next_Value);
		  }
		  break;
	  case 5: { ++MptrZ;
		    if (MptrZ > 7)
		      MptrZ = 0;
		    Next_Value = MOTTAB[MptrZ] + 128;
		    Mout(Next_Value);
		  }
		  break;
	  case 6: { --MptrZ;
		    if (MptrZ > 7)
		      MptrZ = 7;
		    Next_Value = MOTTAB[MptrZ] + 128;
		    Mout(Next_Value);
		  }
		  break;
	}
      }

      Mdelay(SAkku);
    }
  }

  Next_Value = STANDBY[MptrX];
  Mout(Next_Value);
  Next_Value = STANDBY[MptrY] + 64;
  Mout(Next_Value);

  if ((Pen > 2) && (P_Mode != 1))
  {
    Next_Value = STANDBY[MptrZ] + 128;
    Mout(Next_Value);
  }

  return;
}


void Referenz(int xR_Step, int yR_Step, int zR_Step)
{
  extern unsigned int _LPT;
  extern unsigned char Reffahrt;

  union REGS Register;

  int xStep, yStep, zStep, i, T_Zeichen, Ref_sw;
  unsigned char Pen;
  unsigned int _LPTSTATUS, Flag;


  Ref_sw = 1;
  Reffahrt = 1;
  xStep = xR_Step;
  yStep = yR_Step;
  zStep = zR_Step;
  _LPTSTATUS = _LPT +1;
  Ref_sw = inp(_LPTSTATUS);
  Ref_sw = Ref_sw & 0x80;
  if (Ref_sw == 0)
    Vecout(xStep, yStep, zStep);

  Pen = 3;

  if (zStep == -32000)
  {
    Pen_up();
    Pen = 0;
  }

  if (zStep == 32000)
  {
    Pen_down();
    Pen = 1;
  }

  if (xR_Step != 0)
  {
    i = 0;
    xStep = -1;
    yStep = 0;

    if (Pen > 2)
      zStep = 0;
    else
     zStep = zR_Step;

    T_Zeichen = 0;

    while ((((Ref_sw=(inp(_LPTSTATUS) & 0x80)) != 0) && i < 32000) && (T_Zeichen != 27))
    {
      Register.h.ah = 1;
      int86(0x16, &Register, &Register);
      Flag = Register.x.cflag;
      if (Flag == 1)
      {
        T_Zeichen = Register.h.al;
       }

      Vecout(xStep, yStep, zStep);
      ++i;
    }

    xStep = xR_Step;
    Vecout(xStep, yStep, zStep);
    Wait_Time(656324);       /* Zeit:  656324 = 550 msec. */
  }

  if (yR_Step != 0)
  {
    i = 0;
    xStep = 0;
    yStep = -1;

    T_Zeichen = 0;

    while ((((Ref_sw = (inp(_LPTSTATUS) & 0x80)) != 0) && i < 32000) && (T_Zeichen != 27))
    {
      Register.h.ah = 1;
      int86(0x16, &Register, &Register);
      Flag = Register.x.cflag;
      if (Flag == 1)
      {
        T_Zeichen = Register.h.al;
      }

      Vecout(xStep, yStep, zStep);
      ++i;
    }

    yStep = yR_Step;
    Vecout(xStep, yStep, zStep);
    Wait_Time(656324);        /* Zeit:  656324 = 550 msec. */
  }

  if (zR_Step != 0)
  {
    if ((zR_Step < 32000) && (zR_Step > -32000))
    {
      i = 0;
      yStep = 0;
      zStep = -1;

      T_Zeichen = 0;

      while ((((Ref_sw = (inp(_LPTSTATUS) & 0x80)) != 0) && i < 32000) && (T_Zeichen != 27))
      {
        Register.h.ah = 1;
        int86(0x16, &Register, &Register);
        Flag = Register.x.cflag;
        if (Flag == 1)
	{
	  T_Zeichen = Register.h.al;
	}

       Vecout(xStep, yStep, zStep);
       ++i;
      }

      zStep = zR_Step;
      Vecout(xStep, yStep, zStep);
      Wait_Time(656324);     /* Zeit:  656324 = 550 msec. */
    }
  }

  Reffahrt = 0;

  return;
}


void Tastatur(unsigned char F_Mode)
{
  #define E_Steps   30
  #define Ref_Steps  4
  #define M_Steps    8

  extern long T_Arbeitsfreq;
  extern unsigned char Tastfahrt;

  union REGS Register;

  int Modus, Zeichen, old_Zeichen, counter;
  int xStep, yStep, zStep;


  if (T_Arbeitsfreq < 1)
    T_Arbeitsfreq = 1;
  if (T_Arbeitsfreq > 5000)
    T_Arbeitsfreq = 5000;

  Zeichen = 0;
  counter = 0;
  Tastfahrt = 1;

  while (Zeichen != 27)
  {
    old_Zeichen = Zeichen;
    Register.h.ah = 0;
    int86(0x16, &Register, &Register);
    Modus = Register.h.al;

    if (Modus == 0)
      Zeichen = Register.h.ah;
    else
      Zeichen = Register.h.al;

    if (Zeichen == old_Zeichen)
      ++counter;
    else
      counter = 0;

    switch (Zeichen)
    {
      case 72: { xStep = 0;
		 if (counter < E_Steps)
		   yStep = Ref_Steps;
		 else
		 {
		   yStep = M_Steps;
		   counter = E_Steps;
		 }

		 if (F_Mode == 1)
		   zStep = 32222;
		 else
		   zStep = 0;

		 Vecout(xStep, yStep, zStep);
               }
               break;
      case 73: { if (F_Mode == 1)
		   Pen_up();
	         else
	         {
		   xStep = 0;
		   yStep = 0;

		   if (counter < E_Steps)
		     zStep = Ref_Steps;
		   else
		   {
		     zStep = M_Steps;
		     counter = E_Steps;
		   }

		   Vecout(xStep, yStep, zStep);
	         }
               }
               break;
      case 75: { yStep = 0;
                 if (counter < E_Steps)
		   xStep = -Ref_Steps;
	         else
		 {
		   xStep = -M_Steps;
		   counter = E_Steps;
		 }

 	         if (F_Mode == 1)
		   zStep = 32222;
	         else
	   	   zStep = 0;

	         Vecout(xStep, yStep, zStep);
               }
               break;
      case 77: { yStep = 0;
                 if (counter < E_Steps)
   		   xStep = Ref_Steps;
	         else
		 {
		   xStep = M_Steps;
		   counter = E_Steps;
		 }

	         if (F_Mode == 1)
		   zStep = 32222;
	         else
		   zStep = 0;

	         Vecout(xStep, yStep, zStep);
               }
               break;
      case 80: { xStep = 0;
	         if (counter < E_Steps)
		   yStep = -Ref_Steps;
	         else
		 {
		   yStep = -M_Steps;
		   counter = E_Steps;
		 }

	         if (F_Mode == 1)
               	   zStep = 32222;
	         else
		   zStep = 0;

	         Vecout(xStep, yStep, zStep);
               }
	       break;
      case 81: { if (F_Mode == 1)
		   Pen_down();
	         else
	         {
		   xStep = 0;
		   yStep = 0;

		   if (counter < E_Steps)
		     zStep = -Ref_Steps;
		   else
		   {
		     zStep = -M_Steps;
		     counter = E_Steps;
		   }

		   Vecout(xStep, yStep, zStep);
	         }
               }
               break;
    }
  }

  Tastfahrt = 0;

  return;
}



void Plotter();
void XYZ_System();


/*****  Hauptprogramm  *****/

void main()
{

  _LPT = 0x378;			       /* Adresse der parallelen Schnittstelle   */
                                       /* muá bei Programmstart definiert werden */
				       /* LPT1: 0x378         */
                                       /* LPT2: 0x278 	      */
				       /* MDA - Karte:  0x3BC */


  /*******************************************************************/
  /*                                                                 */
  /*   Mit diesen Werten wird die Geschwindigkeit in Schritte/sec.   */
  /*   angegeben  ( Ausgabefrequenz zur Ansteuerung der Motoren )    */
  /*                                                                 */
  /*******************************************************************/

  V_Startfreq    = 200;         /* Startfrequenz Vektorausgabe       */
  V_Arbeitsfreq  = 1000;        /* Arbeitsfrequenz Vektorausgabe     */
  R_Arbeitsfreq  = 2000;        /* Arbeitsfrequenz Referenzfahrt     */
  Beschleunigung = 300;         /* Beschleunigung Vektorausgabe      */
  Bremsen        = 500;         /* Bremsen Vektorausgabe             */
                                /* die Werte fr Beschleunigung und  */
                                /* Bremsen gelten nur fr die Vektor-*/
                                /* ausgabe, bei der Referenzfahrt    */
                                /* und Tastatursteuerung werden      */
                                /* diese Werte nicht bercksichtigt  */

  /*******************************************************************/




  Init_Timer();                 /* Interrupt-Timer initialisieren   */
				/* muá bei Programmstart gemacht    */
				/* werden, damit Beschleunigung und */
				/* Bremsen berechnet werden k”nnen  */




  /* An dieser Stelle k”nnen Sie festlegen ob ein Plotter            */
  /* oder ein 3-Achsen-System demonstriert werden soll !             */
  /*                                                                 */
  /* Geben Sie folgende Syntax ein:                                  */
  /*                                                                 */
  /*           < Plotter() >     fr Plotter - Demo                  */
  /*           < XYZ_System() >  fr 3-Achsen-System - Demo          */
  /*                                                                 */
  /*                                                                 */
  /* Die Syntax zur Vektorausgabe finden Sie in der jeweil. Funktion */
  /*                                                                 */
  /* Wollen Sie also die Funktion eines Plotters demonstriert haben, */
  /* geben Sie folgende Syntax ein:		                     */



  Plotter();





  /* Dieser Aufruf ist bei einem 3-Achsen-System durch < XYZ_System() > zu ersetzen */



  /* XYZ_System(); */
}


void Plotter()
{
  int xStep, yStep, zStep;
  unsigned char F_Mode;



  printf("SMC800 / SMC1500   -   Plotter-Demo\n");
  printf("-----------------------------------\n");
  printf("Tastatur: Steuerung mit Pfeiltasten\n");
  printf("          Beenden mit <ESC>\n");



  F_Mode = 1;			        /* F_Mode = 0:  3-Achsen-System */
				        /* F_Mode = 1:  Plotter         */
  Tastatur(F_Mode);		        /* Manuelle Positionierung mit PC-Tastatur */
				        /* Abruch mit ESC                          */


  printf("Referenzfahrt:  Schalter drcken\n");



  /* Verschiedene M”glichkeiten der Initialisierung beim Aufruf zur Referenzfahrt */

  xStep = 250;				/* Schritte, die der X-Motor bei der Referenzfahrt */
					/* aus dem Schalter fahren soll			   */
  yStep = 250;				/* Schritte, die der Y-Motor bei der Referenzfahrt */
					/* aus dem Schalter fahren soll 		   */
  zStep = -32000;			/* -32000: Plotter-Modus, bei Referenzfahrt Pen up   */
					/*  32000: Plotter-Modus, bei Referenzfahrt Pen down */
  Referenz(xStep, yStep, zStep);	/* Referenzfahrt mit šbergabe der Schritte */


  xStep = 500;				/* Schritte, die der X-Motor bei der Referenzfahrt */
					/* aus dem Schalter fahren soll			   */
  yStep = 0;				/* Keine Referenzfahrt in Y-Richtung */

  zStep = -32000;			/* -32000: Pen up   */
					/*  32000: Pen down */
  Referenz(xStep, yStep, zStep);	/* Referenzfahrt mit šbergabe der Schritte */



  printf("Vektorausgabe:  Abbruch mit <ESC>\n");



  /* Positionierbeispiel */

  xStep = 8200;                         /* X - Positionierung    */
  yStep = 3400;                         /* Y - Positionierung    */
  zStep = -32000;                       /* bei angehobenen Stift */

  Vecout(xStep, yStep, zStep);          /* Ausgabe der Vektoren  */


  xStep = 5000;                         /* X - Positionierung    */
  yStep = -800;                         /* Y - Positionierung    */
  zStep = 32000;                        /* bei abgesenktem Stift */

  Vecout(xStep, yStep, zStep);          /* Ausgabe der Vektoren  */

  return;
}


void XYZ_System()
{
  int xStep, yStep, zStep;
  unsigned char F_Mode;



  printf("SMC800 / SMC1500   -   3-Achsen-Demo\n");
  printf("------------------------------------\n");
  printf("Tastatur:  Steuerung mit Pfeiltasten\n");
  printf("           Beenden mit <ESC>\n");



  F_Mode = 0;				/* F_Mode = 0:   3-Achsen-System */
					/* F_Mode = 1:   Plotter	 */
  Tastatur(F_Mode);			/* Manuelle Positionierung mit PC-Tastatur */
					/* Abbruch mit ESC                         */


  printf("Referenzfahrt:  Schalter drcken\n");



  /* Beispiel der Initialisierung beim Aufruf zur Referenzfahrt */

  xStep = 250;				/* Schritte, die der X-Motor bei der Referenzfahrt */
					/* aus dem Schalter fahren soll			   */
  yStep = 250;				/* Schritte, die der Y-Motor bei der Referenzfahrt */
					/* aus dem Schalter fahren soll 		   */
  zStep = 100;    			/* Schritte, die der Z-Motor bei der Referenzfahrt */
					/* aus dem Schalter fahren soll                    */
  Referenz(xStep, yStep, zStep);	/* Referenzfahrt mit šbergabe der Schritte */



  printf("Vektorausgabe:  Abbruch mit <ESC>\n");



  /* Positionierbeispiel */

  xStep = 4600;                         /* X - Positionierung   */
  yStep = 2300;                         /* Y - Positionierung   */
  zStep = 0;                            /* Z - Achse steht      */

  Vecout(xStep, yStep, zStep);          /* Ausgabe der Vektoren */


  xStep = 0;                            /* X - Achse steht      */
  yStep = 0;                            /* Y - Achse steht      */
  zStep = 800;                          /* Z - Achse nach unten (z.B. Bohrer) */

  Vecout(xStep, yStep, zStep);          /* Ausgabe der Vektoren */

  return;
}

Steven19 · 31. Januar 2011

Cool Dankeschön.

Hab das Programm mal in Dev c++ kopiert.
Beim Compilieren kommt jetzt noch ein Fehler:

void Vecout(int xStep, int yStep, int zStep)
{
extern long V_Startfreq, V_Arbeitsfreq;
extern long Beschleunigung, Bremsen;
extern double Startfreq, Bremsfreq;
extern double StartRampe, BremsRampe;
extern unsigned char BrAktiv, Reffahrt;
extern long MerkAkku, starttimer;
extern unsigned char MptrX, MptrY, MptrZ;
extern unsigned char Pen_aktl, Pen_akth, P_Mode;

/*-----Konstante-------------------------------------------------------*/

const unsigned char MOTTAB[8] = {0x27, 0x2D, 0x1C, 0x0D, 0x03, 0x09, 0x38, 0x29};
const unsigned char STANDBY[8] = {0x37, 0x36, 0x1E, 0x16, 0x13, 0x12, 0x3A, 0x32}; /* 20% vom Maximalstrom */
/*const unsigned char STANDBY[8] = {0x2F, 0x2D, 0x1D, 0x0D, 0x0B, 0x09, 0x39, 0x29}; */ /* 50% vom Maximalstrom */

union REGS Register; genau ihr kommt die Fehlermeldung

unsigned int x, y, z, SKan, L1Kan, L2Kan, SAkku, L1Akku, L2Akku;
unsigned char Next_Value, VorX, VorY, VorZ;
unsigned char SMode, L1Mode, L2Mode, Pen;
int T_Zeichen, Flag;

Was du zufällig was da noch fehlt?

ComFreek · 31. Januar 2011

Was denn für eine Fehlermeldung?
Ich denke mal der Bezeichner REGS wird nicht gefunden.

Übrigens ist der Dev-Cpp veraltet und sollte nicht mehr benutzt werden. Würde dir Code::Blocks empfehlen.

Steven19 · 31. Januar 2011

Okay ich hab mir Code::Blocks runtergeladen und installiert.
Ja stimmt sieht schon mal viel professioneller aus.

Hab das Programm jetzt rein kopiert.
Wenn ich jetzt auf Build gehe dann kommt schon bei:

#include "dos.h" ein rotes Kästchen. Also ein fehler.
fatatel error: dos.h: No such file or directory.

Hast du es mal versucht zu compilieren?
Kommen bei dir auch fehler?

ComFreek · 31. Januar 2011

Der Compiler will die Datei "dos.h" finden, findet Sie aber nicht.
Guck mal in den Ordner vom alten Projekt (mit Dev-Cpp), ob da irgendwo eine "dos.h" zu finden ist.

Ja ich habe es gerade mal versucht, einige Fehler tauchen auf. Aber vielleicht lösen sich ja die restlichen, wenn man eben die fehlende Datei einbindet.

Steven19 · 31. Januar 2011

Hey,

Ja hab die Headerdatei dos gefunden aber wie kann ich die jetzt bei Code::Blocks einbinden?

2 Klassen miteinander verbinden

Steven19

Mitglied

Anhänge

ComFreek

Mod | @comfreek

Steven19

Mitglied

Steven19

Mitglied

Anhänge

ComFreek

Mod | @comfreek

Steven19

Mitglied

ComFreek

Mod | @comfreek

Steven19

Mitglied

ComFreek

Mod | @comfreek

Steven19

Mitglied

Neue Beiträge