Robot Arm spielt Schach (Arduino Mini 05)

Hallo,
für diejenigen, die das Projekt AdeTeK interessiert, hier nun die Prozedur, mit der ihr drei Stepper-Motoren synchron ansteuern könnt. Es ist alles in Echtzeit programmiert, so dass ihr jeden Arduino dafür benutzen könnt. Nähere Einzelheiten findet ihr auf meinem YouTube-Kanal, insbesondere das Video Nr. 16.
Hier der Link:

Hier der erste Teil des Codes:

const int ANZAHL_FELDER = 5;//Werte durch "," getrennt
int       feldIndex = 0;
float     values[ANZAHL_FELDER];

//-----------------------------------------
int HauptMotorDir   = 0;
int HauptMotorStep  = 0;
int NebenMotor1Dir  = 0;
int NebenMotor1Step = 0;
int NebenMotor2Dir  = 0;
int NebenMotor2Step = 0;

int Mot1Step	= 2;    //Mot1 Step X
int Mot1Dir		= 3;    //Mot1 DIR  X
int Mot2Step	= 4;    //Mot2 Step Y
int Mot2Dir		= 5;    //Mot2 DIR  Y
int Mot3Step	= 6;    //Mot3 Step Z
int Mot3Dir		= 7;    //Mot3 DIR  Z
int LED_Pin13 = 13;
//-----------------------------------------

//-----------------------------------------
int PulseDelay              = 80; //Delay zwischen Step HIGH/LOW Mikrosekunden
float BeschleunigungsFaktor = 3;
float amSchnellsten         = 200.0; //uS
float Highspeed             = amSchnellsten; //Mikrosekunden
float Beschleunigung        = Highspeed * BeschleunigungsFaktor;
//-----------------------------------------

//##### Anfang lineare Rampe ####
int   ArrayIndex   = 300; //Rampenlaenge insgesamt (Anfahrt + Bremse) = ArrayIndex * 2
float MinimalWeg   = 2000;
float Rampenlaenge = float(ArrayIndex);
float RampenCoeff  = float(Beschleunigung / Rampenlaenge);
//##### Ende lineare Rampe ######

//-----------------------------------------
void setup()
{
  pinMode(Mot1Dir,     OUTPUT);  //Pin 2
	pinMode(Mot1Step,    OUTPUT);  //Pin 3
	pinMode(Mot2Dir,     OUTPUT);  //Pin 4
	pinMode(Mot2Step,    OUTPUT);  //Pin 5
	pinMode(Mot3Dir,     OUTPUT);  //Pin 6
	pinMode(Mot3Step,    OUTPUT);  //Pin 7
  pinMode(LED_Pin13,   OUTPUT);  //Pin 13

  digitalWrite(Mot1Dir, LOW); //counterclockwise
  digitalWrite(Mot2Dir, LOW); //counterclockwise
  digitalWrite(Mot3Dir, LOW); //counterclockwise

  Serial.begin(9600);
}//Ende:.void setup()
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
void loop()
{
  if( Serial.available())
  {

    for(feldIndex = 0; feldIndex  < ANZAHL_FELDER; feldIndex ++)
    {
      values[feldIndex] = Serial.parseFloat();
    }//Ende:.for(fieldIndex = 0; fieldIndex  < 5; fieldIndex ++)

    switch (int(values[0])) //Funktionszuordnung werden abgefragt
    {
      case 1:
        Blink_13(int(values[1]),int(values[2]));
      break;

      case 3:
        FahrtXYZ(int(values[1]), int(values[2]), int(values[3]));
      break;

      case 12:
        Kaufmann(float (values[1]));
      break;
    }//Ende:.switch (int(values[0]))

    feldIndex  = 0;
    values[0]  = 0;
    values[1]  = 0;
    values[2]  = 0;
    values[3]  = 0;
    values[4]  = 0;// ready to start over

    while (Serial.read() != -1);

  }//Ende:.if( Serial.available())
}//Ende:...void loop()
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
void Blink_13(int x_mal, int bl_freq)
{
	for (int i = 1; i <= x_mal; i++)
	{
		digitalWrite(LED_Pin13, HIGH);
		delay(bl_freq);
		digitalWrite(LED_Pin13, LOW);
		delay(bl_freq);
	}
}//Ende:.void Blink_12(int x_mal, int bl_freq)
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
int runden(float number) //kaufmaennisches Runden
{
  int x;
  x = (int)number;
  if (number - x >= 0.5)
  {
    x += 1;
  }
  else
  {
    x = (int)number;
  }
  return x;
}//Ende: int runden(float number)
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
void Kaufmann(float dezimalzahl)
{
  int gerundeteZahl = runden(dezimalzahl);
  Serial.print("Dezimalzahl    = "); Serial.println(dezimalzahl);
  Serial.print("gerundete Zahl = "); Serial.println(gerundeteZahl);
}//Ende: void Kaufmann(float dezimalzahl)
//---------------------------------------------------------------------------------------

