Posts by Shaq

Shaq · Oct 11th 2019

Hallo zusammen,

ich habe folgende Projektidee und wollte Fragen, ob jemand damit schon mal Erfahrung gemacht hat oder ob dies Überhaupt in dem Rahmen möglich ist.

Zum Projekt:

Ich möchte gerne einen fahrenden Roboter bauen, welcher die folgenden Eigenschaften besitzt.

- Fahren ohne Fernsteuerung im Nachgang (autonomes Fahren). Das heißt man soll Ihn einmal um den Umriss der Fläche steuern können mit Festlegung von Start und Endpunkt. Nach Beendigung dieser fahrt, soll er sich ein Koordinatensystem innerhalb dieser Fläche anlegen und jeden punkt mindestens einmal anfahren. Dies soll jedoch kreuz und quer geschehen und nicht in einer bestimmten Reihenfolge. (Als Beispiel, Mähroboter etc.).

- Erkennung von Gegenständen in der Umgebung mittels Lidar und Ultraschallsensor.

LG

Shaq

Shaq · Jul 16th 2018

Das hat mich einfach mal interessiert. Da ich mich des Öfteren mit den Geräten auseinandersetze was deren Funktionsweise betrifft und ich mich gefragt habe ob die alle in der selben Sprache programmiert werden oder es eine Inhouse Sprache ist.

LG

Bastelstube

Shaq · Jul 16th 2018

Hallo zusammen,

konnte mich nun lange Zeit nicht mehr dazu äußern, da ich momentan mitten im Studium bin. Das Projekt hat momentan auch ein wenig Stillstand dadurch und wird in den nächsten Wochen wahrscheinlich weiter voran getrieben. Dazu werde ich mich aber dann noch einmal äußern.

Momentan nur eine kleinere Zwischenfrage da ich mir nicht sicher bin.

Professionelle Mähroboter werden doch in C/C++ programmiert oder?

LG

Bastelstube

Shaq · Apr 9th 2018

Quote from Eisbergsalat

Um etwas konkreter zu werden hab 2x1TB wo von ich beide im Raid1 laufen lassen will. Bzw falls andere Ideen, wie ich am einfachsten eine Backupplatte mache, gerne her damit. Kenne mich da auch nur begrenzt aus. Problem ist ja beim Raid das jedweder Fehler/Lösung etc sofort übertragen wird, oder?

Ein Raid ist kein Backup. Um ein sauberes Backup deiner Daten zu machen nimm am besten noch eine dritte Festplatte. Auf diese Platte sicherst du dann die Daten aus dem Raid.

LG

Bastelstube

Shaq · Apr 9th 2018

Das Ausgangsproblem ist, dass bei dem Code aus Beitrag #145 etwas nicht funktioniert, was sich meigrafd auch nicht erklären kann.

Zunächst einmal was passieren sollte:

Momentan habe ich zwei HC-SR04 Sensoren angebracht. Diese messen beide den jeweiligen Abstand. Wenn der linke Sensor nun merkt das die Distanz kleiner 15cm ist, so wird ein pivot_right()ausgeführt (Ein Rad dreht sich vorwärts und das andere Rückwärts). Das gleiche soll passieren, wenn der rechte Sensor merkt, dass die Distanz unter 15cm ist, dann soll ein pivot_left()ausgeführt.

Was passiert nun:

Es funktioniert immer nur eine Funktion. Wenn ich einen Gegenstand vor den rechten Sensor halte wird pivot_left()ohne Probleme ausgeübt. Mache ich das gleiche beim linken Sensor, so dreht sich immer nur ein Rad und das andere bleibt stehen.

Was wurde bisher unternommen:

- Sensoren getauscht um auszuschließen, dass einer defekt ist (negativ)

- Alles entkabelt und neu verkabelt (negativ)

- Neue Batterien in das Akkupack eingebaut (negativ)

- Funktionen im Code getauscht (negativ)

Nun zu dem was meigrafd meinte.

Laut Beitrag #144 habe ich das Scipt nicht mit python3 ausgeführt. Dies habe ich dann im Anschluss gemacht. Mir ist jedoch nicht ersichtlich welchen Fehler meigrafd meint, der beim ausführen mit python3 auftreten soll.

LG

Bastelstube

Shaq · Apr 4th 2018

#push

Shaq · Mar 26th 2018

Das wäre die Ausgabe zum Script:

Python

pi@raspberrypi:~ $ sudo python3 MotorTest.py
Distance: 164.36 cm
Distance: 102.22 cm
Motor: forward
Distance: 165.34 cm
Distance: 104.05 cm
Distance: 166.71 cm
Distance: 107.57 cm
Distance: 166.59 cm
Distance: 107.67 cm
Distance: 94.02 cm
Distance: 174.00 cm
Motor: pivot_left
Distance: 97.38 cm
Distance: 6.60 cm
Distance: 165.95 cm
Distance: 5.45 cm
Distance: 97.69 cm
Distance: 12.50 cm
Motor: forward
Distance: 165.88 cm
Distance: 101.64 cm
Motor: pivot_right
Distance: 6.31 cm
Distance: 88.09 cm
Distance: 6.26 cm
Distance: 92.22 cm
Distance: 6.21 cm
Distance: 166.12 cm
Motor: forward
Distance: 166.98 cm
Distance: 85.00 cm
Distance: 164.90 cm
Distance: 85.60 cm
^CProcess Process-5:
Traceback (most recent call last):
  File "/usr/lib/python3.5/multiprocessing/process.py", line 249, in _bootstrap
    self.run()
  File "/usr/lib/python3.5/multiprocessing/process.py", line 93, in run
    self._target(*self._args, **self._kwargs)
  File "MotorTest.py", line 90, in run
    time.sleep(self.settings['distance_measure_time'])
KeyboardInterrupt
pi@raspberrypi:~ $

Display More

Meinst du den mir nicht ersichtlichen Fehler in Zeile 90 ?

LG

Bastelstube

Shaq · Mar 13th 2018

Aufgrund privater Angelegenheiten, kann ich mich leider erst jetzt wieder zurück melden.

Ich habe es jetzt gerade noch einmal getestet mit folgendem Script:

Python

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# (c) 2018 by meigrafd
#
import sys
import time
import multiprocessing as mp
from datetime import datetime
from RPi import GPIO


class Sonar_Ranger:
    """
    This class encapsulates a type of acoustic ranger.  In particular
    the type of ranger with separate trigger and echo pins.
    
    A pulse on the trigger initiates the sonar ping and shortly
    afterwards a sonar pulse is transmitted and the echo pin
    goes high.  The echo pins stays high until a sonar echo is
    received (or the response times-out).  The time between
    the high and low edges indicates the sonar round trip time.
    
    Adjusting the interval between measurements increases the speed
    of the reading.  Increasing the speed will also increase CPU usage.
    Setting it too low will cause errors.
    """
    def __init__(self, trigger_pin, echo_pin, telemetry, status, settings, unit='cm', average=False, range_min=2, range_max=400):
        self.trig = trigger_pin
        self.echo = echo_pin
        self.telemetry = telemetry
        self.status = status
        self.settings = settings
        self.unit = unit
        self.average = average
        self.range_min = range_min
        self.range_max = range_max
        self.average_count = 3
        self.last_announce_time = int(time.time())
        GPIO.setup(self.trig, GPIO.OUT)
        GPIO.setup(self.echo, GPIO.IN)
        self.start_time = datetime.now()
        self.distance=None
        GPIO.add_event_detect(self.echo, GPIO.BOTH, self.callback)
    
    def callback(self, channel):
        if GPIO.input(self.echo) == 1:
            self.start_time = datetime.now()
        else:
            self.end_time = datetime.now()
            self.delta = self.end_time - self.start_time
            self.time_elapsed = self.delta.seconds + self.delta.microseconds / 1E6  # ultra-hacker-style. 1E6 is 1000000.
            if self.unit == 'cm':
                metric = 0.000058
            else:
                metric = 0.000148
            self.distance = self.time_elapsed / metric
            self.telemetry['distance'] = self.distance
    
    def measure_average(self, count=3):
        c=1
        distance=0
        while (c <= count):
            self.ping()
            time.sleep(0.040)
            if self.distance:
                distance = distance + self.distance
                time.sleep(0.05)
                c+=1
        self.distance = distance/count
    
    def ping(self, pulse=0.00005):
        self.start_time=datetime.now()
        self.end_time=datetime.now()
        self.distance=None
        GPIO.output(self.trig, GPIO.HIGH)
        time.sleep(pulse)
        GPIO.output(self.trig, GPIO.LOW)
    
    def print_distance(self):
        if self.distance:
            if (int(time.time()) - self.last_announce_time) >= self.settings['distance_announce_time']:
                if self.distance > self.range_max or self.distance < self.range_min:
                    print('Distance: out of range %.2f' % self.distance)
                else:
                    print('Distance: %.2f %s' % (self.distance, self.unit))
                self.last_announce_time = int(time.time())
    
    def run(self):
        while True:
            time.sleep(self.settings['distance_measure_time'])
            if not self.status['stop_ping']:
                if self.average:
                    self.measure_average(self.average_count)
                else:
                    self.ping()


class Motor_Control:
    """
    http://www.14core.com/wiring-driving-the-l298n-h-bridge-on-2-to-4-dc-motors/
    """
    def __init__(self, status, motor_a_in1, motor_a_in2, motor_b_in3, motor_b_in4):
        self.motor_a_in1 = motor_a_in1
        self.motor_a_in2 = motor_a_in2
        self.motor_b_in3 = motor_b_in3
        self.motor_b_in4 = motor_b_in4
        self.status = status
        self.status['steerTo']=0
        GPIO.setup(self.motor_a_in1, GPIO.OUT)
        GPIO.setup(self.motor_a_in2, GPIO.OUT)
        GPIO.setup(self.motor_b_in3, GPIO.OUT)
        GPIO.setup(self.motor_b_in4, GPIO.OUT)
    
    def stop(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'stop'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def forward(self):
        GPIO.output(self.motor_a_in1, True)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, True)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'forward'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def reverse(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, True)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, True)
        self.status['steerTo'] = 'reverse'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def turn_left(self):
        GPIO.output(self.motor_a_in1, True)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'left'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def turn_right(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, True)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'right'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def pivot_left(self):
        GPIO.output(self.motor_a_in1, True)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, True)
        self.status['steerTo'] = 'pivot_left'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def pivot_right(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, True)
        GPIO.output(self.motor_b_in3, True)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'pivot_right'
        print('Motor: {}'.format(self.status['steerTo']))

def main(gpio_mode=GPIO.BCM):
    motor_a_in1 = 11
    motor_a_in2 = 7
    motor_b_in3 = 13
    motor_b_in4 = 15
    sonar_trigger_left = 38
    sonar_trigger_right = 35
    sonar_echo_left = 40
    sonar_echo_right = 37
    GPIO.setmode(gpio_mode)
    status = mp.Manager().dict()  # shared dictionary
    telemetry_left = mp.Manager().dict()
    telemetry_right = mp.Manager().dict()
    settings=dict()  # static dictionary
    settings['distance_measure_time'] = 0.5  # sec. you should wait 50ms before the next trigger.
    settings['distance_announce_time'] = 1   # sec
    status['stop_ping']=False
    telemetry_left['distance']=None
    telemetry_right['distance']=None
    try:
        motor = Motor_Control(status, motor_a_in1, motor_a_in2, motor_b_in3, motor_b_in4)
        radar_left = Sonar_Ranger(sonar_trigger_left, sonar_echo_left, telemetry_left, status, settings)
        radar_right = Sonar_Ranger(sonar_trigger_right, sonar_echo_right, telemetry_right, status, settings)
        # Spawn child process for running measurement
        radarProcess_left = mp.Process(target=radar_left.run)
        radarProcess_left.daemon = True
        radarProcess_left.start()
        radarProcess_right = mp.Process(target=radar_right.run)
        radarProcess_right.daemon = True
        radarProcess_right.start()
        time.sleep(1)
        while True:
            radar_left.print_distance()
            radar_right.print_distance()
            ## ..robots brain..
            
            if telemetry_left['distance'] < 15:
                if not status['steerTo'] == 'pivot_right':
                    motor.pivot_right()
            elif telemetry_right['distance'] < 15:
                if not status['steerTo'] == 'pivot_left':
                    motor.pivot_left()
            else:
                if not status['steerTo'] == 'forward':
                    motor.forward()
            
            time.sleep(0.01)  # lowers CPU usage
    except (KeyboardInterrupt, SystemExit):
        if radarProcess_left.is_alive(): radarProcess_left.terminate()
        elif radarProcess_right.is_alive(): radarProcess_right.terminate()
        GPIO.cleanup()
            

if __name__ == '__main__':
    main(gpio_mode=GPIO.BOARD)

Display More

Dieses habe ich mit sudo python3 MotorTest.pyeinmal ausgeführt. Der Fehler bleibt jedoch bestehen. Der pivot_left funktioniert. Jedoch dreht sich beim pivot_right immer nur ein Rad. Eine Fehlermeldung aufgrund der Abänderung des brains ist nicht aufgetreten.

LG

Bastelstube

Shaq · Feb 22nd 2018

Habs schon hinbekommen. Danke trotzdem. :)

Im Anhang mal die Ausgabe als Screenshot. Meintest Du das so?

Shaq · Feb 22nd 2018

Wie kann ich denn den Test ausführen und gleichzeitig die CPU überwachen? Habe doch kein Eingabe Fenster

Shaq · Feb 21st 2018

Verkabelung habe ich überprüft und mal die Kabel getauscht. Fehler bleibt bestehen. Somit schaue ich dann mal nach dem Code. Hast Du einen Tipp für mich woran es liegen könnte?

Edit: Mir ist gerade aufgefallen, dass wenn ich den Code ausführe und die Hand zuerst vor den Sensor halte wo es scheinbar nicht funktioniert, funktioniert es für eine kurze Zeit. Wenn ich aber erst den Sensor auslöse wo es definitiv funktioniert und danach den wo es nicht geht, funktioniert es nicht Liegt es eventuell am Multiprocessing, dass zu viele Prozesse gleichzeitig ausgeführt werden etc.?

LG

Bastelstube

Shaq · Feb 21st 2018

Hier mal ein Video der aktuellen Situation:

Video

Hier der im Video verwendete Code:

Python

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# (c) 2018 by meigrafd
#
import sys
import time
import multiprocessing as mp
from datetime import datetime
from RPi import GPIO


class Sonar_Ranger:
    """
    This class encapsulates a type of acoustic ranger.  In particular
    the type of ranger with separate trigger and echo pins.
    
    A pulse on the trigger initiates the sonar ping and shortly
    afterwards a sonar pulse is transmitted and the echo pin
    goes high.  The echo pins stays high until a sonar echo is
    received (or the response times-out).  The time between
    the high and low edges indicates the sonar round trip time.
    
    Adjusting the interval between measurements increases the speed
    of the reading.  Increasing the speed will also increase CPU usage.
    Setting it too low will cause errors.
    """
    def __init__(self, trigger_pin, echo_pin, telemetry, status, settings, unit='cm', average=False, range_min=2, range_max=400):
        self.trig = trigger_pin
        self.echo = echo_pin
        self.telemetry = telemetry
        self.status = status
        self.settings = settings
        self.unit = unit
        self.average = average
        self.range_min = range_min
        self.range_max = range_max
        self.average_count = 3
        self.last_announce_time = int(time.time())
        GPIO.setup(self.trig, GPIO.OUT)
        GPIO.setup(self.echo, GPIO.IN)
        self.start_time = datetime.now()
        self.distance=None
        GPIO.add_event_detect(self.echo, GPIO.BOTH, self.callback)
    
    def callback(self, channel):
        if GPIO.input(self.echo) == 1:
            self.start_time = datetime.now()
        else:
            self.end_time = datetime.now()
            self.delta = self.end_time - self.start_time
            self.time_elapsed = self.delta.seconds + self.delta.microseconds / 1E6  # ultra-hacker-style. 1E6 is 1000000.
            if self.unit == 'cm':
                metric = 0.000058
            else:
                metric = 0.000148
            self.distance = self.time_elapsed / metric
            self.telemetry['distance'] = self.distance
    
    def measure_average(self, count=3):
        c=1
        distance=0
        while (c <= count):
            self.ping()
            time.sleep(0.040)
            if self.distance:
                distance = distance + self.distance
                time.sleep(0.05)
                c+=1
        self.distance = distance/count
    
    def ping(self, pulse=0.00005):
        self.start_time=datetime.now()
        self.end_time=datetime.now()
        self.distance=None
        GPIO.output(self.trig, GPIO.HIGH)
        time.sleep(pulse)
        GPIO.output(self.trig, GPIO.LOW)
    
    def print_distance(self):
        if self.distance:
            if (int(time.time()) - self.last_announce_time) >= self.settings['distance_announce_time']:
                if self.distance > self.range_max or self.distance < self.range_min:
                    print('Distance: out of range %.2f' % self.distance)
                else:
                    print('Distance: %.2f %s' % (self.distance, self.unit))
                self.last_announce_time = int(time.time())
    
    def run(self):
        while True:
            time.sleep(self.settings['distance_measure_time'])
            if not self.status['stop_ping']:
                if self.average:
                    self.measure_average(self.average_count)
                else:
                    self.ping()


class Motor_Control:
    """
    http://www.14core.com/wiring-driving-the-l298n-h-bridge-on-2-to-4-dc-motors/
    """
    def __init__(self, status, motor_a_in1, motor_a_in2, motor_b_in3, motor_b_in4):
        self.motor_a_in1 = motor_a_in1
        self.motor_a_in2 = motor_a_in2
        self.motor_b_in3 = motor_b_in3
        self.motor_b_in4 = motor_b_in4
        self.status = status
        self.status['steerTo']=0
        GPIO.setup(self.motor_a_in1, GPIO.OUT)
        GPIO.setup(self.motor_a_in2, GPIO.OUT)
        GPIO.setup(self.motor_b_in3, GPIO.OUT)
        GPIO.setup(self.motor_b_in4, GPIO.OUT)
    
    def stop(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'stop'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def forward(self):
        GPIO.output(self.motor_a_in1, True)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, True)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'forward'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def reverse(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, True)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, True)
        self.status['steerTo'] = 'reverse'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def turn_left(self):
        GPIO.output(self.motor_a_in1, True)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'left'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def turn_right(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, True)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'right'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def pivot_left(self):
        GPIO.output(self.motor_a_in1, True)
        GPIO.output(self.motor_a_in2, False)
        GPIO.output(self.motor_b_in3, False)
        GPIO.output(self.motor_b_in4, True)
        self.status['steerTo'] = 'pivot_left'
        print('Motor: {}'.format(self.status['steerTo']))
    
    def pivot_right(self):
        GPIO.output(self.motor_a_in1, False)
        GPIO.output(self.motor_a_in2, True)
        GPIO.output(self.motor_b_in3, True)
        GPIO.output(self.motor_b_in4, False)
        self.status['steerTo'] = 'pivot_right'
        print('Motor: {}'.format(self.status['steerTo']))

def main(gpio_mode=GPIO.BCM):
    motor_a_in1 = 11
    motor_a_in2 = 7
    motor_b_in3 = 13
    motor_b_in4 = 15
    sonar_trigger_left = 38
    sonar_trigger_right = 35
    sonar_echo_left = 40
    sonar_echo_right = 37
    GPIO.setmode(gpio_mode)
    status = mp.Manager().dict()  # shared dictionary
    telemetry_left = mp.Manager().dict()
    telemetry_right = mp.Manager().dict()
    settings=dict()  # static dictionary
    settings['distance_measure_time'] = 0.6  # sec. you should wait 50ms before the next trigger.
    settings['distance_announce_time'] = 1   # sec
    status['stop_ping']=False
    telemetry_left['distance']=None
    telemetry_right['distance']=None
    try:
        motor = Motor_Control(status, motor_a_in1, motor_a_in2, motor_b_in3, motor_b_in4)
        radar_left = Sonar_Ranger(sonar_trigger_left, sonar_echo_left, telemetry_left, status, settings)
        radar_right = Sonar_Ranger(sonar_trigger_right, sonar_echo_right, telemetry_right, status, settings)
        # Spawn child process for running measurement
        radarProcess_left = mp.Process(target=radar_left.run)
        radarProcess_left.daemon = True
        radarProcess_left.start()
        radarProcess_right = mp.Process(target=radar_right.run)
        radarProcess_right.daemon = True
        radarProcess_right.start()
        time.sleep(1)
        while True:
            radar_left.print_distance()
            radar_right.print_distance()
            ## ..robots brain..
            
            if telemetry_left['distance'] < 15:
                if not status['steerTo'] == 'pivot_right':
                    motor.pivot_right()
            elif telemetry_right['distance'] < 15:
                if not status['steerTo'] == 'pivot_left':
                    motor.pivot_left()
            else:
                if not status['steerTo'] == 'forward':
                    motor.forward()
            
            time.sleep(0.01)  # lowers CPU usage
    except (KeyboardInterrupt, SystemExit):
        if radarProcess_left.is_alive(): radarProcess_left.terminate()
        elif radarProcess_right.is_alive(): radarProcess_right.terminate()
        GPIO.cleanup()
            

if __name__ == '__main__':
    main(gpio_mode=GPIO.BOARD)

Display More

Hier die zum Video & Code zugehörige Ausgabe:

Quote

pi@raspberrypi:~ $ sudo python MotorTest.py

Distance: 113.52 cm

Distance: 92.57 cm

Motor: forward

Distance: 109.45 cm

Distance: 93.64 cm

Motor: pivot_left

Distance: 110.64 cm

Distance: 4.62 cm

Distance: 113.19 cm

Distance: 5.93 cm

Motor: forward

Distance: 111.00 cm

Distance: 96.43 cm

Distance: 167.69 cm

Distance: 106.52 cm

Motor: pivot_left

Distance: 114.67 cm

Distance: 3.43 cm

Distance: 102.62 cm

Distance: 5.60 cm

Motor: forward

Distance: 97.93 cm

Distance: 108.69 cm

Distance: 97.41 cm

Distance: 104.57 cm

Distance: 97.33 cm

Distance: 106.52 cm

Motor: pivot_right

Distance: 3.90 cm

Distance: 167.21 cm

Motor: forward

Distance: 166.45 cm

Distance: 108.59 cm

Distance: 102.47 cm

Distance: 103.26 cm

Distance: 101.91 cm

Distance: 102.40 cm

Motor: pivot_right

Distance: 7.57 cm

Distance: 166.59 cm

Motor: forward

Distance: 106.17 cm

Distance: 100.57 cm

Distance: 105.76 cm

Distance: 102.17 cm

Distance: 102.41 cm

Distance: 104.47 cm

Motor: pivot_left

Distance: 168.59 cm

Distance: 2.95 cm

Distance: 168.00 cm

Distance: 4.57 cm

Motor: forward

Distance: 98.84 cm

Distance: 108.71 cm

Distance: 95.19 cm

Distance: 111.52 cm

Motor: pivot_right

Distance: 3.10 cm

Distance: 113.57 cm

Motor: forward

Distance: 94.83 cm

Distance: 112.31 cm

Distance: 166.00 cm

Distance: 119.64 cm

Distance: 166.95 cm

Distance: 119.81 cm

Distance: 93.83 cm

Distance: 113.33 cm

Distance: 165.86 cm

Distance: 122.57 cm

^CProcess Process-5:

Traceback (most recent call last):

File "/usr/lib/python2.7/multiprocessing/process.py", line 258, in _bootstrap

self.run()

File "/usr/lib/python2.7/multiprocessing/process.py", line 114, in run

self._target(*self._args, **self._kwargs)

File "MotorTest.py", line 90, in run

time.sleep(self.settings['distance_measure_time'])

KeyboardInterrupt

pi@raspberrypi:~ $

Display More

LG

Bastelstube

Shaq · Feb 20th 2018

Achso das meinst du. Ich hatte das jetzt mal so ausprobiert, jedoch selber schnell gemerkt, dass das keinen Sinn macht. Jedoch habe ich keinerlei Idee wo da der Fehler liegen könnte.

Hast du eine Idee bzgl. der Pivot Thematik?

LG

Bastelstube

Shaq · Feb 20th 2018

Quote from meigrafd

Jetzt bin ich verwirrt... Was hat datetime.now() mit radarProcess_left.is_alive() zu tun?

Das hat nichts miteinander zu tun. Mein Problem ist das pivot_right() nicht funktioniert und ich nicht so recht verstehe warum. Was hat denn pivot_right() mit Zeile 49 und 50 zu tun?

Ich bin selber gerade etwas verwirrt.

Quote from meigrafd

Das einzubauen wäre aber auch nicht richtig... Lieber eine Anzahl an Wiederholungen gleicher Vorgänge und wenn Maximum erreicht dann andere Aktion...

Das meinte ich ja, da könnte man dann sagen, dass das Gefährt rückwärts fahren soll etc.

LG

Bastelstube

Shaq · Feb 20th 2018

Quote from meigrafd

Zeile 49 und 50 wird so nicht gehen, da es keine "elif" Situation geben könnte... Der Part wird ja nur dann ausgeführt wenn die erste Bedingung nicht Zutraf - was ist aber wenn doch?

radarProcess.terminate()wird ebenfalls nicht gehen

Das radarProcess.terminate()habe ich schon angepasst (Siehe Code). Wegen der elif sache fällt mir momentan keine wirklich passende Lösung ein. Ich hätte jetzt den else Block in den if Block geschrieben bis auf self.end_time = datetime.now().

Python

def main(gpio_mode=GPIO.BCM):
    motor_a_in1 = 11
    motor_a_in2 = 7
    motor_b_in3 = 13
    motor_b_in4 = 15
    sonar_trigger_left = 38
    sonar_trigger_right = 35
    sonar_echo_left = 40
    sonar_echo_right = 37
    GPIO.setmode(gpio_mode)
    status = mp.Manager().dict()  # shared dictionary
    telemetry_left = mp.Manager().dict()
    telemetry_right = mp.Manager().dict()
    settings=dict()  # static dictionary
    settings['distance_measure_time'] = 0.6  # sec. you should wait 50ms before the next trigger.
    settings['distance_announce_time'] = 1   # sec
    status['stop_ping']=False
    telemetry_left['distance']=None
    telemetry_right['distance']=None
    try:
        motor = Motor_Control(status, motor_a_in1, motor_a_in2, motor_b_in3, motor_b_in4)
        radar_left = Sonar_Ranger(sonar_trigger_left, sonar_echo_left, telemetry_left, status, settings)
        radar_right = Sonar_Ranger(sonar_trigger_right, sonar_echo_right, telemetry_right, status, settings)
        # Spawn child process for running measurement
        radarProcess_left = mp.Process(target=radar_left.run)
        radarProcess_left.daemon = True
        radarProcess_left.start()
        radarProcess_right = mp.Process(target=radar_right.run)
        radarProcess_right.daemon = True
        radarProcess_right.start()
        time.sleep(1)
        while True:
            radar_left.print_distance()
            radar_right.print_distance()
            ## ..robots brain..
            
            if telemetry_left['distance'] < 15:
                if not status['steerTo'] == 'pivot_right':
                    motor.pivot_right()
            elif telemetry_right['distance'] < 15:
                if not status['steerTo'] == 'pivot_left':
                    motor.pivot_left()
            else:
                if not status['steerTo'] == 'forward':
                    motor.forward()
            
            time.sleep(0.01)  # lowers CPU usage
    except (KeyboardInterrupt, SystemExit):
        if radarProcess_left.is_alive(): radarProcess_left.terminate()
        elif radarProcess_right.is_alive(): radarProcess_right.terminate()
        GPIO.cleanup()
            

if __name__ == '__main__':
    main(gpio_mode=GPIO.BOARD)

Display More

datetime.now ist die aktuelle Zeit und starttime.now ist die Zeit wann die Messsung gestartet wurde oder?

Quote from meigrafd

Problem: Was ist wenn das Gefährt unglücklich in einer Ecke des Raumes steht, und zwar so dass er sich nun nur zur Seite dreht... Links zu wenig Platz, drehe nach rechts, dann ist rechts zu wenig Platz also drehe nach links, dann ist links zu wenig platz und drehe wieder nach rechts... Das geht dann ggf ewig so weiter

Dann wäre es sinvoll wenn er versucht rückwärts zu fahren. Dafür benötige ich aber dann noch einen weiteren Sensor. Das wäre jetzt meine Idee.

LG

Bastelstube

Shaq · Feb 20th 2018

Der pivot_right() will jedoch nicht so ganz pivot_left() geht ohne Probleme.

Python

while True:
            radar_left.print_distance()
            radar_right.print_distance()
            ## ..robots brain..
            
            if telemetry_left['distance'] < 15:
                if not status['steerTo'] == 'pivot_right':
                    motor.pivot_right()
            elif telemetry_right['distance'] < 15:
                if not status['steerTo'] == 'pivot_left':
                    motor.pivot_left()
            else:
                if not status['steerTo'] == 'forward':
                    motor.forward()

Display More

Die Motor_Control()sieht richtig aus.

LG

Bastelstube

Shaq · Feb 20th 2018

Quote from meigrafd

Wie sieht denn deine "Roboter Brain" aus?

Python

def main(gpio_mode=GPIO.BCM):
    motor_a_in1 = 11
    motor_a_in2 = 7
    motor_b_in3 = 13
    motor_b_in4 = 15
    sonar_trigger_left = 38
    sonar_trigger_right = 35
    sonar_echo_left = 40
    sonar_echo_right = 37
    GPIO.setmode(gpio_mode)
    status = mp.Manager().dict()  # shared dictionary
    telemetry_left = mp.Manager().dict()
    telemetry_right = mp.Manager().dict()
    settings=dict()  # static dictionary
    settings['distance_measure_time'] = 0.6  # sec. you should wait 50ms before the next trigger.
    settings['distance_announce_time'] = 1   # sec
    status['stop_ping']=False
    telemetry_left['distance']=None
    telemetry_right['distance']=None
    try:
        motor = Motor_Control(status, motor_a_in1, motor_a_in2, motor_b_in3, motor_b_in4)
        radar_left = Sonar_Ranger(sonar_trigger_left, sonar_echo_left, telemetry_left, status, settings)
        radar_right = Sonar_Ranger(sonar_trigger_right, sonar_echo_right, telemetry_right, status, settings)
        # Spawn child process for running measurement
        radarProcess_left = mp.Process(target=radar_left.run)
        radarProcess_left.daemon = True
        radarProcess_left.start()
        radarProcess_right = mp.Process(target=radar_right.run)
        radarProcess_right.daemon = True
        radarProcess_right.start()
        time.sleep(1)
        while True:
            radar_left.print_distance()
            radar_right.print_distance()
            ## ..robots brain..
            
            if telemetry_left['distance'] < 15:
                if not status['steerTo'] == 'right':
                    motor.turn_right()
            elif telemetry_right['distance'] < 15:
                if not status['steerTo'] == 'left':
                    motor.turn_left()
            else:
                if not status['steerTo'] == 'forward':
                    motor.forward()
            
            time.sleep(0.01)  # lowers CPU usage
    except (KeyboardInterrupt, SystemExit):
        if radarProcess_left.is_alive(): radarProcess.terminate()
        elif radarProcess_right.is_alive(): radarProcess.terminate()
        GPIO.cleanup()
            

if __name__ == '__main__':
    main(gpio_mode=GPIO.BOARD)

Display More

Quote from meigrafd

pivot_*

Ach sorry übersehen

Shaq · Feb 20th 2018

Das ganze läuft jetzt soweit. Die Frage die sich mir momentan noch stellt ist. Im vorherigen Scipt ohne den zweiten Sensor war es so, dass wenn der Roboter einen turn_left()gemacht hat, dass sich das eine rad vorwärts und das andere rückwärts gedreht hat. Dies hätte ich jetzt auch gerne wieder. Sprich das sich die Räder beim turn_left()und beim turn_right()jeweils in die andere Richtung drehen.

Hierfür muss ich doch in der class Motor_Control()jeweils ein neues steerToanlegen oder?

Bsp. steerTo_left und steerTo_right

LG

bastelstube

Shaq · Feb 20th 2018

Wofür benötigt man den zum Beispiel das self.vor der Variabel. Könnte man das ganze nicht auch ohne das self.machen? Welchen nutzen hat dies?

Was bedeutet eigentlich =None? Heißt das, dass ich die Variabel auf nullsetze. Sprich kein Inhalt? Weil bei Falsewäre es ja ein Zustand.

Worin liegt der unterschied und die funktionsweise von einemstaticzu einem sharedDictionary?

LG

Bastelstube

Shaq · Feb 19th 2018

Das mit der Fehlermeldung hat sich anscheined von selbst erledigt. Wie kann ich denn ein zweites Dictionary für den anderen Sensor anlegen?

Posts by Shaq

Sammelthread: "Ist mein Projekt machbar?"

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Eigene Cloud

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter

Projekt: Autonomer Roboter