(Erledigt) LCD mit HC-SR04 Formel einbinden?

Hallo Leute,

die Tage bekomme ich einen Arduino Duo mit LCD und HC-SR04.
(Servo ist schon da)

Die Sachen sind für Festeinbau gedacht.

Hab mir so was ausgedacht:
Der Entfernungssensor misst einen Abstand und regelt den Servo passend zu.
Am ´Display sollte auch was erscheinen, da ist aber etwas schwerer :wink:

Kann ich ein Wert als "Nullpunkt" einstellen?
Von da aus sollte der HC-SR04 den Radius messen aber auf dem
Display brauche ich Angabe als Umfang.

Also als Beispiel der Sensor misst 40cm, das sollte jetzt "Nullpunkt" sein.
Der Sensor misst 30cm also haben wir da 10cm Radius.

Dann müsste automatisch die Formel durch gerechnet werden: u = 2 x ? x r

So in etwa: 2 x ? x 10cm = 62,83cm

Auf dem Display sollte erscheinen: Umfang ca. 62,83cm

Was denkt Ihr ist das realisierbar? Den Code habe ich mir als Beispiel angesehen:

#include  

LiquidCrystal lcd(11, 10, 9, 4, 5, 6, 7);

int pingPin = 13;
int inPin = 12;

void setup() {
lcd.begin(16, 2);
lcd.print("testing...");
}

void loop()
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, inches, cm;

  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(pingPin, LOW);

  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(inPin, INPUT);
  duration = pulseIn(inPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
  cm = microsecondsToCentimeters(duration);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(inches);
  lcd.print("in, ");
  lcd.print(cm);
  lcd.print("cm");

  delay(100);
}

long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;

da hab ich ne kleines Fehler bei der Formel gemacht Undecided.

So sollte es in dem Code berechnet werden:

(Nullpunkt - Gemessener Wert) x 2 x 3,1415

in Zahlen:

(40 - 30) x 2 x 3,1415 = das Ergebnis sollte jetzt auf dem Display erscheinen.

Jemand ne Idee wie ich das in den Code einbauen könnte?

Danke schön

Dürfte ich mal fragen wofür du die Rechnung machst? Also mir erschließt sich nicht der sinn bzw. ich vermute das du was anderes haben willst als du errechnest.

Hallo,

na klar kann ich es dir erklären.

Der Sensor wird Festmontiert, runden Formen werden immer an gleicher Stelle
angesetzt. Die haben allerdings verschiedene umfänge. Und die will ich auch ermessen.

Also muss ich ein mal die Mitte der Formen herausfinden, oder eher den Wert der Entfernung eintragen.
Wenn wie gesagt eine Form angesetzt wird, ist der gemessene Abstand zu dem Sensor geringer.

Sagen wir mal Mitte der Formen ist 40cm, der Sensor misst bei einer Form 30cm.
Also hätte die Form einen Radius von 10 cm (40 mitte minus 30 Entfernung)

Und aus den 10cm Radius muss ich Umfang der Form errechnen, die Formel steht quasi oben im ersten Post.

Also muss ich eine "Nullpunkt" eingeben von da den Radius errechnen und daraus den Umfang.

Hoffe es war jetzt verständlich genug.

Danke übrigens für die Hilfe :wink:

Hallo,

Du kannst die Formen auch einseitig (an einer Kante) anschlagen, dann den Abstand messen und daraus die Größe und den Umfang berechnen.

Hi,

schön das es geht. Hättest du ein Beispiel für mich?

Das wäre super.

Danke schön.

Hallo Leute,

ich klinke mich noch mal hier rein.
Wie würde die Codezeile für so eine Formel aussehen?

Danke schön

Was für eine FOrmel genau meinst Du ? :roll_eyes:

Hi,

immer noch die gleiche:

(40-gemessener Wert) x 2 x 3.1415= Ergebnisse an den

Display senden.

Also:

(40-30) x 2 x 3.1415 =

Mhm, ich weiss jetzt nicht ob wir uns da genau verstanden haben:
Du möchtest von runden Gegenständen den Durchmesser ermitteln um daraus was zu berechnen.

Wenn Du also in einer Messumgebung den Sensor LINKS hast (nach rechts zeigend) kannst Du die Gegenstände RECHTS an einer Leiste anschlagen und dann den (ja bekannten) Abstand bis zu dieser Kante MINUS dem aktuell gemessenen Wert des Gegenstandes misst - daraus kannst Du dann einfach den Radius (Differenz / 2) und alles mögliche Andere berechnen

Hi,

ja genau das will ich machen :).

Weiß jetzt nicht wie das einbinden soll, den ich muss doch mal "pi" berechnen 3,14 bla bla bla...
Für ein Beispiel wäre ich sehr dankbar.

Gruß

z.B.:

  • Abstand vom Sensor bis Kante = 500 mm
  • Durchmesser des aktuell gemessenen Gegenstands = 120 mm
int PIN_Entferungssensor = A0;
int Entfernung_Kante = 500;
int Entfernung_aktuell = 0;
int Durchmesser_aktuell = 0;

Entfernung_aktuell = analogRead(PIN_Entferungssensor); //  = 380 mm

Serial.print("Aktueller Abstand     = ");
Serial.println(Entfernung_aktuell);

Durchmesser_aktuell =  (Entfernung_Kante - Entfernung_aktuell);    // = 120 mm
Serial.print("Aktueller Durchmesser = ");
Serial.println(Durchmesser_aktuell);

So in etwa sollte das aussehen - Umfang usw. berechnen kannste ja wohl alleine, da gibbet Formeln im Netz zu.

power-dodge:
Weiß jetzt nicht wie das einbinden soll, den ich muss doch mal "pi" berechnen 3,14 bla bla bla...

Pi mußt du doch nicht berechnen.

const float PI = 3.1415926;

er meinte bestimmt MIT Pi rechnen: r * Pi 8)

A.R.Ty:
er meinte bestimmt MIT Pi rechnen: r * Pi 8)

Na gut, wenn du meinst, dass er das gemeint haben könnte:

const float PI = 3.1415926;
float A, r;
A = r * r * PI;

:roll_eyes:

Bei manchen Usern finde ich anstrengend zu erraten, was sie eigentlich gemeint haben könnten.
power-dodge, sei doch mal etwas weniger einsilbig.

power-dodge, sei doch mal etwas weniger einsilbig.

Jau, Menno - immer her mit den Infos, um so weniger Rückfragen und um so schneller und überhaupt... :fearful:

hi,

die einsilbigkeit ist es ja nicht, es ist nur verwirrend, daß power-dodge seit seinem ersten post die richtige formel reinschreibt, aber immer wieder fragt, wie er es berechnet...

bin immer noch nicht sicher, ob wir sein problem richtig verstanden haben.

gruß stefan

Hallo,

sorry fals ich mich falsch ausgedrückt hab.

Ich will verschieden Zylinder messen (Umfang).

Der Mittelpunkt wird festgesetzt , nehmen wir mal ein Beislpiel von 400mm.
Der Sensor misst eine Entfernung von 300mm. Also kann ich jetzt daraus den Radius errechnen.
400-300=100mm. Und daraus eben den Umfang. (Umfang = 2 * pi * Radius)

Daher die Klammern:

(400-300) x 2 x 3,1415 = Umfang : 628.319mm

Deswegen die Formel, im Klammer zu erst danach der rest.

Von mir aus kann man ach so schreiben wenn Ihr das besser verstehen könnt:

(a-b) mal 2 mal pi = Umfang

Damit habe ich leider schwirigkeite, dies in den Code einzubinden, mein Code übrigens:

void loop() {
  
  int duration;
  float  distance;
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(1000);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 2.91;
 
    Serial.print(distance,0);
    Serial.println(" mm");

wäre nett wenn jemand mir das mal zeigen könnte.

Danke

Es gibt übrigens ein fertige Pi Konstante in math.h
http://www.nongnu.org/avr-libc/user-manual/group__avr__math.html

Die heißt M_PI

Du hast doch schon alles. Du kannst die Formel einfach so in den Code übernehmen:

float Mittelpunkt = 400;  
int duration;
float  distance, Umfang;

void loop() {
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(1000);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2.0) / 2.91;
  Umfang = (Mittelpunkt -distance) * 2 * PI;
 
    Serial.print(distance,0);
    Serial.println(" mm");
    Serial.print(Umfang,0);    
    Serial.println(" mm Umfang");

Edit: ich habe gerade gemerkt, dass die Arduino IDE PI schon kennt, kann man garnicht declarieren!

Hi,

cool das müsste es sein. Hab gerade alles auseinander gebaut.
Moin teste ich das mal.

Sieht aber vielversprechend aus :slight_smile:

Danke schön :wink: