INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 1 Bewertungen - 5 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Lenk-Korrektur berechnen (Koordinaten)
16.03.2017, 17:01 (Dieser Beitrag wurde zuletzt bearbeitet: 16.03.2017 18:31 von Binatone.)
Beitrag #9
RE: Lenk-Korrektur berechnen (Koordinaten)
Jawoll, Arne...
So hab ich das auch diese Tage schonmal durchdacht

Jetzt hab ich die theoretischen Punkte, klar soweit.
Mein Fahrzeug fährt in etwa in die Richtung
Jetzt lieg ich aber nicht exakt auf der Soll Linie sondern sag ich mal 12 Punkte daneben.

Wäre ich jetzt gerade aus im Koordinatensystem, also Y hat sich um 100 Punkte erhöht und X soll gleich bleiben, hat sich aber um 12 Punkte verkleiner, liege ich um 12 Punkte links daneben.

Arbeite ich aber schräg, sagen wir 45 Grad, verzerrt sich mein Bild entsprechend.

Hoffe, ich hab mich verständlich ausgedrückt Sad

Binatone

Edit:
Ich fürchte, ich hab mir das einfacher vorgestellt, als es ist.
Ein Plotter oder eine CNC Fräse wird über X und Y Verfahren.
Wenn sich X 200 mal gedreht hat und Y in der gleichen Zeit 100 mal und beide Achsen sich die ganze Zeit gleich schnell gedreht haben, hab ich den Kopf linear aber schräg verfahren.

Das ist einfacher.

Hier brauch ich einen ganz anderen Ansatz:

Wie wäre es damit:

Ich messe Punkt 1 und dann Punkt 2
Aus diesen Punkten errechne ich einen Winkel.
Diesen Winkel vergleiche ich mit dem Winkel aus meiner A/B Linie.
Abweichung? = erste Korrektur.

Jetzt rechne ich noch aus, ob ich mit dem zweiten Punkt links oder rechts von der A/B Linie bin - zweite Korrektur.

Jetzt muss ich die beiden Korrekturwerte noch kombinieren (addieren?)

Daraus könnte ich einen neuen Lenkwinkel berechnen.
Denke ich hier zu kompliziert oder bin ich noch auf dem richtigen Weg?

Binatone

sooo

Ich hab noch etwas die Suchmaschinen belästigt,in der Hoffnung, das Rad nicht neu erfinden zu müssen.

Hier wurde ich aufmerksam:

GPS GUIDED AUTONOMOUS ROBOT


Und ab hier der Code, der auf deren Seite veröffentlicht ist.
Den werd ich mir mal zu einer stillen Stunde langsam durch den Kopf gehen lassen.
(Hier wird direkt mit den GPS Daten gearbeitet, die werden aber mittels Faktoren auf Meter geändert, dann sind wir wieder in einem "Koordinatensystem")



Code:
#include <LiquidCrystal.h>
#include <TinyGPS.h>
#include <Wire.h>

//wire pins are in my board( Mega2560)    20 (SDA), 21 (SCL)
#define address 0x1E //0011110b, I2C 7bit address of HMC5883
TinyGPS gps;
#define rxPin 19 // to yellow wire in my gps
#define txPin 18

bool feedgps();

int echoPin = 9; // pingpin to Digital 8
int trigPin = 8; // inpin to Digital 9
int SAFE_ZONE = 10;

//Motor direction control pin def
#define right1 22
#define right2 24
#define left1 26
#define left2 28
#define pwm_left 13
#define pwm_right 12

LiquidCrystal lcd(6 ,7 ,2 ,3, 4, 5); // define our LCD and which pins to user

void setup()

