ToF Sensor VL53L0X und CR -Servo FS5113R bekomme ich nicht zusammengeschrieben

Guten Tag,

Ich arbeite schon seit mehreren Wochen an einem Projekt, wo ich unteranderem den ToF Sensor VL53L0X und den Continuous Rotation Servo FS5113R benutze. Ich habe, bevor ich diesen Artikel hier schreibe, mich im Internet schlau gemacht, jedoch kaum Beiträge zu den beiden Teilen gefunden. Ich hoffe ihr könnt mir da etwas helfen, denn ich habe auch in den Arduino Foren nachgeschaut, jedoch nichts passendes gefunden.

Mein Problem ist folgender:
Ich möchte mithilfe dem Sensor Daten an den Servo übermitteln, sodass dieser entweder CW oder CCW dreht, dabei in einem Bereich von ... bis ... . Das Problem ist nur, ich habe keine Ahnung, wie ich den Servo in meinen Sketch einbauen kann.

Ich bin trotz der ganzen Recherchen immer noch ein ziemlicher Anfänger und danke für jede Hilfe , die ich bekomme.

Grüßend,
Julian

Hallo @julian_k ,

willkommen im Arduino-Forum.
du hast im englischen Forum auf deutsch gepostet. Es gibt ein deutsches Unterforum wo in deutsch geschrieben werden darf/soll.

Diese Beschreibung ist noch zu ungenau als das man einen konkreten Code-Vorschlag machen könnte.

dabei in einem Bereich von ... bis ... . Bereich von was?
Das hört sich beinahe an wie "drehe Servo um einen Winkel von "X" Grad und dann soll das Servo auf dieser Winkelstellung stehen bleiben.

Ein continious-rotation servo zeichnet sich dadurch aus das es genau NICHT auf einem exakten Winkel stehen bleibt.
continious-rotation zu deutsch kontinuierlich drehend (zig tausende Umdrehungen)

Ein continious-rotation servo kann nur mit unterschiedlichen Geschwindigkeiten (sich drehen lassen oder es still stehen lassen. Wobei die exakte Position beim stehen bleiben nicht vorhergesagt werden kann.

Zuerst: Du kannst hier im Forum hunderte Fragen stellen. Manche threads hier sind bei Posting 537 + X
Das ist völlig in Ordnung so viele Fragen zu stellen.
Wenn man seine Fragen schnell und immer wieder neue Fragen beantwortet haben will dann muss eigenes dazulernen hier im Forum erkennbar sein.

Davon das du schreibst

Und du postest keinen Code, dann glaubt man dir dieses "wochenlange arbeiten" nicht so richtig.
Nach mehreren Wochen solltest du doch zumindest einen Demo-Code entweder zum ToF-Sensor oder zum Servo erfolgreich auf den microcontroller geflasht haben.

Also poste den Code den du hast. Es ist vollkommen OK wenn der Code noch nicht compiliert.
Es geht einfach darum das du
a.) Durch Code posten nachweist was du bis jetzt selbst gemacht hast
b.) man durch den Code dann sehr genau sehen kann an welcher Stelle es hängt.

Deine Anfrage oben ist ungefähr so wie wenn du bei der Tourist-Info anrufst
"Ich habe Hunger auf was italienisches lösen sie dieses Problem!" Ende der deiner Anfrage
ganz viele Details unklar

  • Wie teuer?
  • nach Hause liefern, Fertiggericht einkaufen ? (wo?) oder ins Restaurant gehen?
  • welches Restaurant?
  • welches Gericht Pizza, Nudeln, Fisch, Fleisch, Käse?
  • was zu trinken dazu?
  • Tisch reservieren?
  • Wie viele Personen kommen mit?
  • welche Uhrzeit?

Also:
Detail-Infos anliefern

  • welcher Microcontroller?
  • Datenblatt zum ToF-Sensor
  • Datenblatt zum Servo
  • Demo-Code den du benutzt hast
    als Code-Section posten in dem du vor dem Einfügen des Codes den </>-Button klickst
    vgs

Hallo Nochmal,

Danke StefanL38 für die Bemerkungen. Tut mir leid, habe vergessen den Code, den ich aktuell dazu benutze, hochzuladen. Kommt gleich.

Also ich benutze den Arduino UNO R3 mit den Atmega328P
Hier ist einmal das Datenblatt zum Servo:
(FeeTech FS5113R Servo Specifications and Reviews)
(Hochladen kann ich nicht, bin noch neuer Benutzer)

und hier das Datenblatt zum Sensor:
https://www.st.com/resource/en/datasheet/vl53l0x.pdf

Beim Code möchte ich nur eins vorweg nehmen. Er ist nur teils fertig, besonders bezogen auf den Sensor und ist leider nicht kommentiert. Ich hoffe das macht keine Probleme.

#include <Wire.h>
#include <VL53L0X.h>
#include <Servo.h>

VL53L0X sensor;
// Die Addresse vom Sensor heißt 41(0x29), die ist wahrscheinlich
// wichtig, um die Daten von A4 übermitteln zu können. 
//Dazu muss über der I2C Schnittstelle diese angefunkt werden und 
// soll dann diese abgeben können.

#define Long_Range 

//#define RANGESTARTMM 30
//#define RANGEENDMM 320

Servo servo;

int pos = 0;
//const unsigned int Interrupt_Pin = 2
const int SensorPin = A4;
const int ServoPin = 9;
const int minPulse = 900;
const int maxPulse = 2100;
const int periode = 30;
int aktPulse; 


void setPos(int winkel) {
  aktPulse = map(winkel, -180,180,minPulse,maxPulse);
}

void setServoPosition(){
  static int old = -1;
  if (aktPulse != old) {
    Serial.println(aktPulse);
    old = aktPulse;
  }
  digitalWrite(ServoPin, HIGH);
  delayMicroseconds(aktPulse);
  digitalWrite(ServoPin, LOW);
  delay(periode);
}


void setup(){
  Serial.begin(9600);
  Wire.begin();
  pinMode(ServoPin, INPUT_PULLUP);
  setPos(120);
  pinMode(A4, OUTPUT);

  sensor.setTimeout(500);
  if (!sensor.init()){
    Serial.println(" Nicht Gefunden ");
    while (1) {}
    sensor.setMeasurementTimingBudget(100000);
  }
#if defined Long_Range
sensor.setSignalRateLimit(0.1);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 20);
sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 15);
#endif
}

void loop(){
Serial.print(sensor.readRangeSingleMillimeters());
if (sensor.timeoutOccurred()) {Serial.print(" TIMEOUT "); }
Serial.println();
setServoPosition();



if( A4 >= pos, pos 


}

/*if(digitalRead(distanz) == minPulse){
  servo.attach(9);
  servo.write(i+1);
  delay(20);
  servo.detach();
}
 if(digitalRead(distanz)== maxPulse){
servo.attach(9);
servo.write(i-1);
delay(20);
servo.detach();
}
else{Serial.println(" out of Range ");
}*/

Nebenbei noch gesagt: Ich weiß, dass ein continuous rotation Servo NICHT auf einen genauen Winkel gehen kann, sondern nur bis dahin dreht und dann unendlich weiterdreht. Das ist ja auch das, was ich haben will.
Der Servo soll so ähnlich wie ein Kran arbeiten, der das Seil entweder verlängert oder verkürzt - nur bei mir sieht der Kran aus wie ein "T" und zieht halt auf beiden Seiten.

Entschuldigt mich, wenn ich das mit dem Erstellen nicht hinbekommen habe, wird das nächste mal nicht vorkommen.

MFG Julian

OK
Ich habe mir das Servo angeschaut
56g Gewicht
Drehmoment 12,5 kgcm

Das ist ein recht kräftiges Servo.
Das kann man auf gar keinen Fall aus dem 5V-Anschluss des Arduinos versorgen.
Da geht der Spannungsregler des Arduino sofort in die Knie und macht einen Reset.
Für dieses Servo brauchst du eine separate Spannunsversorgung mit 2A besser 3A

Wenn du den Sensor gleich volle Lotte im Programmbenutzen willst dann hast du folgende Fehlermöglichkeiten gleichzeitig

  1. Sensor geht nicht
  2. Sensor falsch initialisiert
  3. Sensor an die falschen IO-Pins angeschlossen
  4. Programmlogik Sensor Messwert-Abfragen hat einen Fehler
  5. Servo falsch initialisiert
  6. Servo an den falschen IO-pin angeschlossen
  7. Programmlogik des Servos hat einen Fehler

Und jetzt möchtest du durch herumprobieren herausfinden wo der Fehler steckt?
Dauert ewig.

const int SensorPin = A4; // was für ein Sensor?
const int ServoPin = 9;   
// das Servo soll ein Signal gesendet bekommen = OUTPUT
// aber du definierst den ServoPin als Eingang mit Pullup-widerstand
pinMode(ServoPin, INPUT_PULLUP); 
pinMode(A4, OUTPUT);

da würdest du besser schreiben

pinMode(SensorPin, OUTPUT);

Du hast einen Sensor (welcher Sensor soll das sein?) Sensoren liefern Signale an
Das heisst werden als INPUT definiert aber du definierst OUTPUT

Wenn es der VL53L0X sein soll. Der hat ein I2C-interface. Da muss man auch per I2C-Interface mit dem Sensor kommunizieren.

Ich war ungenau in meiner Anfrage: Datenblatt vom VL53L0X-Sensor das hast du gepostet.
Aber vermutlich benutzt du nicht den Winzigsensor alleine sondern der Sensor ist auf eine Platine aufgelötet. Wir brauchen das Datenblatt vom ganzen VL53L0X-Modul

Da wird dann auch die I2C-Adresse angegeben sein.

Der erste Schritt:
Prüfen ob der VL53-Sensor selbst funktioniert. Nur den VL53-Sensor an den I2C-Bus des Arduino Uno anschließen und zuerst mal einen funktionierenden Demo-Code hochzuladen der einfach nur den Messwert des VL53-Sensors im seriellen Monitor anzeigt.

I2C-Bus sind die Anschlüsse A4 SDA und A5 SCL
.
.
Das gleiche mit dem Servo machen
Servo als einziges an den Arduino anschließen und einen funktionierenden Demo-Code laden und testen ob sich das Servo bewegt.

Dann verändert man den Demo-Code in kleinen Schritten und testet sofort wieder
Dann verändert man den Demo-Code in kleinen Schritten und testet sofort wieder
Dann verändert man den Demo-Code in kleinen Schritten und testet sofort wieder

Du hast die Zeilen die etwas mit der Servoansteuerung zu tun haben auskommentiert

  servo.attach(9);
  servo.write(i+1);

Das geht in die richtige Richtung enthält aber Fehler.
Wenn du von einem funktionierenden Servo-Demo-Code aus startest dann sollte das Servo funktionieren

Hi,

Tatsächlich habe ich grundsätzlich zwei Codes, die ich benutzen kann, wenn ich die Teile jeweils einzeln ansteure. Die Library für den Sensor ist die von POLULU und ich habe erst den "Single" Sketch genutzt, um Daten zu empfangen. Benutze jetzt aber den "Continuous" Sketch, da ich die Daten eh ununterbrochen empfangen will, soweit alles gut.

Hier der Single Sketch:

/* This example shows how to get single-shot range
 measurements from the VL53L0X. The sensor can optionally be
 configured with different ranging profiles, as described in
 the VL53L0X API user manual, to get better performance for
 a certain application. This code is based on the four
 "SingleRanging" examples in the VL53L0X API.

 The range readings are in units of mm. */

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;


// Uncomment this line to use long range mode. This
// increases the sensitivity of the sensor and extends its
// potential range, but increases the likelihood of getting
// an inaccurate reading because of reflections from objects
// other than the intended target. It works best in dark
// conditions.

//#define LONG_RANGE


// Uncomment ONE of these two lines to get
// - higher speed at the cost of lower accuracy OR
// - higher accuracy at the cost of lower speed

//#define HIGH_SPEED
//#define HIGH_ACCURACY


void setup()
{
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init())
  {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

#if defined LONG_RANGE
  // lower the return signal rate limit (default is 0.25 MCPS)
  sensor.setSignalRateLimit(0.1);
  // increase laser pulse periods (defaults are 14 and 10 PCLKs)
  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);
  sensor.setVcselPulsePeriod(VL53L0X::VcselPeriodFinalRange, 14);
#endif

#if defined HIGH_SPEED
  // reduce timing budget to 20 ms (default is about 33 ms)
  sensor.setMeasurementTimingBudget(20000);
#elif defined HIGH_ACCURACY
  // increase timing budget to 200 ms
  sensor.setMeasurementTimingBudget(200000);
#endif
}

void loop()
{
  Serial.print(sensor.readRangeSingleMillimeters());
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

  Serial.println();
}

Hier der Continuous Sktech:

/* This example shows how to use continuous mode to take
range measurements with the VL53L0X. It is based on
vl53l0x_ContinuousRanging_Example.c from the VL53L0X API.

The range readings are in units of mm. */

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup()
{
  Serial.begin(9600);
  Wire.begin();

  sensor.setTimeout(500);
  if (!sensor.init())
  {
    Serial.println("Failed to detect and initialize sensor!");
    while (1) {}
  }

  // Start continuous back-to-back mode (take readings as
  // fast as possible).  To use continuous timed mode
  // instead, provide a desired inter-measurement period in
  // ms (e.g. sensor.startContinuous(100)).
  sensor.startContinuous();
}

void loop()
{
  Serial.print(sensor.readRangeContinuousMillimeters());
  if (sensor.timeoutOccurred()) { Serial.print(" TIMEOUT"); }

  Serial.println();
}

Beim Servo kann ich aktuell nur das Beispiel "KNOB" verwenden ,wenn ich ihn in die eine Richtung drehen lassen will oder in die andere.
Kann ich auf diese aufbauen oder ist da ein anderes Beispiel besser ? Und für den benutze ich eine externe Stromquelle mit rund 6V, der reagiert da auch, spackt aber manchmal rum, könnte sein, dass ich das ground nicht mit dem Arduino verbunden habe ?

Ich stelle hier mal den Link rein für die Seite, woher ich den Sensor eigentlich habe. Daran kann man auch sehen, welche Stifte der Sensor eigentlich besitzt.
www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/vl53l0x-time-of-flight-tof-laser-abstandssensor-teil-1

Ich habe mich vor allem beim Sensor erkundigt, wie das mit dem I2C funktioniert und ob ich die Pins GPIO1 und XSHUT benötige. Für mein Verständnis brauche ich XSHUT nur,wenn ich den Sensor an und ausmachen will, so grob gesagt.
GPIO1 ist ein Interrupt Pin und habe mich auch dort gefragt, ob ich den nutzen könnte. In einem Beitrag stand dann jedoch drinne, dass es grundsätzlich eigentlich nur da ist, die Daten zu messen, wenn er in den Interrupt Pins 2 oder 3 beim UNO steckt, und wenn man diesen rausnimmt, er nichts mehr liefert.
Weiterhin habe ich was mit Adressen gelesen. Brauche ich das? Weil darauf wollte ich aufbauen, aber komme spätestens dann beim Servo nicht weiter.

Und danke für die Erklärungen, da ist dann aber die Frage, ob ich die Daten vom Sensor über die SDA Pin, also analog A4 lesen kann und weiterleiten kann. Im Grunde ist die SDA Stelle ja da, die Signale auszugeben.

Ich werde mich auf jedenfall die Woche dransetzen und zeigen, ob sich was getan hat.

MFG Julian

Der ToF-Sensor den du da hast ist ein liefert

digitale

Daten über den I2C-Bus.
Die IO-pins eines Arduino Uno haben meistens mehrere Funktionen.
So ist das auch bei IO-Pin A4 und A5.
Man kann die A0,A1,A2,A3,A4,A5 pins als Analogeingänge verwenden
Speziell A4 und A5 haben einen zweiten Verwendungszweck:

Digitale Daten nach I2C-Standard senden / empfangen
Der I2C-Bus hat zwei Leitungen. Deswegen brauchst du

immer beide IO-pins

A4 als SDA und A5 als SCL verwenden

Der Single-Sketch und der Continuos-Sketch liefern dir nur dann Messwerte wenn du den ToF-Sensor so angeschlossen hast. Fritzing-Bilder sind ja hier im Forum total verpönt aber ichhabe auf die Schnelle kein anderes Bild gefunden. Und ausnahmsweise kann man auf diesem Fritzing-Bild auch erkennen was wichtig ist

Also dein ToF VX53L01-Sensor ist

digital

und wird per I2C-Bus abgefragt.
Dazu verwendet man die VL53L0X-library die durch die Code-Zeile

#include <VL53L0X.h>

eingebunden wird.
Dadurch kann man den vom Sensor gemessenen Abstand dann mit den Befehlen wie im single- bzw. continuous-sketch Sketch auslesen
vgs

Okay, also das mit digital pins war mir noch nicht so klar, aber danke. Also kann ich Mithilfe digitalRead in einem if-Befehl die Daten theoretisch an den servo Pin( bei mir pin 9) senden?
Wenn ja, dann frage ich mich nur, wie ich das genau eingrenzen soll, denn der sensor liefert mir Werte von rund 20 bis 330 mm. Ich hätte hier jetzt an den Befehl map() gedacht. Geht das damit?

MFG Julian

Mit Verlaub das ist ziemlicher Quark den du schreibst; ausser das mit der map()-function

Nein !

Die Codezeile

VL53L0X ToFsensor;

definiert ein VL53L0X-Objekt

Zum Einlesen des Abstandes der vom ToF-Sensor kommst benutzt du die
ganzen Funktionsaufrufe
ToFsensor.XXXXXXXXX

Wobei XXXXXXXXX die jeweiligen functions meint
zum Konfigurieren des Sensors
.setTimeout(500);
.setSignalRateLimit(0.1);
.setVcselPulsePeriod(VL53L0X::VcselPeriodPreRange, 18);

und dann zum Einlesen des gemessenen Abstandes
.readRangeSingleMillimeters();

Jetzt muss ich doch einmal ganz explizit fragen:

Liest du eigentlich die Demo-Codes ? und versuchst du die einzelnen Code-Zeilen zu verstehen?
oder bastelst du dir eine Vorstellung die losgelöst von den Programmzeilen ist?

  • vom ToF-Sensor gemessen Abstand in eine Variable einlesen

  • Diesen Zahlenwert per map()-Funktion in einen Winkel umwandeln.

  • und dann die Servo-library und die entsprechenden function-calls der Servo-library benutzen
    um das Steuersignal für das Servo zu erzeugen

Das ist aber kein

sondern durch den function-call

myservo.write()

wird eine dem Winkel entsprechende Impulsdauer gesetzt.
Die Servo-library erzeugt dann fortlaufend impulse für das Servo

Das Knob-Beispiel kommt dem was du brauchst einigermaßen nahe.
Und an der Stelle ist es jetzt Zeit, dass du den Knob-Beispielcode

Zeile für Zeile

verstehen lernst.
Ohne dieses Basiswissen wie zum Beispiel was macht eine code-Zeile wie

#include <Servo.h>

was macht eine Zeile wie

myservo.attach(9);

wirst du alle 5 Minuten neu im Forum nachfragen müssen.
Wie mache ich denn jetzt X
wie mache ich denn jetzt Y
wie mache ich denn jetzt Z

Um nicht mißverstanden zu werden. Du kannst im Forum hunderte Fragen stellen.
So lange man dabei Lernfortschritt bei dir erkennen kann ist alles in Butter.

Nur Fragen in der Art
"funktioniert nicht" Und jetzt?
darauf gibt es schon auch eine Antwort aber eine die von dir einfordert

  • genaue Beschreibung des Code-Verhaltens,
  • deinen aktuellen Sketch
  • und eine spezifische Frage .

ganz im Stil wie

vgs

Sorry für die Fragerei, dass hängt alles leider mit den ganzen Recherchen zusammen, die mich da doch ganz verrückt gemacht haben.
Ich nehme deine Begründungen zu Herzen und lese mir das alles nochmal Genau durch.
Melde mich bei Neuigkeiten.

MFG Julian

Eine Code-zeile lesen
Das ist das erste Drittel.
Das zweite Drittel ist dich selber zu fragen habe ich das jetzt wirklich verstanden?
Das dritte Drittel ist dann

  • entweder die Antwort "ja"
    oder
  • eine spezifische Frage zu genau der einzelnen Code-Zeile die du (noch) nicht verstehst

Was macht die Code-Zeile

#include <Servo.h>

?
poste deine Antwort oder deine Vermutung verbunden mit einer Frage
.
.
was macht die Code-Zeile

int potpin = A0; 

poste deine Antwort oder deine Vermutung verbunden mit einer Frage
usw.
usw.

Abend,

Hier bin ich wieder.

Ich habe die Woche mal an den beiden Beispielen gearbeitet und das heute in einen Sketch zusammengetragen. Leider fehlte mir die Zeit gänzlich und es könnte erstmal etwas mickrig aussehen. Ich habe in dem Code jetzt alles kommentiert, was dort passiert bzw. es eigentlich macht.

tippe oder füge den Cod/*Dieser Sketch wird hoffentlich der letzte, überarbeitende Code
 * sein. Der Sketch wird für die Ansteuerung eines Sensors, den 
 * ToF( Time-of-Flight) VL53L0x über die I2C Schnittstelle, sowie 
 * einem Continuous Rotiation Servo FS5113R Servo verwendet. Servo 
 * kommt von Feetech und Sensor von Az-delivery. 
 * 
 * Ersteller:Julian Kroier
 * Datum:23.1.2023
 * 
 * Änderungen sind gerne möglich und auch notwendig, um den Code 
 * zum laufen zu bekommen.
 * 
 * Codes sind einmal Continuous von Polulu 
 * sowie das Knob Beispiel bei Servo
 */



#include<Servo.h>         //Fügt die Servo-Bibliothek ein
#include<Wire.h>          //Fügt die "Wire"-Bibliothek ein
#include<VL53L0X.h>       //Fügt die Sensor-Bibliothek"VL53L0X" ein

VL53L0X Sensor;           //definiert den Sensor VL53L0X als "Sensor"

Servo myservo;            //definiert den Servo als "myServo"; es können bis zu 12 Servos eingebunden werden

const int Potipin = A0;   //setzt eine konstante Variable für den Potentiometer, der an Pin A0 angeschlossen wird 
int val;                  //setzt eine Variable mit den Namen val(Value, zu Deutsch "Betrag")
                          
void setup() {            //öffnet eine Befehlreihe, dessen Code nur einmal durchlaufen wird
  
  Serial.begin(9600);     //startet die Serielle Kommunikation, also übermittelt Daten mithilfe der Übertragunsrate 9600 Baud 
                          //an den Seriellen Monitor(oben rechts die Lupe)
                          
  Wire.begin();           //beginnt mit der BUS-Kommunikation als Master über die SDA(A4) und SCL(A5) Pins

  Sensor.setTimeout(500);   //befehlt Sensor, eine halbe Sekunde zu warten bzw. stellt eine Wartezeit ein
  if(!Sensor.init()) {      //sagt dem Sensor, dass wenn die Initialisierung nicht erfolgreich erfolgt, über den Monitor den Satz unter der Schleife ausgibt
    Serial.println(" Fehler beim finden und initialisieren des Sensors!"); // gibt dem Benutzer bescheid, dass der Arduino den Sensor nicht gefunden hat
    while(1) {}       
  }
  Sensor.startContinuous();   //gibt dem Sensor den Befehl, fortlaufend und ununterbrochen Daten zu lesen und diese über den Seriellen Monitor anzuzeigen
                              // Start continuous back-to-back mode (take readings as
                              // fast as possible).  To use continuous timed mode
                              // instead, provide a desired inter-measurement period in
                              // ms (e.g. sensor.startContinuous(100)).

 myservo.attach(9);            // gibt an, dass der Servo an Pin 9 angeschlossen ist (PWM-Pin)                            
}

void loop(){
  Serial.print(Sensor.readRangeContinuousMillimeters());    //gibt über den Seriellen Monitor die gelesenen Werte an(in mm)
  if (Sensor.timeoutOccurred()) {Serial.print("TIMEOUT");}   // wieder eine Schleife, der befehlt, dass wenn der Sensor für eine gewisse Zeit auf LOW, gesetzt ist, also keine Spannung hat, 
                                                            //über den Seriellen Monitor schreibt "TIMEOUT". Ist besonders auffliig gewesen, als Sensor und Servo eine Stromquelle benutzt haben.
  Serial.println();      // schreibt über den Seriellen Monitor die ganze Zeit die gemessenen Daten vom Sensor 

  val = analogRead(Potipin);    //beschreibt die Variable als neue Funktion, analogRead soll die analogen Daten über den Poti messen
  Serial.println(val);          //schreibt eine neue Zeile, wo die analogen Werte des Poti´s übermittelt werden
  val = map(val, 0, 1023, 0, 180);  //map-Funktion, die die gegebenen analogen Werte(0-1023) in digitale Werte(0-180) umwandelt
  myservo.write(val);           //liefert die Daten, welche durch die map-Funktion in digitale Werte umgewandelt wurden, an den Servo
}

Ich habe nicht viel rumexperimentiert, aber ich weiß beim Kompilieren, dass es funktioniert.
Wäre es möglich, dass ihr mal da drüber schaut und wo man anfangen könnte, etwas zu ändern?
Ansonsten melde ich mich bei Neuigkeiten.

MFG Julian

Hallo Julian,

die meisten Erklärungen sind richtig. Es gibt hie und da etwas merkwürdige Formulierungen und ein paar falsche Vorstellungen was in der jeweiligen Code-Zeile gemacht wird.

if(!Sensor.init()) { //sagt dem Sensor, dass wenn die Initialisierung nicht erfolgreich erfolgt, über den Monitor den Satz unter der Schleife ausgibt
Serial.println(" Fehler beim finden und initialisieren des Sensors!"); // gibt dem Benutzer bescheid, dass der Arduino den Sensor nicht gefunden hat

Dem Sensor wird nichts gesagt. Der Bibliotheks-Code meldet, dass das ansprechen des Sensors nicht funktioniert hat = es kam keine Antwort vom Sensor.

myservo.attach(9); // gibt an, dass der Servo an Pin 9 angeschlossen ist (PWM-Pin)

sagt der Servo-Library erzeuge das Servosteuersignal am Pin 9.
Dem Programm ist dabei vollkommen wurscht ob das Servo nun angeschlossen ist oder nicht

if (Sensor.timeoutOccurred()) {Serial.print("TIMEOUT");} // wieder eine Schleife, der befehlt, dass wenn der Sensor für eine gewisse Zeit auf LOW, gesetzt ist, also keine Spannung hat,

keine Schleife! . Eine If-Bedingung wird abgearbeitet und das war es dann.
If-bedingungen können sich aber selbstverständlich innerhalb einer Programm-Schleife befinden
und nur durch diese Tatsache, dass sich eine if-bedingung innerhalb einer Schleife befindet wird die if.bedingung wiederholt ausgeführt. Aber bei jedem Schleifendurchgang nur exakt einmal

Serial.println(); // schreibt über den Seriellen Monitor die ganze Zeit die gemessenen Daten vom Sensor

Schreibt einfach nur einen Zeilenvorschub sonst nichts!
Wenn ein function-call Serial.println() etwas schreiben soll dann muss das was geschrieben werden soll zwischen den Klammern stehen
Serial.println("Hallo Welt");
schreibt Hallo Welt in den seriellen Monitor

val = analogRead(Potipin); //beschreibt die Variable als neue Funktion, analogRead soll die analogen Daten über den Poti messen

Ruft die function analogRead() auf die je nach Potistellung einen Zahlenwert zwischen 0 und 1023 zurück gibt. Dieser Zahlenwert wird in der Variable names "val" gespeichert

myservo.write(val); //liefert die Daten, welche durch die map-Funktion in digitale Werte umgewandelt wurden, an den Servo

Benutzt den Zahlenwert der in der Variable namens "val" gespeichert ist und weist den Servo-library-code an den Zahlenwert als Servoposition in Grad zu benutzen.

Wenn die Variable "val" den Zahlenwert 140 enthält
könnte man salopp sagen "steuere Servoarm auf 140 Grad"

Was in deinem Code jetzt noch überhaupt nicht vorkommt ist irgendein Versuch auch nur eine einzige Zeile hinzuzufügen wie der Wert der Abstandsmessung benutzt werden könnte um
die Position des Servoarms davon steuern zu lassen.

Es ist nicht so wichtig dass diese von dir geänderte Code-Version compiliert.
Das wirklich wichtige ist, dass DU SELBST anfängst darüber nachzudenken wie das gehen KÖNNTE. Und dann mit einer hochspezifischen Frage zu deiner Code-Änderung im nächsten Posting eine Frage stellst.
Dabei lernst du am meisten. Außerdem kann man dann an deiner Antwort am besten sehen welche Dinge kannst du schon und welche noch nicht. Und WIE muss man etwas ergänzend erklären damit du es richtig verstehst.

Von mir wirst du NIEMALS einen vorgekauten Code dazu bekommen. Über andere kann ich natürlich nicht bestimmen.

vgs

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.