- Akku Tests und Balkonkraftwerk Speicher         
Seite 24 von 57 ErsteErste ... 14222324252634 ... LetzteLetzte
Ergebnis 231 bis 240 von 566

Thema: outdoor I

  1. 23.12.2019, 22:40 #231
    Moppi
    Moppi ist offline
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.677
    Blog-Einträge
    1
    Anzeige

     Zendure
    Ja! Dann probiere es morgen aus!

    Nein, ich denke, es war nicht zu viel, gerne wieder.

    Dir auch frohe Weihnachten!



    MfG
    ZitierenZitieren
  2. 26.12.2019, 17:03 #232
    inka
    inka ist offline
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    78
    Beiträge
    2.180
    ich habe mir mal die beiden versionen des codes angeschaut und verglichen...

    deine
    Code:
    // DIR und STEP pins definieren
#define dirPin_VL 6 //2
#define stepPin_VL 7 //3
#define dirPin_HL 8 //4
#define stepPin_HL 9 //5
#define dirPin_VR 2 //6
#define stepPin_VR 3 //7
#define dirPin_HR 4 //8
#define stepPin_HR 5 //9


//enable pins definieren
#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43


//resett pin definieren
#define PIN2RESET 10




//steps pro umdrehung definieren:
#define stepsPerRevolution 200




uint8_t taste_neu = 1;
uint8_t taste_alt = 8;
uint8_t taste = 0;


uint8_t s_vor = 0;
uint8_t s_rueck = 0;
uint8_t s_links = 0;
uint8_t s_rechts = 0;
uint8_t StepsPerDirection = 0;


void setup()
{
  //  pinMode(LED, OUTPUT);


  //pins als output:


  pinMode(dirPin_VL, OUTPUT);
  pinMode(stepPin_VL, OUTPUT);
  pinMode(enbl_VL, OUTPUT);
  pinMode(dirPin_HL, OUTPUT);
  pinMode(stepPin_HL, OUTPUT);
  pinMode(enbl_HL, OUTPUT);
  pinMode(dirPin_VR, OUTPUT);
  pinMode(stepPin_VR, OUTPUT);
  pinMode(enbl_VR, OUTPUT);
  pinMode(dirPin_HR, OUTPUT);
  pinMode(stepPin_HR, OUTPUT);
  pinMode(enbl_HR, OUTPUT);




  //resett pin zustand definieren
  pinMode(PIN2RESET, INPUT);


  Serial.begin(115200);
  Serial1.begin(115200);
  Serial.println("code----- /home/georg/Arduino/outdoor_robo/smartphone_steuerung/outdoor_moppi_FB_switch_bluetooth_1");


  Serial.println("bluetooth übertragung!");




  //enable pins deaktivieren:
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);


  //resett pin aktivieren
  digitalWrite(PIN2RESET, HIGH);
}


void loop()
{
  if (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    tasten_abfrage();
  }


  if ( StepsPerDirection > 0)
  {
        StepsPerDirection--;
        richtung_abfrage();
  }
}


/***********************************************************/
void richtung_abfrage(void)
{
  if (s_rechts == 1) rechts_drehen();
  if (s_links == 1) links_drehen();
  if (s_vor == 1) vorwaerts();
  if (s_rueck == 1) rueckwaerts();
}


/***********************************************************/
void tasten_abfrage(void)
{


  switch (taste)
  {


    case 100:// rotate rechts - FB quer smartphone
      {


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        rechts_drehen();


        break;
      }




    case 97:// rotate links - FB quer smartphone
      {


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        links_drehen();


        break;


      }




    case 116:// fahre vor - FB quer smartphone
      {


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        vorwaerts();


        break;
      }




    case 115:// fahre rückwärts - FB quer smartphone
      {


        StepsPerDirection = 200/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200 Schritte
        rueckwaerts();


        break;
      }
  }




}


/***********************************************************/
void alle_stepper_stop(void)
{
  //enable pins deaktivieren
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);
  reboot();
}


/***********************************************************/
void vorwaerts(void)
{
  if(s_vor == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);


      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);


      s_vor = 1;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}


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


void rueckwaerts(void)
{
  if(s_rueck == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);


      //richtung bestimmen
      digitalWrite(dirPin_VL, HIGH);
      digitalWrite(dirPin_HL, HIGH);
      digitalWrite(dirPin_VR, LOW);
      digitalWrite(dirPin_HR, LOW);


      s_vor = 0;
      s_rueck = 1;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}

/***********************************************************/
void rechts_drehen(void)
{
  if(s_rechts == 0)
  {
      // enable pins aktivieren
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);


      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, LOW);
      digitalWrite(dirPin_HR, LOW);


      s_vor = 0;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 1;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}




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


void links_drehen(void)
{
  if(s_links == 0)
  {
      //enable pins aktivieren
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);


      //richtung bestimmen
      digitalWrite(dirPin_VL, HIGH);
      digitalWrite(dirPin_HL, HIGH);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);


      s_vor = 0;
      s_rueck = 0;
      s_links = 1;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}


/*
  void links_drehen(void) //mit beschleunigung und sound
  {


  //enable pins aktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);


  //richtung bestimmen
  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);


  //"j = 2000": der Anfangswert für das Delay in Microsekunden


  for (int i = 0, j = 2000; i < stepsPerRevolution; i++)
  {


    //"j > 500": der Endwert für das Delay in Microsekunden - bestimmt auch die Endgeschwindigkeit (mindestens 250 bis 300)


    if (j > 300) j--;
    //"z < 3": wieviele Schritte mit dem eingstellten Delay "j" gemacht werden sollen, bevor es reduziert wird


    for (int z = 0; z < 3 && i < stepsPerRevolution; z++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(j);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(j);
      i++;
    }
  }
  }
*/
/***********************************************************/
void reboot()
{
  pinMode(PIN2RESET, OUTPUT);
  digitalWrite(PIN2RESET, LOW);
  delay(100);
}
/***********************************************************/


/************************************************************/
    und die meine
    Code:
    //#include "Arduino.h"

//2019_12_21:

//bei linksdrehen ist das langsammere anfahren berücksichtigt / auskommentiert
//dauerbewegung beim einmal drücken (fernbedienung "quer" am smartphone) geht nicht

//uint8_t LED = 13;

// DIR und STEP pins definieren
#define dirPin_VL 6 //2
#define stepPin_VL 7 //3
#define dirPin_HL 8 //4
#define stepPin_HL 9 //5
#define dirPin_VR 2 //6
#define stepPin_VR 3 //7
#define dirPin_HR 4 //8
#define stepPin_HR 5 //9

//enable pins definieren
#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43

//resett pin definieren
#define PIN2RESET 10


//steps pro umdrehung definieren:
#define stepsPerRevolution 1600


uint8_t taste_neu = 1;
uint8_t taste_alt = 8;
uint8_t taste = 0;



void setup()
{
  //  pinMode(LED, OUTPUT);

  //pins als output:

  pinMode(dirPin_VL, OUTPUT);
  pinMode(stepPin_VL, OUTPUT);
  pinMode(enbl_VL, OUTPUT);
  pinMode(dirPin_HL, OUTPUT);
  pinMode(stepPin_HL, OUTPUT);
  pinMode(enbl_HL, OUTPUT);
  pinMode(dirPin_VR, OUTPUT);
  pinMode(stepPin_VR, OUTPUT);
  pinMode(enbl_VR, OUTPUT);
  pinMode(dirPin_HR, OUTPUT);
  pinMode(stepPin_HR, OUTPUT);
  pinMode(enbl_HR, OUTPUT);


  //resett pin zustand definieren
  pinMode(PIN2RESET, INPUT);

  Serial.begin(115200);
  Serial1.begin(115200);
  Serial.println("code----- /home/georg/Arduino/outdoor_robo/smartphone_steuerung/outdoor_FB_switch_bluetooth_1.ino");

  Serial.println("bluetooth übertragung!");


  //enable pins deaktivieren:
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);

  //resett pin aktivieren
  digitalWrite(PIN2RESET, HIGH);
}

void loop()
{

  while (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    tasten_abfrage();
  }
}
/***********************************************************/

void tasten_abfrage(void)
{

  switch (taste)
  {

    case 100:// rotate rechts - FB quer smartphone
      {

        rechts_drehen();

        break;
      }


    case 97:// rotate links - FB quer smartphone
      {

        links_drehen();

        break;

      }


    case 116:// fahre vor - FB quer smartphone
      {

        vorwaerts();

        break;
      }


    case 115:// fahre rückwärts - FB quer smartphone
      {

        rueckwaerts();

        break;
      }
  }


}