... und hier die eigentliche Prozedur:

void FahrtXYZ(int XSteps, int YSteps, int ZSteps)
{

	float NM1z = 0.0; float NM1index = 0.0; float NM1teiler = 0.0; int NM1teiler2 = 0;
	float NM2z = 0.0; float NM2index = 0.0; float NM2teiler = 0.0; int NM2teiler2 = 0;
	int NM1teiler_S = 0;
	int NM2teiler_S = 0;

	float SummeXYZ     = 0.0;
	int HauptMotor     = 0;
	int NebenMotor_1   = 0;
	int NebenMotor_2   = 0;
	int StepCount      = 2;
	int zaehlerSteps   = 0;
	int SpeicherXSteps = 0;
	int SpeicherYSteps = 0;
	int SpeicherZSteps = 0;

//Echtzeit....................
	int Geschwindigkeit   = 1;
	int indexCoeffAnfahrt = 0;
	int indexCoeffBremse  = 0;
    int ArrayIndex1     = 0;
    int ArrayIndex2     = 0;
//Echtzeit....................

  Serial.print("XSteps Soll = "); Serial.println(XSteps);
  Serial.print("YSteps Soll = "); Serial.println(YSteps);
  Serial.print("ZSteps Soll = "); Serial.println(ZSteps);
  Serial.println();

	SummeXYZ = float(XSteps + YSteps + ZSteps);
	//Serial.print("--- SummeXYZ = "); Serial.print(SummeXYZ); Serial.println(" ---");

	//-------------------------------------------------------
  //Vorbereitung 1 (XSteps am groessten)
	if (XSteps >= YSteps && XSteps >= ZSteps)//-X- (Y & Z Verteilung)
	{
		HauptMotorStep  = Mot1Step; //X-Motor
		NebenMotor1Step = Mot2Step; //Y-Motor
		NebenMotor2Step = Mot3Step; //Z-Motor

    if (YSteps == 0)
    {
      NM1z = 0;
    }
    else
    {
      NM1z = float(SummeXYZ / YSteps);
    }

    if (ZSteps == 0)
    {
      NM2z = 0;
    }
    else
    {
      NM2z = float(SummeXYZ / ZSteps);
    }

		NM1index    = 1.0;
		NM1teiler   = float(NM1index * NM1z);
		NM1teiler2  = runden(NM1teiler);
		NM1teiler_S = NM1teiler2;

		NM2index    = 1.0;
		NM2teiler   = float(NM2index * NM2z);
		NM2teiler2  = runden(NM2teiler);
		NM2teiler_S = NM2teiler2;

		if (YSteps == 0 || ZSteps == 0) StepCount = 1;

	}//Ende: if (XSteps >= YSteps && XSteps >= ZSteps)

	//-------------------------------------------------------
  //Vorbereitung 2 (YSteps am groessten)
	if (YSteps >= XSteps && YSteps >= ZSteps)//-Y- (X & Z Verteilung)
	{
		HauptMotorStep  = Mot2Step; //Y-Motor
		NebenMotor1Step = Mot1Step; //X-Motor
		NebenMotor2Step = Mot3Step; //Z-Motor

    if (XSteps == 0)
    {
      NM1z = 0;
    }
    else
    {
      NM1z = float(SummeXYZ / XSteps);
    }

    if (ZSteps == 0)
    {
      NM2z = 0;
    }
    else
    {
      NM2z = float(SummeXYZ / ZSteps);
    }

		NM1index    = 1.0;
		NM1teiler   = float(NM1index * NM1z);
		NM1teiler2  = runden(NM1teiler);
		NM1teiler_S = NM1teiler2;

		NM2index    = 1.0;
		NM2teiler   = float(NM2index * NM2z);
		NM2teiler2  = runden(NM2teiler);
		NM2teiler_S = NM2teiler2;

    if (XSteps == 0 || ZSteps == 0) StepCount = 1;

	}//Ende: if (YSteps >= XSteps && YSteps >= ZSteps)

	//-------------------------------------------------------
  //Vorbereitung 3 (ZSteps am groessten)
	if (ZSteps >= XSteps && ZSteps >= YSteps)//-Z- (X & Y Verteilung)
	{
		HauptMotorStep  = Mot3Step; //Z-Motor
		NebenMotor1Step = Mot1Step; //X-Motor
		NebenMotor2Step = Mot2Step; //Y-Motor

   if (XSteps == 0)
    {
      NM1z = 0;
    }
    else
    {
      NM1z = float(SummeXYZ / XSteps);
    }

    if (YSteps == 0)
    {
      NM2z = 0;
    }
    else
    {
      NM2z = float(SummeXYZ / YSteps);
    }

		NM1index    = 1.0;
		NM1teiler   = float(NM1index * NM1z);
		NM1teiler2  = runden(NM1teiler);
		NM1teiler_S = NM1teiler2;

		NM2index    = 1.0;
		NM2teiler   = float(NM2index * NM2z);
		NM2teiler2  = runden(NM2teiler);
		NM2teiler_S = NM2teiler2;

    if (XSteps == 0 || YSteps == 0) StepCount = 1;

	}//Ende: if (ZSteps >= XSteps && ZSteps >= YSteps)

	//-------------------------------------------------------
  //Vorbereitung 4 (Rampen und Fahrweg)
	if (SummeXYZ < MinimalWeg)//hier 2000 Steps (s.o.)
	{
		ArrayIndex1  = int(MinimalWeg / 3); //Rampenlaenge insgesamt (Anfahrt + Bremse) = ArrayIndex1 * 2
		Rampenlaenge = float(ArrayIndex1);
		RampenCoeff  = float(Beschleunigung / Rampenlaenge); //z.B. bei 90 -> 17.78, bei 50 --> 32.00
		Highspeed    = Beschleunigung;

	}
	else
  {
		ArrayIndex2  = ArrayIndex * 2; // 300 * 2 Rampenlaenge insgesamt (Anfahrt + Bremse)
		Rampenlaenge = float(ArrayIndex2);
		RampenCoeff  = float(Beschleunigung / Rampenlaenge); //z.B. bei 90 -> 17.78, bei 50 --> 32.00
		Highspeed    = amSchnellsten;
	}

	//-------------------------------------------------------

	indexCoeffAnfahrt = int(Rampenlaenge); //hier Rampenlaenge = 300 (s.o.)
	indexCoeffBremse  = 1;

//#######################################################################################
//Auswertung
	while (StepCount <= SummeXYZ)
	{
		//Anfahren
		if (StepCount <= int(Rampenlaenge))
		{
			Geschwindigkeit = Highspeed + runden(indexCoeffAnfahrt * RampenCoeff);
			indexCoeffAnfahrt--;
		}
		//Highspeed
		if (StepCount > int(Rampenlaenge) && StepCount < SummeXYZ - int(Rampenlaenge))
		{
			Geschwindigkeit = Highspeed; // hier 200 uS (s.o.)
		}
		//Bremsen
		//if (StepCount > (SummeXYZ - int(Rampenlaenge)) && StepCount < SummeXYZ-2)
    if (StepCount > (SummeXYZ - int(Rampenlaenge)) && StepCount <= SummeXYZ)
		{
			Geschwindigkeit = Highspeed + runden(indexCoeffBremse * RampenCoeff);
			indexCoeffBremse++;
		}

    //Auswertung
		if (StepCount != NM1teiler_S && StepCount != NM2teiler_S)
		{
			digitalWrite(HauptMotorStep, HIGH);    //PIN on
			delayMicroseconds(PulseDelay);
			digitalWrite(HauptMotorStep, LOW);     //PIN off
			delayMicroseconds(Geschwindigkeit);
			HauptMotor++; //Zaehler fuer HauptMotor-Steps
			StepCount++;
			{goto bailoutXYZ;}
		}//Ende: if (StepCount != teilerY_S && StepCount != teilerZ_S)

		if (StepCount == NM1teiler2)
		{
		  if (NM1teiler2 == 0){goto bailoutXYZ;}
			digitalWrite(NebenMotor1Step, HIGH);    //PIN on
			delayMicroseconds(PulseDelay);
			digitalWrite(NebenMotor1Step, LOW);     //PIN off
			delayMicroseconds(Geschwindigkeit);
			NebenMotor_1++; //Zaehler fuer NebenMotor_1-Steps

			NM1index++; NM1teiler = NM1index * NM1z;
			NM1teiler2 = runden(NM1teiler);

			zaehlerSteps++;
		}//Ende: if (StepCount == NM1teiler2)

		if (StepCount == NM2teiler2)
		{
		  if (NM2teiler2 == 0){goto bailoutXYZ;}
			digitalWrite(NebenMotor2Step, HIGH);    //PIN on
			delayMicroseconds(PulseDelay);
			digitalWrite(NebenMotor2Step, LOW);     //PIN off
			delayMicroseconds(Geschwindigkeit);
			NebenMotor_2++; //Zaehler fuer NebenMotor_2-Steps

			NM2index++; NM2teiler = NM2index * NM2z;
			NM2teiler2 = runden(NM2teiler);

			zaehlerSteps++;
		}//Ende: if (StepCount == NM2teiler2)

bailoutXYZ:
		NM1teiler_S = NM1teiler2;
		NM2teiler_S = NM2teiler2;
		StepCount = StepCount + zaehlerSteps;
		zaehlerSteps = 0;
	}//Ende: while-Scleife
//#######################################################################################

	 Serial.print("HauptMotor   Ist = "); Serial.println(HauptMotor);
	 Serial.print("NebenMotor_1 Ist = "); Serial.println(NebenMotor_1);
	 Serial.print("NebenMotor_2 Ist = "); Serial.println(NebenMotor_2);
	 Serial.println();
}//Ende: FahrtXYZ

Ich grüße alle.
Peter

Hier die Code-Teile, wie ihr den Arduino mit Visual Basic von außen besser steuern könnt. Im Video Nr. 18 im Projekt AdeTeK auf YouTube habe ich die Einzelheiten erklärt.

Der Link zum Projekt AdeTeK:

Viele Grüße an alle.
Peter

Der Code:

Für Visual Basic--------------------------------------------------

Private Sub sleep(ByVal sleeptime As Integer)
  Dim stopw As New Stopwatch
  stopw.Start()
  Do Until stopw.ElapsedMilliseconds >= sleeptime
    Application.DoEvents()
  Loop
  stopw.Stop()
  stopw.Reset()
End Sub


Private Sub btnReadGrundeinst_Click(sender As Object, e As EventArgs) Handles btnReadGrundeinst.Click
  tbReceived.Clear()
  SerialPort1.Write("4,0,0,0,0")
  sleep(2000)
  Dim Zeile() As String = tbReceived.Lines
  Try
    tbAmSchnellsten.Text = Zeile(0)
    tbBeschleunigFaktor.Text = Zeile(1)
    tbArrayIndex.Text = Zeile(2)
    tbPulseDelay.Text = Zeile(3)
  Catch ex As Exception
    MsgBox("Es sind noch keine Werte vorhanden.")
  End Try
