2. Informationsfluß von Oberfläche bis Hardware

Ausgehend vom Dialog "Manuelle Justage" - Eingabe "Neuer Winkel" wird der Informationsfluß im Programm nachverfolgt und erklärt.
 

Betrachtung Manuelle Justage
 

Dialogitem: "Neuer Winkel"
 

1. Eingabe des neuen Winkels

 m_dlg.cpp (TAngleControl::Dlg_OnCommand)

     :
     :
  case id_NewAngle:
      hDlgItem = GetDlgItem( hwnd, id_NewAngle );
     break;
     :
     :

   -> aktuelles Dialogelement wird auf id_NewAngle gesetzt

2. Betätigung von ENTER

  -> IDOK-Event wird ausgeloest

3. Event-Verarbeitung

m_dlg.cpp

   case IDOK:
  if (!hDlgItem)
    {
      TModalDlg::Dlg_OnCommand( hwnd, id, hwndCtl, codeNotify );
      break;
    }
    // Der Nutzer hat mit Return eine neue Position, eine neue Geschwindigkeit
    // oder eine neue Schrittweite eingegeben
    for (;;)
    {
        :
        :
        :
      if (hDlgItem == GetDlgItem( hwnd, id_NewAngle ))         // akt. Dialogitem=NewAngle
      {
        if (!bMoveActive)                                    // Motor nicht in Fahrt
        {
          GetDlgItemText( hwnd, id_NewAngle, (LPSTR)buf, 10 ); // Winkelwert aus Textfeld lesen
          bMoveActive = TRUE;                                // Motor-aktiv setzen
          bLongMove = TRUE;                                  // Fahrbetrieb setzen
          mMoveToDistance( atof( buf ) );                    // Aufruf der c-Call-Funktion
          FORWARD_WM_COMMAND( hwnd, cm_MoveButton, 0, 0, PostMessage );
        }
        break;
      }
        :
        :
        :
    }
    hDlgItem = NULL;
    SetFocus( BarHandle );    //"Winkelbalken" bekommt Fokus
    break;

   -> bei eingegebenem Winkel (aus Dialogelement in Puffer gelesen)
        wird bei inaktivem Motor (bMoveActive == FALSE)
        auf Fahrbetrieb gestellt (bMoveActive = TRUE; bLongMove = TRUE)

4. Aufruf von
     BOOL mMoveToDistance( atof (buf)) (buf = aus Textfeld gelesener Winkelwert)

m_layer.cpp

    BOOL _export WINAPI mMoveToDistance(double angle)
  {
   if(!bModulLoaded) return FALSE;    // wurde motors.dll korrekt initialisiert ?
   lpMList->MP()->MoveToAngle(angle);   // Vorsicht: keine Fehlerkontrolle
   return TRUE;                       // Fkt. gibt immer TRUE zurueck - Fehler ??
  };

5. Aufruf von
   TMotor* TMList::MP(void)(motors.cpp: Rückgabe des aktiven Motors (nActiveDrive) )
   und BOOL TMotor::MoveToAngle(double angle)

motors.cpp

    BOOL TMotor::MoveToAngle(double ang)
  {
    long lpos;

    if(Translate(lpos,ang))               // Umwandlung von Winkel- in Positionsangaben
      if(MoveToPosition(lpos)) return TRUE; // Aufruf der DC-Motor-Funktion mit Pos.angabe
    return FALSE;                         // bei Fehlschlag: FALSE
    };

    -> Umrechnung von Winkelmass in Motorposition (motorspezifisch):
         BOOL TMotor::Translate(long &pos,double ang)
         - Berücksichtigung von dAngleBias, dAngleMax, fCorrBias
         - Unterscheidung von Sekunden- und Grad-Werten (abhängig von eUnit)
         - abhängig von eCorrStatus:
           Berechnung durch Polynomberechnung (Newton-Verfahren)
           (Benutzung von motors.cpp:
       int  TMotor::rtsave(double offset,double x1,double x2, double xacc, double *ret))

           oder einfache Umrechnung in MotorPos. ( l_pos = l_ang / dKoeff_1 )

----> Übergang zur Motorhardwareebene

6. Aufruf von
    TDCDrive::MoveToPosition(position) (position ist der vom Winkelmass umgerechnete Positionswert)

  BOOL TDC_Drive::MoveToPosition(long position)
 {
   if(bUpwards && (position < lPosition))     // Test, ob Motor noch vor Endlage
   {
    lDeltaPosition += dwHysteresis;
    bUpwards = FALSE;
   }
   else if(!bUpwards && (position > lPosition)) // Testen, ob Motor noch vor Endlage
   {
    lDeltaPosition -= dwHysteresis;
    bUpwards = TRUE;
   };
   // Beruecksichtigen der relativen Position nach Programm-Start
   // und Richtungswechsel
   position -= lDeltaPosition + lCorrPos;
   return MoveAbsolute(position);             // Aufruf der C-812 bzw. C-832-Fkt.
 };

7. Aufruf der motorabhängigen Hardware-Funktion mit umgerechneter Positionsangabe
    (unter Berücksichtigung von Richtung, Spiel und relativer Position)
    TC_812::MoveAbsolute(position) bzw. TC832::MoveAbsolute(position)
 

a)
 BOOL TC_812::MoveAbsolute(long pos)
 {
   char    cmd[MaxString+1];

   sprintf(cmd,"%uMA%ld\r",nOnBoardId,pos); // Zusammensetzung des Motorkommandos
   if(R_OK == ExecuteCmd(cmd))            // Aufruf der Hardwarefkt.
     return TRUE;                         // korrekte Ausfuehrung des Kommandos: TRUE
   return FALSE;                          // wenn Fehler bei Kommandoausfuehrg.: FALSE
 };

  --> Erzeugung des Motorkommandos

    [boardID] MA [Position] [RETURN] (Move Absolute - Kommando für C-812-Karte)

    --> Aufruf der Hardwarezugriffsfunktionen
   BOOL TC_812ISA::ExecuteCmd(char *pString)    bzw.

   BOOL TC_812GPIB::ExecuteCmd(char *pString)

  kommentiertes BOOL TC_812ISA::ExecuteCmd(char *pString)
 

********** zur weiteren Betrachtung
   ->TC_812ISA::PutChar / TC_812ISA::GetChar / Delay
   ->TC_812GPIB --> gTransmit, gReceive, gSPoll
**********
 

b)
 BOOL TC_832::MoveAbsolute(long pos)
 {
   Drive628(LTRJ,LD_POS,pos);   // Motorkommando: Load Trajectory Parameter
   Drive628(STT,0,0);         // Motorkommando: Start Motion Control
   return TRUE;               // Rueckgabewert immer TRUE (Wieso ?)
 };

 --> Aufruf der Hardwarezugriffsfkt.  TC_832::Drive628 und Drive628c
     mit Motorkommandos (LTRJ -> Load Trajectory Parameters (pos, velo, accel, operation mode, etc.)
                                       STT   -> Start Motion Control: (execute selected Trajectory) )

********** zur weiteren Betrachtung
   ->PutWord /PutDWord / GetWord / GetDWord / LM628Ready
**********

Zusammenfassung

Der Informationsfluß verläuft durch folgende Klassen:

TModalDialog -> TMList -> TMotor -> TDC_Drive -> Motor-Instanzen (TC_812ISA, TC_812GPIB, TC_832)

Die zugehörigen Programmabschnitte befinden sich in folgenden Files:

m_dialog.cpp -> m_layer.cpp -> motors.cpp
 

zurück zur Übersicht