4. fehlermeldungen smc800

fehlermeldungen smc800

  • ?

    Hallo,

    dies ist das Programm das ich gekauft habe, habe allerdings nun einige Fehlermeldungen. Ich bin nicht gut im Programmieren, da ich es gerade erst lerne. Vielleicht kann mir jmd sagen, wie ich sie korrieren muss.
    Benutze das Programm Dev-C++
    Vielen Dank im Voraus
    [/*******/
    /* /
    /* Programm: SMCMOT.C /
    /* Funktion: Ansteuerung der Schrittmotorsteuerkarte SMC800 /
    /* mittels Start- und Enderampe /
    /* Datum: 05.06.1992 /
    /* Letzte Žnd.: 06.05.1997 /
    /* /
    /    /

    #include <dos.h>

    /-----Funktionsdeklaration-------------------------------------------/

    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 Pen_up();
    void delay_500();
    void delay_100();

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

    unsigned char MptrX, MptrY, MptrZ, Bremse, RampGen = 0, Steilheit;
    unsigned char P_Mode = 0, Reffahrt = 0, Pen_aktl = 0, Pen_akth = 0;
    unsigned int _LPT, Rampe_Ende;
    long Rampe_Start, Delay_Value;

    /-----Funktion: Ausgabe an die parallele Schnittstelle LPT1----------/

    void Mout( unsigned char Out_Val )

    {
    extern unsigned int _LPT;
    unsigned int _STB;

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

    return;
    }

    /-----Funktion: Verz”gert Programmablauf um ca. 500ms ---------------------/

    void delay_500()
    {

    long ticks, vgl;
    unsigned char n;

    n = 0;

    ticks = clock();
    vgl = ticks;
    while( ticks == vgl )
    ticks = clock();
    while( n < 10 )
    {
    ticks = clock();
    vgl = ticks;
    while( ticks == vgl )
    ticks = clock();
    ++n;
    }

    }

    /-----Funktion: Verz”gert Programmablauf um ca. 150ms ---------------------/

    void delay_100()
    {

    long ticks, vgl;
    unsigned char n;

    n = 0;

    ticks = clock();
    vgl = ticks;
    while( ticks == vgl )
    ticks = clock();
    while( n < 3 )
    {
    ticks = clock();
    vgl = ticks;
    while( ticks == vgl )
    ticks = clock();
    ++n;
    }

    }

    /-----Funktion: Verz”gerung, um Rechnergeschwindigkeit an Karte anzupassen-/

    void Delay(int SAkku)
    {

    extern unsigned char Bremse, RampGen;
    extern unsigned char Steilheit;
    extern unsigned int Rampe_Ende;
    extern long Rampe_Start, Delay_Value;
    long i, Rampe;

    if( Rampe_Start < 1 )
    Rampe_Start = 1;
    if( Rampe_Start > 32000 )
    Rampe_Start = 32000;
    if( Rampe_Ende < 1)
    Rampe_Ende = 1;
    if( Rampe_Ende > 10000 )
    Rampe_Ende = 10000;
    Rampe = Rampe_Start;
    if( Reffahrt == 1 )
    Rampe = Rampe_Start * 10;

    if( Rampe_Start > Rampe_Ende )
    {

    if( RampGen == 0 )
    {
    Delay_Value = Rampe;
    RampGen = 1;
    }

    Bremse = 0;

    if( Reffahrt == 1 )
    Delay_Value = Rampe_Start * 10;

    i = 0;
    while ( i < Delay_Value )
    ++i;

    if (SAkku < 50)
    Bremse = 1;

    if ((Delay_Value >= Rampe_Ende) && (!Bremse))
    Delay_Value -= Steilheit;

    if( (Delay_Value < Rampe) && (Bremse==1) )
    {
    Delay_Value += Steilheit;
    if( (Delay_Value >= Rampe_Start) || (SAkku == 1) )
    RampGen = 0;
    }
    }
    return;
    }

    /-----Funktion: Ausgabe des Vektors an die jeweilige Achse--------------/

    void Vecout( int xStep, int yStep, int zStep )
    {

    /-----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;
    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;
    }
    }
    Delay(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;
    }

    /-----Funktion: Referenzfahrt-----------------------------------------/

    void Referenz(int xR_Step, int yR_Step, int zR_Step)
    {

    union REGS Register;

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

    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);
    delay_500();
    RampGen = 0;
    }

    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);
    delay_500();
    RampGen = 0;
    }

    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);
    delay_500();
    }
    }
    RampGen = 0;
    Reffahrt = 0;
    return;
    }

    /-----Funktion: Tastaturbearbeitung bei manueller Betriebsart-----/

    void Tastatur(unsigned char F_Mode)
    {

    #define E_Steps 50
    #define Ref_Steps 2
    #define M_Steps 5

    union REGS Register;
    int Modus, Zeichen, old_Zeichen, counter;
    int xStep, yStep, zStep;

    Zeichen = 0;
    counter = 0;

    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: { if( counter < E_Steps )
    xStep = -Ref_Steps;
    else
    {
    xStep = -M_Steps;
    counter = E_Steps;
    }
    yStep = 0;
    if( F_Mode == 1 )
    zStep = 32222;
    else
    zStep = 0;
    Vecout(xStep, yStep, zStep);
    }
    break;
    case 77: { if( counter < E_Steps )
    xStep = Ref_Steps;
    else
    {
    xStep = M_Steps;
    counter = E_Steps;
    }
    yStep = 0;
    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;
    }
    }
    RampGen = 0;
    return;
    }

    /-----Funktion: Pen absenken-------------------------------------/

    void Pen_down()
    {

    unsigned char Next_Value;

    Next_Value = 0x87;
    Mout( Next_Value );
    delay_100();

    return;
    }

    /-----Funktion: Pen anheben-----------------------------------------/

    void Pen_up()
    {

    unsigned char Next_Value;

    Next_Value = 0x9B;
    Mout( Next_Value );
    delay_100();

    return;
    }]

    fehlermeldungen:

    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:9:20: smcmot.c: No such file or directory
    G: \smc800\S M C_D RV1 \S M C_ C\S M CMAI N. C: In fundion 'int main(J':
    IG:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:31: error: 'RampGen' undeclared (first use this function)
    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:31: error: (Each undeclared identifier is reported only once for each function it appears in.) G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:33: error: 'LPT' undeclared (first use this fundion)
    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:46: error: 'Rampe_Start' undeclared (first use this fundion)
    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:47: error: 'Rampe_Ende' undeclared (first use this fundon)
    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:48: error: 'Steilheit' undeclared (first use this function)
    IG:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C: In fundion 'yoid PloUer(j':
    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:82: error: 'T astatur' undeclared (first use this fundion) G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:93: error: 'Referenz' undeclared (first use this function) G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:11 0: error: Vecout' undeclared (first use this function) G: \smc800\S M C_D RV1 \S M C_ C\S M CMAI N. C: In fundion 'yoid XYZ     S ystemO':
    G:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:130: error: 'T astat ur' undeclared (first use this fundion) G: \smc800\S M C_D RV1 \S M C_ C\S M CMAI N. C: 141: error: 'R eferenz' undeclared (first use this function) IG:\smc800\SMC_DRV1 \SMC_C\SMCMAIN.C:149: error: Vecout' undeclared (first use this function)
    E :-:ecution terminated

    0
  • K

    a) bitte im richtigen Forum
    b) bitte Codetags verwenden!

    0
  • E

    c) wenn du es gekauft hast, warum veroeffentlichst dus ?
    d) void delay_500();
    /-----Funktion: Verz”gert Programmablauf um ca. 150ms ---------------------/
    void delay_100()

    das hast du gekauft ? nicht nur das der code schlecht ist - die comments sind zudem falsch (und auf die idee eines delay(int) kahm wo niemand #gg

    ich glaub aber das der code auch mit einem code tag unlesbar waere - sehr inkonsequente handhabe der einrueckung und neu zeilen

    0
Anmelden zum Antworten