End Sub


Private Sub btnWriteGrundeinst_Click(sender As Object, e As EventArgs) Handles btnWriteGrundeinst.Click
  tbReceived.Clear()
  SerialPort1.Write("5," & tbAmSchnellsten.Text & "," & tbBeschleunigFaktor.Text & "," & tbArrayIndex.Text & "," & tbPulseDelay.Text)
End Sub


Für den Arduino---------------------------------------------------

case 4:
  GrundeinstellungenSenden();
break;
//-----------------------
case 5:
  Grundeinstellungen(float (values[1]), float (values[2]), int(values[3]), int(values[4]) ); //aS, BF, AI, PD
break;
//----------------------
void GrundeinstellungenSenden()//case 4:
{
  Serial.println(amSchnellsten);
  Serial.println(BeschleunigungsFaktor);
  Serial.println(ArrayIndex);
  Serial.println(PulseDelay);
}
//------------------------

//------------------------
void Grundeinstellungen(float aS, float BF, int AI, int PD )//aS = amSchnellsten, BF = BeschleunigungsFaktor, AI = ArrayIndex, PD = PulseDelay
{
  amSchnellsten         = aS; //case 5:
  BeschleunigungsFaktor = BF;
  ArrayIndex            = AI;
  PulseDelay            = PD;

  Serial.print("neue Werte:"); Serial.println();
  Serial.println();
  Serial.print("amSchnellsten  = "); Serial.println(amSchnellsten);
  Serial.print("Beschl.-Faktor = "); Serial.println(BeschleunigungsFaktor);
  Serial.print("ArrayIndex     = "); Serial.println(ArrayIndex);
  Serial.print("PulseDelay     = "); Serial.println(PulseDelay);
}

Hallo,
hier der Quellcode, die Prozedur, um die Winkel bei RoboKran zu berechnen. Eigentlich steht und fällt das Projekt AdeTeK mit dem Wissen um diese Winkel-Mathematik. Erklärt wird diese im Video Nr. 19 des YouTube-Kanals.

Private Sub btnBerechneWinkel_Click(sender As Object, e As EventArgs) Handles btnBerechneWinkel.Click
        Dim Y_Arm, Z_Arm, z, Achshoehe_Y, MagnetLeiste As Integer
        Dim posY, posZ, winkel_Y, winkel_Z, HilfsWinkel, c As Double
        'Die Namen der Textboxes zur Eingabe: "tbPosY", "tbPosZ"
        'zur Ausgabe: "tbWinkelY", "tbWinkelZ"
        'Der Name des Berechne-Winkel-Button: "btnBerechneWinkel"
        posY = tbPosY.Text
        posZ = tbPosZ.Text
        Achshoehe_Y = 90
        MagnetLeiste = 72
        Y_Arm = 230
        Z_Arm = 230
        z = posZ + MagnetLeiste - Achshoehe_Y
        c = posY ^ 2 + z ^ 2 ' ...ist c-Quadrat
        c = Math.Sqrt(c) '     ...ist Wurzel aus c-Quadrat, also c

        winkel_Z = (Y_Arm ^ 2 + Z_Arm ^ 2 - c ^ 2) / (2 * Y_Arm * Z_Arm) '...ist winkel_Z als Cosinus 
        winkel_Z = Math.Acos(winkel_Z) '                                  ...ist winkel_Z als ArcusCosinius in Radians
        winkel_Z = (180 / Math.PI) * winkel_Z '                           ...ist winkel_Z umgerechnet von Radians in Grad
        tbWinkelZ.Text = Math.Round(winkel_Z, 2) '                        ...ist winkel_Z mit 2 Stellen hinter dem Komma

        HilfsWinkel = (Y_Arm ^ 2 + c ^ 2 - Z_Arm ^ 2) / (2 * Y_Arm * c) ' ...ist HilfsWinkel als Cosinus
        HilfsWinkel = Math.Acos(HilfsWinkel) '                            ...ist HilfsWinkel als ArcusCosinius in Radians
        HilfsWinkel = (180 / Math.PI) * HilfsWinkel '                     ...ist HilfsWinkel umgerechnet von Radians in Grad

        winkel_Y = z / posY '                                             ...ist winkel_Y als Tangens
        winkel_Y = Math.Atan(winkel_Y) '                                  ...ist winkel_Y als ArcusTangens in Radians
        winkel_Y = (180 / Math.PI) * winkel_Y + HilfsWinkel '             ...ist winkel_Y umgerechnet von Radians in Grad + HilfsWinkel

        tbWinkelY.Text = Math.Round(winkel_Y, 2) '                        ...ist winkel_Y mit 2 Stellen hinter dem Komma
    End Sub

Ich grüße alle ganz herzlich.
Peter

Hallo,

hier jetzt die Winkelberechnungen mit dem Arduino als Ergänzung zum vorigen Post. Erklärt wir die ganze Sachen im Video Nr. 20.

Hier der Code:

############# Arduino-Code ###################

#include <math.h>

case 6:
  Winkelberechnung(float (values[1]), float (values[2]));//values[1] = posY, values[2] = posZ
break;

//---------------------------------------------------------------------------------------
void Winkelberechnung(float posY, float posZ)//case 6:
{
  int z;
  float winkel_Y;
  float winkel_Z;
  float HilfsWinkel;
  float c;

  const long Y_Arm_Hoch2              = 52900;
  const long Z_Arm_Hoch2              = 52900;
  const long Zwei_mal_Y_Arm_mal_Z_Arm = 105800;
  const int Zwei_mal_Y_Arm            = 460;
  const int Achshoehe_Y               = 90;
  const int MagnetLeiste              = 72;

  z = posZ + MagnetLeiste - Achshoehe_Y;
  c = posY * posY + z * z;
  c = sqrt(c);
  float c_Hoch2 = c * c;

  winkel_Z = (Y_Arm_Hoch2 + Z_Arm_Hoch2 - c_Hoch2) / (Zwei_mal_Y_Arm_mal_Z_Arm);
  winkel_Z = acos(winkel_Z);
  winkel_Z = (180 / PI) * winkel_Z;

  HilfsWinkel = (Y_Arm_Hoch2 + c_Hoch2 - Z_Arm_Hoch2) / (Zwei_mal_Y_Arm * c);
  HilfsWinkel = acos(HilfsWinkel);
  HilfsWinkel = (180 / PI) * HilfsWinkel;

  winkel_Y = posY / c; //nicht ueber den Tangens (z / posY), sondern ueber den Cosinus (posY / c)
  winkel_Y = acos(winkel_Y);
  winkel_Y = (180 / PI) * winkel_Y + HilfsWinkel;

  Serial.println(winkel_Y);
  Serial.println(winkel_Z);
}//Ende: void Winkelberechnung(float posY, float posZ)
//---------------------------------------------------------------------------------------

################### Visual Basic Prozedur ##########################

Private Sub btnBerechneWinkel_Arduino_Click(sender As Object, e As EventArgs) Handles btnBerechneWinkel_Arduino.Click
        'Die Namen der Textboxes zur Eingabe: "tbPosY_Arduino", "tbPosZ_Arduino"
        'zur Ausgabe: "tbWinkelY_Arduino", "tbWinkelZ_Arduino"
        'Der Name des Berechne-Winkel-Button: "btnBerechneWinkel_Arduino"

        SerialPort1.Write("6," & tbPosY_Arduino.Text & "," & tbPosZ_Arduino.Text & ",0,0")

        sleep(2000)
        Dim Zeile() As String = tbReceived.Lines
        Try
            tbWinkelY_Arduino.Text = Zeile(0)
            tbWinkelZ_Arduino.Text = Zeile(1)
        Catch ex As Exception
            MsgBox("Es sind noch keine Werte vorhanden.")
        End Try
        tbReceived.Clear()
    End Sub

Viele Grüße...
Peter

Hallo liebe Foristen,

ich habe jetzt ein neues Video hochgeladen. Es soll das Hauptvideo meines YouTube-Kanals werden im Projekt AdeTeK. Ich, als absolutes Video-Greenhorn, habe mich bemüht, jetzt doch ein wenig jenseits der Schlaftablette zu produzieren. Über ein Feedback Eurerseits würde ich mich sehr freuen.

Hier der Link zum YouTube-Kanal:

Es ist das Video "21 Roboter Arm spielt Schach".

@Uwe
Ich danke Dir für Deinen Hinweis seinerzeit. Ich habe ihn mir zu Herzen genommen.

Viele Grüße an alle.
Peter

Hier der Quellcode vom Video 23 "RoboKran über die Tastatur steuern"

#################### Arduino Code ##############################

int GlobalstepsX     = 0;        //Globaler Zaehler fuer ArmXTest und FahrtXYZ()
int GlobalstepsY     = 0;        //Globaler Zaehler fuer ArmYTest und FahrtXYZ()
int GlobalstepsZ     = 0;        //Globaler Zaehler fuer ArmZTest und FahrtXYZ()
int ResetPause       = 4000;     //Mikrosekunden



case 7:
  ArmXTest(int(values[1]), int(values[2]));
break;

case 8:
  ArmYTest(int(values[1]), int(values[2]));
break;

case 9:
  ArmZTest(int(values[1]), int(values[2]));
break;


//---------------------------------------------------------------------------------------
void ArmXTest(int richtung, int steps) //case 7:
{
	if (richtung == 1)
	{
		digitalWrite(Mot1Dir, HIGH);   //X-Motor right
		GlobalstepsX = GlobalstepsX + steps;
	}

	if (richtung == 0)
	{
		digitalWrite(Mot1Dir, LOW);    //X-Motor left
		GlobalstepsX = GlobalstepsX - steps;
	}

	for (int i = 1; i <= steps; i++)
	{
		digitalWrite(Mot1Step, HIGH);
		delayMicroseconds(PulseDelay);
                digitalWrite(Mot1Step, LOW);
		delayMicroseconds(ResetPause); //Standard-Pause
	}
	Serial.print("X-Steps seit RST: "); Serial.println(GlobalstepsX);
}//Ende: void ArmXTest(int richtung, int steps)
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
void ArmYTest(int richtung, int steps) //case 8:
{
	if (richtung == 1)
	{
		digitalWrite(Mot2Dir, HIGH);   //Arm back
                GlobalstepsY = GlobalstepsY - steps;
	}

	if (richtung == 0)
	{
		digitalWrite(Mot2Dir, LOW);    //Arm forward
		GlobalstepsY = GlobalstepsY + steps;
	}

	for (int i = 1; i <= steps; i++)
	{
		digitalWrite(Mot2Step, HIGH);
		delayMicroseconds(PulseDelay);
                digitalWrite(Mot2Step, LOW);
		delayMicroseconds(ResetPause); //Standard-Pause
	}
	Serial.print("Y-Steps seit RST: "); Serial.println(GlobalstepsY);
}//Ende: void ArmYTest(int richtung, int steps)
//---------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------
void ArmZTest(int richtung, int steps) //case 9:
{
	if (richtung == 1)
	{
		digitalWrite(Mot3Dir, HIGH);   //Arm down
		GlobalstepsZ = GlobalstepsZ - steps;
	}

	if (richtung == 0)
	{
		digitalWrite(Mot3Dir, LOW);    //Arm up
		GlobalstepsZ = GlobalstepsZ + steps;
	}

	for (int i = 1; i <= steps; i++)
	{
		digitalWrite(Mot3Step, HIGH);
		delayMicroseconds(PulseDelay);
                digitalWrite(Mot3Step, LOW); //Standard-Pause
		delayMicroseconds(ResetPause);
	}
	Serial.print("Z-Steps seit RST: "); Serial.println(GlobalstepsZ);
}//Ende: void ArmZTest(int richtung, int steps)
///---------------------------------------------------------------------------------------

###################### Visual Basic Code ###################################

Private Sub btnKeyPreviewON_Click(sender As Object, e As EventArgs) Handles btnKeyPreviewON.Click
        btnKeyPreviewOFF.Enabled = True
        btnKeyPreviewON.Enabled = False
        Me.KeyPreview = True
End Sub

Private Sub btnKeyPreviewOFF_Click(sender As Object, e As EventArgs) Handles btnKeyPreviewOFF.Click
        btnKeyPreviewON.Enabled = True
        btnKeyPreviewOFF.Enabled = False
        Me.KeyPreview = False
End Sub

Private Sub Form1_KeyDown(sender As Object, e As KeyEventArgs) Handles MyBase.KeyDown

        '#################################################################### Motor X
        'R Arm X Right -------------------------------------- R Arm X Right 	
        If e.KeyCode = Keys.R Then
            SerialPort1.Write("7,1,100,0,0" & "\n") '5 Steps rechts
        End If

        'L Arm X Left --------------------------------------- L Arm X Left
        If e.KeyCode = Keys.L Then
            SerialPort1.Write("7,0,100,0,0" & "\n") '5 Steps links
        End If
        '#################################################################### Motor Y
        'F Arm Y Forward ------------------------------------ F Arm Y Forward	
        If e.KeyCode = Keys.F Then
            SerialPort1.Write("8,0,100,0,0" & "\n") '5 Steps forward
        End If

        'B Arm Y Back --------------------------------------- B Arm Y Back
        If e.KeyCode = Keys.B Then
            SerialPort1.Write("8,1,100,0,0" & "\n") '5 Steps back
        End If
        '#################################################################### Motor Z
        'U Arm Z Up ----------------------------------------- U Arm Z Up	
        If e.KeyCode = Keys.U Then
            SerialPort1.Write("9,0,100,0,0" & "\n") '5 Steps up
        End If

        'D Arm Z Down --------------------------------------- D Arm Z Down
        If e.KeyCode = Keys.D Then
            SerialPort1.Write("9,1,100,0,0" & "\n") '5 Steps down
        End If
        '####################################################################
End Sub

Hallo an alle,

hier auf meinem YouTube-Kanal eine kleine Studie, die beschreibt, wie Maschinensteuerung über den G-Code mit meinem kleinen Holzkran realisiert wird. Es ist gerade für den, der sich mit diesem Thema befassen möchte, ein echt spannender Einstieg.

Viele Grüße an alle...
Peter

Hallo Peter,
toll, dass es bei Deinem Projekt noch weiter geht.

Das neue Video mit dem G-Code hat mich begeistert.
Ich fände es toll, wenn Du mehr Videos zu diesem Thema machst.

Genau in die Richtung 'Fräse' will ich.
Stichwort: Käsefräse
Forum: z. B. http://www.cncecke.de/forum/index.php

Der Bau meines Robokranes geht gut voran, die Holzarbeiten sind fast fertig.
Etwas aufgehalten hat mich die Erstellung eines Modells in Google Sketchup.
Ich musste mich erst in das Programm einarbeiten.

Gruss
Kurti

Hallo an die RoboKran-Nachbauer,

ich poste Euch hier einmal die abgefahrene Funktion, mit der Ihr aus der bekannten Feldnummer die unbekannte Parkplatznummer ermitteln könnt. Es ist eine Ableitung der ganz normalen linearen Funktionsgleichung Y=m*x+b.
Ich habe es allerdings noch nicht hinbekommen, ohne eine if-Anweisung. Eine Gleichung ohne jegliche if-Anweisung wäre der Hammer.

Private Function FeldnummerZuParkplatz(ByVal Feldnummer As Double) As Integer
        Dim X, Y, n, m, Parkplatz As Integer
        X = Int(Feldnummer / 10)
        Y = Feldnummer - X * 10

        If Y < 3 Then
            n = 0
            m = 11
        Else
            n = 5
            m = 1
        End If
        Parkplatz = ((Y + n) * 10 + m + Y / 10) - Feldnummer / 10

        Return Parkplatz
End Function

Hallo Kurti,
schön, dass es vorangeht.

Ich grüße Dich herzlich...
Peter

Hallo an alle,
der kleine Holzkran jetzt mit G-Code Interpreter. Berechnung auf ~ 1/100 mm Genauigkeit. Wer Lust hat, kann ja mal vorbeischauen.

Viele Grüße an alle...
Peter