/***********************************************************/
void alle_stepper_stop(void)
{
  //enable pins deaktivieren
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);
  reboot();
}

/***********************************************************/
void vorwaerts(void)
{

  // enable pins aktivieren:
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

  //richtung bestimmen
  digitalWrite(dirPin_VL, LOW);
  digitalWrite(dirPin_HL, LOW);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);



  for (int i = 0; i < stepsPerRevolution; i++)
  {
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(500);
  }
//  tasten_abfrage();
}


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

void rueckwaerts(void)
{

  // enable pins aktivieren:
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

  //richtung bestimmen
  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, LOW);
  digitalWrite(dirPin_HR, LOW);


  for (int i = 0; i < stepsPerRevolution; i++)
  {
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(500);
  }
//  tasten_abfrage();
}

/***********************************************************/
void rechts_drehen(void)
{

  // enable pins aktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

  //richtung bestimmen
  digitalWrite(dirPin_VL, LOW);
  digitalWrite(dirPin_HL, LOW);
  digitalWrite(dirPin_VR, LOW);
  digitalWrite(dirPin_HR, LOW);



  for (int i = 0; i < stepsPerRevolution; i++)
  {
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(500);
  }
//  tasten_abfrage();
}


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

void links_drehen(void)
{

  //enable pins aktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

  //richtung bestimmen
  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);


  for (int i = 0; i < stepsPerRevolution; i++)
  {
    digitalWrite(stepPin_VL, HIGH);
    digitalWrite(stepPin_HL, HIGH);
    digitalWrite(stepPin_VR, HIGH);
    digitalWrite(stepPin_HR, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin_VL, LOW);
    digitalWrite(stepPin_HL, LOW);
    digitalWrite(stepPin_VR, LOW);
    digitalWrite(stepPin_HR, LOW);
    delayMicroseconds(500);
  }
//  tasten_abfrage();
}

/*
  void links_drehen(void) //mit beschleunigung und sound
  {

  //enable pins aktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);

  //richtung bestimmen
  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);

  //"j = 2000": der Anfangswert für das Delay in Microsekunden

  for (int i = 0, j = 2000; i < stepsPerRevolution; i++)
  {

    //"j > 500": der Endwert für das Delay in Microsekunden - bestimmt auch die Endgeschwindigkeit (mindestens 250 bis 300)

    if (j > 300) j--;
    //"z < 3": wieviele Schritte mit dem eingstellten Delay "j" gemacht werden sollen, bevor es reduziert wird

    for (int z = 0; z < 3 && i < stepsPerRevolution; z++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(j);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(j);
      i++;
    }
  }
  }
*/
/***********************************************************/
void reboot()
{
  pinMode(PIN2RESET, OUTPUT);
  digitalWrite(PIN2RESET, LOW);
  delay(100);
}
/***********************************************************/

/************************************************************/
    bei meiner version habe ich die rekursiv - aufrufe in den einzelnen bewegungsfunktionen rausgenommen - und - das ist bei mir in ein wenig in vergessenheit geraten - die Stepper laufen mit mikrostepping, 1/8schritt, das bedeutet, dass ich die variable "StepsPerRevolution" auf 1600 anpassen muss. Dann laufen die Stepper je nach befehl vom smartphone genau eine umdrehung.

    Bei Deiner version verstehe ich einiges nicht. Dass Du in den einzelnen "richtungs"funktionen die richtungsdefinition nur einmal ablaufen lässt verstehe ich, auch den sinn der "s-* variablen" (vor, rück usw) ist klar.
    Bei einer änderung der zeile " StepsPerDirection = 200/4;" in 200 dreht der Stepper um 1/8 umdrehung, bei 200/4 war es 1/32 pro befehl vom smartphone. Wenn ich die zahl in 1600 ändere müsste doch der Stepper eine ganze umdrehung machen er dreht sich aber nur um einen 1/24stel. Wie kommt das?
    gruß inka
    ZitierenZitieren
  3. 26.12.2019, 17:43 #233
    Moppi
    Moppi ist offline
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.677
    Blog-Einträge
    1
    Bei einer änderung der zeile " StepsPerDirection = 200/4;" in 200 dreht der Stepper um 1/8 umdrehung, bei 200/4 war es 1/32 pro befehl vom smartphone. Wenn ich die zahl in 1600 ändere müsste doch der Stepper eine ganze umdrehung machen er dreht sich aber nur um einen 1/24stel. Wie kommt das?
    Die 200 sind auf Full Steps bezogen. Daran hatte ich schon gedacht, dass Du mit Microstepping arbeiten möchtest. Ich dachte, Du kannst das umrechnen, wenn Du einen anderen Step-Mode wählst. Wenn das bei 1/16tel sechszehn mal mehr Schritte pro Umdrehung sind, muss man die 200 mit 16 multiplizieren: 200*16/4,. Bei 1/8 wären das dann 200*8/4 (also: StepsPerDirection = 200*8/4. Theoretisch wäre das also mit 1600 richtig. Dann wären 1600/4, wieder ein Viertel. Wie dann jetzt 1/24stel rauskommt, verstehe ich nicht an der Stelle. Ich hoffe natürlich, dass der Code so weit fehlerfrei war, das kann ich schlecht ausprobieren (das wäre immer meine Kontrolle hinterher). Aber ich will gerne noch mal schauen. Dann stell den Code hier noch mal rein, wie der bei Dir 1/24stel Umdrehung macht.

    Habe gerade gesehen, oben steht der Code ...

    Mal eine grundsätzliche Frage: funktionierte dass denn vom Prinzip, mit den Änderungen, die ich angebracht habe?

    Dann entspräche dieser Code jetzt dem mit Mode 1/8 Step und das Rad müsste eine viertel Umdrehung machen, bis es steht:

    Code:
    // DIR und STEP pins definieren
#define dirPin_VL 6 //2
#define stepPin_VL 7 //3
#define dirPin_HL 8 //4
#define stepPin_HL 9 //5
#define dirPin_VR 2 //6
#define stepPin_VR 3 //7
#define dirPin_HR 4 //8
#define stepPin_HR 5 //9




//enable pins definieren
#define enbl_VL 40
#define enbl_HL 42
#define enbl_VR 41
#define enbl_HR 43




//resett pin definieren
#define PIN2RESET 10








//steps pro umdrehung definieren:
#define stepsPerRevolution 200








uint8_t taste_neu = 1;
uint8_t taste_alt = 8;
uint8_t taste = 0;




uint8_t s_vor = 0;
uint8_t s_rueck = 0;
uint8_t s_links = 0;
uint8_t s_rechts = 0;
uint8_t StepsPerDirection = 0;




void setup()
{
  //  pinMode(LED, OUTPUT);




  //pins als output:




  pinMode(dirPin_VL, OUTPUT);
  pinMode(stepPin_VL, OUTPUT);
  pinMode(enbl_VL, OUTPUT);
  pinMode(dirPin_HL, OUTPUT);
  pinMode(stepPin_HL, OUTPUT);
  pinMode(enbl_HL, OUTPUT);
  pinMode(dirPin_VR, OUTPUT);
  pinMode(stepPin_VR, OUTPUT);
  pinMode(enbl_VR, OUTPUT);
  pinMode(dirPin_HR, OUTPUT);
  pinMode(stepPin_HR, OUTPUT);
  pinMode(enbl_HR, OUTPUT);








  //resett pin zustand definieren
  pinMode(PIN2RESET, INPUT);




  Serial.begin(115200);
  Serial1.begin(115200);
  Serial.println("code----- /home/georg/Arduino/outdoor_robo/smartphone_steuerung/outdoor_moppi_FB_switch_bluetooth_1");




  Serial.println("bluetooth übertragung!");








  //enable pins deaktivieren:
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);




  //resett pin aktivieren
  digitalWrite(PIN2RESET, HIGH);
}




void loop()
{
  if (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    tasten_abfrage();
  }




  if ( StepsPerDirection > 0)
  {
        StepsPerDirection--;
        richtung_abfrage();
  }
}




/***********************************************************/
void richtung_abfrage(void)
{
  if (s_rechts == 1) rechts_drehen();
  if (s_links == 1) links_drehen();
  if (s_vor == 1) vorwaerts();
  if (s_rueck == 1) rueckwaerts();
}




/***********************************************************/
void tasten_abfrage(void)
{




  switch (taste)
  {




    case 100:// rotate rechts - FB quer smartphone
      {




        StepsPerDirection = 200*8/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200*8 Schritte
        rechts_drehen();




        break;
      }








    case 97:// rotate links - FB quer smartphone
      {




        StepsPerDirection = 200*8/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200*8 Schritte
        links_drehen();




        break;




      }








    case 116:// fahre vor - FB quer smartphone
      {




        StepsPerDirection = 200*8/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200*8 Schritte
        vorwaerts();




        break;
      }








    case 115:// fahre rückwärts - FB quer smartphone
      {




        StepsPerDirection = 200*8/4; //Nach 1/4 Radumdrehung Stillstand; weil pro Umdrehung = 200*8 Schritte
        rueckwaerts();




        break;
      }
  }








}




/***********************************************************/
void alle_stepper_stop(void)
{
  //enable pins deaktivieren
  digitalWrite(enbl_VL, LOW);
  digitalWrite(enbl_HL, LOW);
  digitalWrite(enbl_VR, LOW);
  digitalWrite(enbl_HR, LOW);
  reboot();
}




/***********************************************************/
void vorwaerts(void)
{
  if(s_vor == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);




      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);




      s_vor = 1;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}




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




void rueckwaerts(void)
{
  if(s_rueck == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);




      //richtung bestimmen
      digitalWrite(dirPin_VL, HIGH);
      digitalWrite(dirPin_HL, HIGH);
      digitalWrite(dirPin_VR, LOW);
      digitalWrite(dirPin_HR, LOW);




      s_vor = 0;
      s_rueck = 1;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}


/***********************************************************/
void rechts_drehen(void)
{
  if(s_rechts == 0)
  {
      // enable pins aktivieren
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);




      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, LOW);
      digitalWrite(dirPin_HR, LOW);




      s_vor = 0;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 1;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}








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




void links_drehen(void)
{
  if(s_links == 0)
  {
      //enable pins aktivieren
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);




      //richtung bestimmen
      digitalWrite(dirPin_VL, HIGH);
      digitalWrite(dirPin_HL, HIGH);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);




      s_vor = 0;
      s_rueck = 0;
      s_links = 1;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}




/*
  void links_drehen(void) //mit beschleunigung und sound
  {




  //enable pins aktivieren
  digitalWrite(enbl_VL, HIGH);
  digitalWrite(enbl_HL, HIGH);
  digitalWrite(enbl_VR, HIGH);
  digitalWrite(enbl_HR, HIGH);




  //richtung bestimmen
  digitalWrite(dirPin_VL, HIGH);
  digitalWrite(dirPin_HL, HIGH);
  digitalWrite(dirPin_VR, HIGH);
  digitalWrite(dirPin_HR, HIGH);




  //"j = 2000": der Anfangswert für das Delay in Microsekunden




  for (int i = 0, j = 2000; i < stepsPerRevolution; i++)
  {




    //"j > 500": der Endwert für das Delay in Microsekunden - bestimmt auch die Endgeschwindigkeit (mindestens 250 bis 300)




    if (j > 300) j--;
    //"z < 3": wieviele Schritte mit dem eingstellten Delay "j" gemacht werden sollen, bevor es reduziert wird




    for (int z = 0; z < 3 && i < stepsPerRevolution; z++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(j);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(j);
      i++;
    }
  }
  }
*/
/***********************************************************/
void reboot()
{
  pinMode(PIN2RESET, OUTPUT);
  digitalWrite(PIN2RESET, LOW);
  delay(100);
}
/***********************************************************/




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



    MfG





    - - - Aktualisiert - - -

    Außerdem kann man dann natrülich die "200*8" auch durch "StepsPerRevolution" ersetzen, wie hier, als Beispiel:

    Code:
    StepsPerDirection = StepsPerRevolution/4; //Nach 1/4 Radumdrehung Stillstand
    Geändert von Moppi (26.12.2019 um 17:35 Uhr)
    ZitierenZitieren
  4. 26.12.2019, 17:52 #234
    inka
    inka ist offline
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    78
    Beiträge
    2.180
    ich habe mir den code jetzt garnicht angeschaut, sondern copy/paste und geladen, ich muss 11x am smartphone drücken, bis die 360° erreicht sind...
    und nun ist der akku leer, muss also ca. 2h warten...

    edit:

    das hier

    Code:
    void loop()
{

  if (Serial1.available())
  {
    taste = Serial1.read();
    Serial.println(taste);
    //    taste_neu = taste;
    tasten_abfrage();
  }

  if ( StepsPerDirection > 0)
  {
    StepsPerDirection--;
    richtung_abfrage();
  }
}
    was genau wird damit erreicht? hauptsächlich die zweite if-abfrage...
    Geändert von inka (26.12.2019 um 18:11 Uhr)
    gruß inka
    ZitierenZitieren
  5. 26.12.2019, 18:26 #235
    Moppi
    Moppi ist offline
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.677
    Blog-Einträge
    1
    Zur ersten if-Abfrage:
    Du bist in der Funktion/Methode loop() innerhalb einer Schleife. Deshalb habe ich das ursprüngliche while von Dir entfernt und durch if ersetzt.

    Die zweite if-Abfrage sorgt dafür, dass die Stepper so lange in die angeforderte Richtung gedreht werden, wie dies in StepsPerDirection vorgegeben ist. Hier habe ich gedacht, dass eine viertel Umdrehung ein guter Wert wäre. Denn wenn Du die Fernbedienung drückst, "feuert" die ja nicht 200mal pro Sekunde (oder wie lange eine Radumdrehung dauert), sondern weniger. Hier muss man dann passende Werte finden, dass die Handhabung angenehm wird. Wenn für Dich 1 Radumdrehung pro Tastendruck angenehm ist, kannst Du natürlich aus der viertel Umdrehung eine Ganze machen (also: StepsPerDirection = StepsPerRevolution).

    Wenn Du 11 Mal Drücken musst, um eine Umdrehung zu erhalten, könnte man versuchsweise schreiben:     StepsPerDirection = StepsPerRevolution*11;
    Allerdings verstehe ich das mit den 11 Malen nicht, ich sehe darin keine Logik.


    MfG
    ZitierenZitieren
  6. 26.12.2019, 18:42 #236
    inka
    inka ist offline
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    78
    Beiträge
    2.180
    Zitat Zitat von Moppi Beitrag anzeigen
    Zur ersten if-Abfrage:
    Du bist in der Funktion/Methode loop() innerhalb einer Schleife. Deshalb habe ich das ursprüngliche while von Dir entfernt und durch if ersetzt.
    ok, die loop wird ja immer wieder durchlaufen, ist es aber nicht so, dass "if" nur einmal abgefragt wird und "while" so lange, bis ein bestimmtes ereignis eintrifft? Damit wollte ich erreichen, dass weitere anweisungen in der loop erst nach diesem ereignis ausgeführt werden...

    Zitat Zitat von Moppi Beitrag anzeigen
    Du die Fernbedienung drückst, "feuert" die ja nicht 200mal pro Sekunde (oder wie lange eine Radumdrehung dauert), sondern weniger. Hier muss man dann passende Werte finden, dass die Handhabung angenehm wird.
    Das eigentliche ziel war (und ist) einmal auf "vor" zu drücken und der roboter fährt so lange vorwärts, bis er einen andern befehl bekommt, oder halt ein anderer sensor meldet sich...

    Zitat Zitat von Moppi Beitrag anzeigen
    Wenn Du 11 Mal Drücken musst, um eine Umdrehung zu erhalten, könnte man versuchsweise schreiben:
    Zitat Zitat von Moppi Beitrag anzeigen
    StepsPerDirection = StepsPerRevolution*11; Allerdings verstehe ich das mit den 11 Malen nicht, ich sehe darin keine Logik.
    ich auch nicht...
    gruß inka
    ZitierenZitieren
  7. 26.12.2019, 19:05 #237
    Moppi
    Moppi ist offline
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.677
    Blog-Einträge
    1
    ist es aber nicht so, dass "if" nur einmal abgefragt wird und "while" so lange, bis ein bestimmtes ereignis eintrifft
    Ja, wenn die Abfrage so formuliert ist.
    "if" wird auch immer wieder geprüft (weil ja in "loop()"). Wenn dann ein Ereignis eingetreten ist, weil auf "Serial1" etwas "available" ist, wird das Ereignis abgearbeitet.

    Damit wollte ich erreichen, dass weitere anweisungen in der loop erst nach diesem ereignis ausgeführt werden...
    Passiert hier mit dem "if" genau so. Wenn keine Taste gedrückt wurde und also kein Ereignis vorhanden ist, bewegt sich auch kein Motor, es sei denn, die viertel oder ganze Umdrehung ist noch nicht fertig. Und wenn sich die Motoren in eine Richtung drehen, kannst Du eine andere Taste drücken und die Motoren bewegen sich praktisch sofort in die andere Richtung.

    Also eigentlich sollte das Programm dann das tun, was Du beabsichtigt hast. Und wie gesagt, das "while" erübrigt sich, weil Du in "loop()" bist und dieser Code darin immer wieder abgearbeitet wird.

    Daher macht

    Code:
    while(Serial1.available()){
...
}
    im Grunde dasselbe, wie

    Code:
    loop(){
    if(Serial1.available()){
    ...
    }
}
    Beides wird immer wieder abgearbeitet, wenn die Bedingungsprüfung für "Serial1.available()" positiv ausfällt.
    Wenn diese Prüfung negativ ausfällt, stoppt "while" nicht den Programmablauf in "loop()", bis ein Ereignis eintritt, sondern nur, solange eines da ist.
    Mit "if" passiert dasselbe. Nur dass es den Programmablauf nicht aufhält, solang Ereignisse vorhanden sind, sondern nur so lange, wie ein Ereignis abgearbeitet wird. Wenn beim nächsten Durchlauf in "loop()" festgestellt wird, dass immer noch oder wieder ein Ereignis vorhanden ist, wird das wieder abgearbeitet. Das geht dann so lange, bis kein Ereignis (also Zeichen auf Serial1) mehr vorhanden ist.


    MfG
    Geändert von Moppi (26.12.2019 um 19:22 Uhr)
    ZitierenZitieren
  8. 26.12.2019, 19:33 #238
    inka
    inka ist offline
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    78
    Beiträge
    2.180
    Zitat Zitat von Moppi Beitrag anzeigen
    Passiert hier mit dem "if" genau so. Wenn keine Taste gedrückt wurde und also kein Ereignis vorhanden ist, bewegt sich auch kein Motor, es sei denn, die viertel oder ganze Umdrehung ist noch nicht fertig. Und wenn sich die Motoren in eine Richtung drehen, kannst Du eine andere Taste drücken und die Motoren bewegen sich praktisch sofort in die andere Richtung.
    Also eigentlich sollte das Programm dann das tun, was Du beabsichtigt hast. Und wie gesagt, das "while" erübrigt sich, weil Du in "loop()" bist und dieser Code darin immer wieder abgearbeitet wird.
    das ist es ja - eben nicht. ich habe deine version von vorwärtes etwas geändert, von:
    Code:
    void vorwaerts(void)
{
  if(s_vor == 0)
  {
      // enable pins aktivieren:
      digitalWrite(enbl_VL, HIGH);
      digitalWrite(enbl_HL, HIGH);
      digitalWrite(enbl_VR, HIGH);
      digitalWrite(enbl_HR, HIGH);


      //richtung bestimmen
      digitalWrite(dirPin_VL, LOW);
      digitalWrite(dirPin_HL, LOW);
      digitalWrite(dirPin_VR, HIGH);
      digitalWrite(dirPin_HR, HIGH);


      s_vor = 1;
      s_rueck = 0;
      s_links = 0;
      s_rechts = 0;
  }
  else{
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
  }
}
    in:
    Code:
    void vorwaerts(void)
{
  if (s_vor == 0)
  {
    // enable pins aktivieren:
    digitalWrite(enbl_VL, HIGH);
    digitalWrite(enbl_HL, HIGH);
    digitalWrite(enbl_VR, HIGH);
    digitalWrite(enbl_HR, HIGH);

    //richtung bestimmen
    digitalWrite(dirPin_VL, LOW);
    digitalWrite(dirPin_HL, LOW);
    digitalWrite(dirPin_VR, HIGH);
    digitalWrite(dirPin_HR, HIGH);

    s_vor = 1;
    s_rueck = 0;
    s_links = 0;
    s_rechts = 0;

    for (int i = 0; i < stepsPerRevolution; i++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
    }
  }
  else

    for (int i = 0; i < stepsPerRevolution; i++)
    {
      digitalWrite(stepPin_VL, HIGH);
      digitalWrite(stepPin_HL, HIGH);
      digitalWrite(stepPin_VR, HIGH);
      digitalWrite(stepPin_HR, HIGH);
      delayMicroseconds(500);
      digitalWrite(stepPin_VL, LOW);
      digitalWrite(stepPin_HL, LOW);
      digitalWrite(stepPin_VR, LOW);
      digitalWrite(stepPin_HR, LOW);
      delayMicroseconds(500);
    }
}
    so macht sie eine umdrehung pro signal vom smartphone, wie meine ursprüngliche auch
    allerdings muss ich am ende der umdrehung für die nächste wieder drücken...
    gruß inka
    ZitierenZitieren
  9. 26.12.2019, 20:01 #239
    Moppi
    Moppi ist offline
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    18.03.2018
    Beiträge
    2.677
    Blog-Einträge
    1
    Du kannst es natürlich machen, wie Du es für richtig hältst. Ich verstehe Deine Intention, das sequentiell abarbeiten zu wollen. Das ist tendenziell für Beginner einfacher. Allerdings wirst Du später eventuell auf eine parallele Abarbeitung hinaus wollen oder müssen. Sequentielle Abarbeitung blockiert immer ein Programm und wird unübersichtlich, wenn man dies zu ändern versucht (indem man immer wieder kreuz und quer Funktionsaufrufe einstreut). Parallele Abarbeitung verfolgt dagegen den Ansatz, mehrere Aufgaben nebeneinander abzuarbeiten, übersichtlich und kontrolliert.

    Ich schlage (leider hier nicht zum ersten Mal) vor, einen Programmablaufplan zu erstellen. Gerade, wenn man nicht so den Überblick hat, ist das eine tolle Sache! Den dafür sind die sogenannten PAPs da: optisch einen Überblick über den Programmablauf zu verschaffen. Da erkennt man auch Probleme in der Programmabarbeitung.

    Ein Problem will ich noch bildhaft beschreiben, wenn Du die Programmierung in diesen Schleifen (for (int i = 0; i < stepsPerRevolution; i++)...) so aufrecht erhalten willst:

    Sollte der Roboter eine dreiviertel Umdrehung am Abgrund stehen und er fährt vorwärts, kannst Du ihn mit keiner Taste stoppen. Weil er erst den Abgrund hinunterstürzt, bevor er auf eine weitere Taste reagiert.



    MfG
    Geändert von Moppi (26.12.2019 um 20:10 Uhr)
    ZitierenZitieren
  10. 26.12.2019, 20:32 #240
    inka
    inka ist offline
    Erfahrener Benutzer Robotik Einstein Avatar von inka
    Registriert seit
    29.10.2006
    Ort
    nahe Dresden
    Alter
    78
    Beiträge
    2.180
    Lieber Moppi,
    wir schreiben aneinander vorbei , es geht nicht um parallel oder seriell, auch das mit der einer Umdrehung pro Smartphonesignal ist doch nur eine Hausnummer, die jederzeit geändert werden kann...
    Es geht um die Dauerbewegung nach nur einem Klick am Smartphone, das weiss ich nicht wie ich da hinkomme...
    morgen geht's weiter...
    gruß inka
    ZitierenZitieren
Seite 24 von 57 ErsteErste ... 14222324252634 ... LetzteLetzte
« Vorheriges Thema | Nächstes Thema »

Ähnliche Themen

  1. Abstandsmessung Outdoor bis 3m
    Von robo218 im Forum Sensoren / Sensorik
    Antworten: 4
    Letzter Beitrag: 14.12.2017, 07:56
  2. outdoor spy robot
    Von jancrombach im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 7
    Letzter Beitrag: 14.08.2010, 14:09
  3. Outdoor Roboter
    Von OsramLED im Forum Vorstellung+Bilder+Ideen zu geplanten eigenen Projekten/Bots
    Antworten: 3
    Letzter Beitrag: 07.08.2006, 10:34
  4. Outdoor-Robo
    Von RobotrixerP im Forum Mechanik
    Antworten: 3
    Letzter Beitrag: 16.04.2006, 19:38
  5. Outdoor - Navigation
    Von Quaio im Forum Sensoren / Sensorik
    Antworten: 37
    Letzter Beitrag: 21.04.2005, 13:31

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

Foren-Regeln


Labornetzteil AliExpress