{
  lcd.begin(20, 4); // need to specify how many columns and rows are in the LCD unit



  Serial.begin(9600);
  delay(100);                   // Power up delay

  Serial.println("THULANA VIMUKTHI ABEYWARDANA");
  Serial.println("Kotelawala Defence University");
  Serial.println("Department of Electrical and Electronic Engineering");
  Serial.println("====================================================");
  Serial.println("                                                     ");
  Serial1.begin(9600);

  Wire.begin();

  Serial1.print("$PMTK314,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29\r\n");
  Serial1.print("$PMTK220,200*2C\r\n");

  // Set operating mode to continuous in compass
  Wire.beginTransmission(address);
  Wire.write(byte(0x02));
  Wire.write(byte(0x00));
  Wire.endTransmission();

  pinMode(left1, OUTPUT);//LEFT  
  pinMode(left2, OUTPUT); //LEFT
  pinMode(right1, OUTPUT); //R
  pinMode(right1, OUTPUT); //R
  pinMode(pwm_left, OUTPUT); //LEFT
  pinMode(pwm_right, OUTPUT); //R
  pinMode(echoPin, OUTPUT);
  pinMode(trigPin, INPUT);

}

inline void setDir(bool L1, bool L2, bool R1, bool R2){
  digitalWrite(left1,L1);//L
  digitalWrite(left2,L2);//L
  digitalWrite(right1,R1);//R
  digitalWrite(right2,R2);//R
}

void forward()
{
  setDir(0,1,0,1);
  analogWrite(pwm_left,200);//L
  analogWrite(pwm_right,255);//R
}

void Backward()
{
  setDir(1,0,1,0);
  analogWrite(pwm_left,200);//L
  analogWrite(pwm_right,255);//R
}


void search()
{
  setDir(0,1,1,0);
  analogWrite(pwm_left,255);//R
  analogWrite(pwm_right,255);//L

}

void Stop()
{
  setDir(0,0,0,0);
  analogWrite(12,0);//L
  analogWrite(13,0);//R
}

void right()
{
  setDir(1,0,0,1);
  analogWrite(pwm_left,255);//L
  analogWrite(pwm_right,255);//R
}

void left()
{
  setDir(0,1,1,0);
  analogWrite(pwm_left,255);//L
  analogWrite(pwm_right,255);//R
}
long getDistance(){
  long duration;
  long cm;
  digitalWrite(echoPin, LOW);
  delayMicroseconds(2);
  digitalWrite(echoPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(echoPin, LOW);
  duration = pulseIn(trigPin, HIGH);
  return duration / 29 / 2;
   Serial.print(cm);
  Serial.print("cm");
}

void loop(){

  long cm=getDistance();
  feedgps();
  getDistance();


  unsigned char cc = Serial1.read();
  float flat, flon,x2lat,x2lon;
  unsigned long age;
  gps.f_get_position(&flat, &flon, &age);

  feedgps();
  getDistance();

  float flat1=flat;     // flat1 = our current latitude. flat is from the gps data.
  float flon1=flon;  // flon1 = our current longitude. flon is from the fps data.
  float dist_calc=0;
  float angle_calc=0;
  float dist_calc2=0;
  float diflat=0;
  float diflon=0;
  x2lat=  6.81820011      ;  //enter a latitude point here   this is going to be your waypoint(here KURUNEGALA)
  x2lon= 79.89105987    ;  // enter a longitude point here  this is going to be your waypoint
  //------------------------------------------ distance formula below. Calculates distance from current location to waypoint

  dist_calc=sqrt((((flon1)-(x2lon))*((flon1)-(x2lon)))+(((x2lat-flat1)*(x2lat-flat1))));
  dist_calc*=110567 ; //Converting to meters
  //=======================angle==========================================
  angle_calc=atan2((x2lon-flon1),(x2lat-flat1));

  float declinationAngle2 = 57.29577951;
  angle_calc*= declinationAngle2;
  feedgps();
  getDistance();

  if(angle_calc < 0){
    angle_calc = 360 + angle_calc;
    feedgps();
    getDistance();
  }
  // Check for wrap due to addition of declination.
  if(angle_calc >0){
    angle_calc= angle_calc;
    feedgps();
    getDistance();
  }

  float angleDegrees = angle_calc;
  feedgps();
  //this is compass code==================================      
  int x, y, z;
  feedgps();
  getDistance();

  // Initiate communications with compass
  Wire.beginTransmission(address);
  Wire.write(byte(0x03));       // Send request to X MSB register
  Wire.endTransmission();

  Wire.requestFrom(address, 6);    // Request 6 bytes; 2 bytes per axis
  if(6<=Wire.available()) {    // If 6 bytes available
    x = Wire.read()<<8; //X msb
    x |= Wire.read(); //X lsb
    z = Wire.read()<<8; //Z msb
    z |= Wire.read(); //Z lsb
    y = Wire.read()<<8; //Y msb
    y |= Wire.read(); //Y lsb
    feedgps();
    getDistance();
  }

  float heading = atan2(y,x);
  float declinationAngle = 0.0457;
  heading += declinationAngle;
  feedgps();
    getDistance();

  // Correct for when signs are reversed.
  if(heading < 0){
    heading += 2*PI;
    feedgps();
    getDistance();
  }

  // Check for wrap due to addition of declination.
  if(heading > 2*PI){
    heading -= 2*PI;
    feedgps();
    getDistance();
  }

  float headingDegrees = heading * 180/M_PI;
  feedgps();
  getDistance();

  //================================LCD
  lcd.setCursor(0,0);
  lcd.print("E");
  lcd.print(flat,5);

  lcd.setCursor(10,0);
  lcd.print("N");
  lcd.print(flon,5);

  lcd.setCursor(0,1);
  lcd.print("d:");
  lcd.print(dist_calc,2);



  lcd.setCursor(0,2);
  lcd.print("H:");
  lcd.print(headingDegrees,2);

  lcd.setCursor(10,2);
  lcd.print("A:");
  lcd.print(angleDegrees,2);


  //==================================



  feedgps();
  getDistance();
  Serial.print("Lat: ");
  Serial.print(flat,8);
  Serial.print(", Long: ");
  Serial.println(flon,8);
  Serial.println("distance");
  Serial.println(dist_calc,8);    //print the distance in meters
  //compass========================================  
  Serial.print("Heading:\t");
  Serial.print(headingDegrees);
  Serial.println(" Degrees   \t");
  Serial.print(angleDegrees);
  Serial.println(" Degrees   \t");
  Serial.print(cm);
  Serial.print("cm");
  Serial.println("                 ");
  delay(500);


  // Take actions ==================================      
  bool condition = ((angleDegrees -10) < headingDegrees) && ((angleDegrees +10) > headingDegrees);  
  if(condition){    //condition == true?
    Serial.println("MOVE");
    lcd.setCursor(5,3);
    lcd.print("   MOVE   ");
    feedgps();
    getDistance();
    forward();
    long stTime = millis();
    while(millis()-stTime < 4000){
      getDistance();
      feedgps();
      if(getDistance() == 10)
      {
        feedgps();
        getDistance();
        Serial.println("OBS FORWARD");
        Serial.println("                 ");
        lcd.setCursor(5,3);
    lcd.print("OBS FORWARD");
        feedgps();
        getDistance();
        Stop();
         myDelay(1000);  //*** what to do if obstacle detected  
        feedgps();
        getDistance();
        Backward();
         myDelay(500);
        feedgps();
        getDistance();
        right();
         myDelay(800);
        feedgps();
        getDistance();
        forward();
         myDelay(2000);
        feedgps();
        getDistance();
        left();
         myDelay(800);
        feedgps();
        getDistance();
        forward();
       // break;              //*** get out of while loop

      }
      else{
      forward();
      }
      feedgps();
      getDistance();
      
    }
  }

  if(SAFE_ZONE>cm){    //obstacle in range?
    
   Serial.println("OBS");
Serial.println("                 ");
lcd.setCursor(5,3);
    lcd.print("    OBS     ");
    feedgps();
        getDistance();
        Stop();
         myDelay(1000);  //*** what to do if obstacle detected  
        feedgps();
        getDistance();
        Backward();
         myDelay(500);
        feedgps();
        getDistance();
        right();
         myDelay(800);
        feedgps();
        getDistance();
        forward();
         myDelay(2000);
        feedgps();
        getDistance();
        left();
         myDelay(800);
        feedgps();
        getDistance();
        forward();
      
  }

  if(dist_calc<4)
  {
    feedgps();
    getDistance();
    Stop();
    lcd.setCursor(4,3);
    lcd.print("   STOP   ");
    Serial.println("      stop    ");
  }
  
/* if(flon==1000 && flat==1000 )
  {
    feedgps();
    Stop();
    lcd.setCursor(4,3);
    lcd.print("  NO SAT  ");
     Serial.println("NO SAT");
  }
  */

  else {
    lcd.setCursor(5,3);
    lcd.print("SEARCHING");
    search();
    feedgps();
    getDistance();
    delay(20);
    Stop();
    feedgps();
    getDistance();
    delay(30);
  }  

}


void myDelay(long duration){
  long stTime = millis();
  while(millis() - stTime <duration){
    feedgps();
    delay(1);
  }
}


static bool feedgps()        
{
  while (Serial1.available())
  {
    if (gps.encode(Serial1.read()))
      return true;
  }
  return false;
}


Ich hab den Code mal 1:1 so gelassen, wie er ist.
Dann kann man ihn vielleicht auch mal selbst testen.

Ich selbst werde ihn wohl nur in Bruchteilen nutzen, die ganzen LCD fallen schonmal raus, ebenso der Ultraschall-Abstand-Sensor z.B.
Der GPS-Input kommt bei mir auf andere Weise und noch so einige andere Dinge.

Aber der Kern dürfte interessant werden Smile

Binatone
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
16.03.2017, 18:33
Beitrag #10
RE: Lenk-Korrektur berechnen (Koordinaten)
Vielleicht ist das Vorhaben kompliziert?
Vielleicht denkst du auch zu kompliziert? Jedenfalls kann ich deinen Gedanken nicht so einfach folgen.
Vielleicht bist du mit deinen Gedanken auch schon weiter voraus als ich in meiner Vorstellung?

Wie wäre es denn wenn du eine Skizze machst?
Zeichne ein einfaches Koordinatensystem.
x von 0 bis ? Meter und y von 0 bis ? Meter.
Drehe die Skizze so dass die y-Achse nach Norden zeigt und Zeichne grob die Umrisse der Wiese ein. Zeige diese Skizze hier, dann kann man sich viel besser vorstellen was dein Plan ist.
Dann musst du immer wissen wo den dein "Schaf" steht. Wie willst du denn den aktuellen Standort ermitteln und mit welchem Messfehler rechnest du bei der Standortbestimmung?
Gibt es Bäume oder andere Hindernisse auf dem Gelände?

Gruß
Arne

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.03.2017, 12:55
Beitrag #11
RE: Lenk-Korrektur berechnen (Koordinaten)
Das Programm aus #9 müsste man auch erst mal verstehen bevor man des anpassen kann. Confused

Mal angenommen der "RaMä" fährt auf einer horizontalen Linie von links A nach rechts B.
Wenn er jetzt etwas oberhalb die Linie ist, muss er nach rechts lenken um wieder auf die Spur zu kommen.
Fährt er jetzt zurück von rechts B nach links A und ist oberhalb der Linie muss er nach links lenken um wieder auf die Spur zu kommen.
Ich vermute es wird erst mal einfacher wenn man bei der Lenkbewegung nicht in rechts/links denkt sondern in Himmelsrichtung. Dann muss man für beide o.g. Fälle immer nach Süden lenken. !!

Ich hatte mal mit einem GPS-Empfänger in Verbindung mit der TinyGPS++ Library gespielt. Neben den Koordinaten (Latitude u. Longitude) liefert die u.A. auch "Speed in meters per second" und "Course in degrees".
Der Wert für Speed ist eher uninteressant aber "Course in degrees" könnte für den RaMä verwertbar sein. "Course in degrees" gibt dabei den Winkel in Grad vom aktuellen Standort zu einem vorher festgelegten Zielpunkt an.
Wie verwertbar das alles ist kann man nur in einem Praxistest ermitteln.

Was dann noch dazu kommt ist die für eine genaue Berechnung von Koordinaten eigentlich zu geringe Anzahl von signifikanten Stellen bei den Arduino Floatingpointroutinen. Der Uno/Mega hat nur 6 bis 7 brauchbare Stellen und das ist eigentlich zu wenig wenn eine Koordinate 48.85826 lautet und sich an der letzten Stelle etwas ändert. (32 Bit float)
An der Stelle müsste man dann wohl etwas tricksen und z.B. die ersten 3 bis 4 Stellen verwerfen weil die sich auf der Rasenfläche vermutlich eh nicht ändern.
Oder auf einen Arduino ZERO oder einen Arduino Due ausweichen. Ich glaube die rechnen float in 64 Bit.

Gruß
Arne

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.03.2017, 13:29
Beitrag #12
RE: Lenk-Korrektur berechnen (Koordinaten)
Ja, einfach ist das Ganze sicher nicht, aber Raketenwissenschaft ist es auch nicht...
Und selbst wenn, hatten die Amis in den 70ern auch keine leistungsfähigere Rechentechnik als heute im Mega verfügbar ist z.B.

Floats kann man doch einfach umgehen, wenn ich die Koordinaten nicht als "normale" GPS Daten in die Berechnung einfließen lasse, sondern sie im Vorfeld bereits in unsigned long Ganzzahl in Zentimeter umrechne.
Dies kann sogar mit einem anderen Arduino erfolgen, der "von links" die GPS Daten bekommt und "nach rechts" die fertigen Koordinaten als Punkte im Zentimeter Raster über UART an den zweiten Arduino weitergibt.
Ob das sein muss, sei dahingestellt, aber so könnte man die Rechenleistung etwas aufteilen, falls Essenz wird.

Und dann haben wir noch den ESP8266 bzw. das NodeMCU Board, welches um einiges leistungsfähiger ist, als ein Arduino... Wink

Binatone
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.03.2017, 14:04
Beitrag #13
RE: Lenk-Korrektur berechnen (Koordinaten)
Raketenwissenschaft ist das sicher nicht, aber für mich ist die GPS nach Lenkbewegungsberechnung auch neu und ich habe damit keine Erfahrung.

Die Berechnung müsste vermutlich lauten:
Wo bin ich im Moment
Wo sollte ich sein
Wie komme ich dort hin

Man müsste den Weg von A nach B also in viele kleine Abschnitte unterteilen und für jeden dieser Abschnitte obige Berechnung anstellen und das Ergebnis vom RaMä ausführen lassen.
Die sinnvolle Länge eines dieser Abschnitte hängt von der Genauigkeit der Positionsbestimmung ab. Wenn die Positionsbestimmung nur ±1m beträgt macht es keinen Sinn die Abschnitte auf 0,5m festzulegen.

Die Floats kann man nicht so einfach umgehen. Auch nicht mit einem zweiten Arduino der GPS in Meter und Zentimeter umrechnet. Wenn dieser zweite Arduino auch nur ein 8 Biter ist der Float mit 32 Bit berechnet wird es nicht genauer.
Wenn der zweite Arduino ein ZERO oder DUE ist der Float mit 64 Bit berechnet kann er auch gleich die ganze Arbeit machen und man spart einen Arduino und die Kommunikation zwischen beiden.

Ich kenne die ESP8266 und NodeMCUs nicht. Weiß nur dass die viel Programmspeicher haben und schneller rechnen können. Ich weiß aber nicht mit wie vielen signifikanten Stellen deren float Rechnungen daher kommen.

Interessant wäre mal zu wissen welche Stelle in einer GPS-Koordinaten welche Wegdifferenz bedeutet.
Mal angenommen die Koordinate 48.85826 wäre relativ der Punkt 0m. Wieviel Meter wäre dann die Koordinate 48.85827, also die letzte Stelle um 1 erhöht?
Und dann müsste man noch wissen wie viele Nachkommastellen liefert der GPS Empfänger überhaupt. Sind es wie im Beispiel 48.85826 fünf Nachkommastelle oder sind es mehr?

Gruß
Arne

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
18.03.2017, 14:49
Beitrag #14
RE: Lenk-Korrektur berechnen (Koordinaten)
Ich hab mich vor etwa 2 Jahren das erste mal damit befasst.
Nun müsste ich die alten Notitzen mal wieder rauskramen, bin aber grad mit dem Schweißgerät an ner anderen Sache am flicken.
(Marlboro-Time mit Stupidphone)

Was ich aber noch weis, ist das im Norden Deutschland bei den Breitengraden pro Grad (und demnach auch an 8ter Nachkommastelle) ein deutlich kleinerer Wert herauskommt, als z.B. in Bayern.
Unsere Erde ist halt rund und kein Würfel.

Nord/Süd hingegen ist überall gleich.


Sollte ich diese Arbeit mit der Brutzelkiste heute zügig durch haben, kann ich am Rechner nochmal nach Verhältnis Grad zu Meter/Zentimeter schauen..

Aber ein herzliches Dankeschön ist hier schonmal angebracht Wink

Binatone
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.03.2017, 08:13
Beitrag #15
RE: Lenk-Korrektur berechnen (Koordinaten)
Sodenn...
Hier kann man wunderbar rechnen

Ich hab mal die Entfernung von Punkt A / B
A= 52.0000 8.0000
B= 52.0001 8.0000

berechnen lassen:
11 Meter

Will man also im Dezimeter-Bereich kalkulieren, muss man sich wohl an 6ter bis 7ter Nachmommastelle orientieren.

Binatone
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
19.03.2017, 13:05 (Dieser Beitrag wurde zuletzt bearbeitet: 19.03.2017 14:50 von ardu_arne.)
Beitrag #16
RE: Lenk-Korrektur berechnen (Koordinaten)
Hi,
der Onlinerechner ist gut gemacht.
Ich hatte gestern mit GoogleEarth etwas gespielt und bin auch auf ca. 11m für die 4. Stelle hinter dem Komma bei der geogr. Breite gekommen.
Bei der Länge sieht es, wie du schon geschrieben hast, etwas anders aus. Die 4. Stelle hinter dem Komma bedeutet im Süden von DE etwa 7,5m und im Norden etwa 6,5m.

Dann habe ich mein GPS Modul am Arduino mal wieder aktiviert und den Arduino mit den empfangenen Daten etwas rechnen lassen.
Den GPS-Empfänger habe ich unter einem Dachfenster positioniert und sehe dort ständig 7 bis 11 Satelliten. Der Empfänger hängt dort ruhig und bewegt sich nicht.
Der Arduino ermittelt für die Länge und die Breite über längere Zeit jeweils den kleinsten und den größten Wert. Die Differenz zwischen dem kleinsten und dem größten Wert habe ich dann mit den o.g. 11m und 7m multipliziert.
Die Messung läuft jetzt seit ca. 1 Stunde.
Für die Breite habe ich in dieser Zeit Sprünge von 33m empfangen und für die Länge von 7m. Undecided
Für einen RaMä der die Spur auf ±0,5m halten soll wäre das also ungeeignet.
Ich weiß jetzt nicht ob mein GPS-Modul so schlecht ist (u-blox NEO-6M) oder ob man mit einfachen Mitteln nicht mehr erwarten kann. Ein Teil der Abweichungen sind wohl auch der begrenzten Auflösung der float Rechnungen im UNO geschuldet.

Gruß
Arne

Kleiner Nachtrag nach einigen Stunden Laufzeit des Testprogramms.
max Streuung für die Breite 47m
max Streuung für die Länge 32m

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Kalenderwoche berechnen torsten_156 3 388 15.03.2017 15:38
Letzter Beitrag: Tommy56
  Prüfsumme berechnen Bus83 3 461 05.02.2017 12:43
Letzter Beitrag: Tommy56
  Gewichteten Durchschnitt berechnen, 20 Werte in fortlaufender Variable speichern TimeMen 10 1.823 03.07.2016 09:00
Letzter Beitrag: Binatone
  Korrektur - Schaltungsproblem Clubsport 0 577 18.09.2015 16:53
Letzter Beitrag: Clubsport
  Umwandlung von Koordinaten Matthias Wehrli 5 1.441 22.11.2014 17:32
Letzter Beitrag: itAxel
  Aluminium-Block, Wärmemenge berechnen Cray-1 9 2.960 31.10.2014 19:40
Letzter Beitrag: Cray-1
  H-Brücke für Anwendung berechnen Cray-1 20 4.526 14.10.2014 19:56
Letzter Beitrag: Cray-1

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste