Dieser Artikel richtet sich an alle, die mit ev3 in Python arbeiten möchten. Dieses Mal möchte ich verschiedene Operationen mit dem Kreiselsensor durchführen.

Inhaltsverzeichnis

Was vorzubereiten?
Kreiselsensorprogramm

0. Was ist vorzubereiten?

◯ ev3 (Tank) und Kreiselsensor ◯ PC (VS-Code) ◯ bluetooth ◯ microSD ◯ Material (Es wird empfohlen, fortzufahren, während Sie dies ansehen.)

1. Kreiselsensorprogramm (Dokument S.36)

1-0. Programm, das die Richtung um einen bestimmten Winkel ändert ①

`gyrosensor00.py`


#!/usr/bin/env python3
from ev3dev2.sensor.lego import GyroSensor
from ev3dev2.display import Display
from time import sleep

#Instanzgenerierung
dsp = Display()
gy = GyroSensor()

#4 mal wiederholen
for i in range(4):
    #Fahren Sie zwei Kurven geradeaus
    tank_drive.on_for_rotations(10,10,2)
    #Stellen Sie den Kreiselsensorwert auf 0
    gy.reset()
    #Ändern Sie die Richtung weiter, bis sich der Wert des Kreiselsensors um 90 Grad ändert.
    tank_drive.on(5,0)
    gy.wait_until_angle_changed_by(90)
exit()

** Punkt **: Ein Programm, das das viermalige Geradeausfahren und Drehen um 90 Grad wiederholt.

Point : wait_until_angle_changed_by(delta,direction_sensitive=False)

Eine Funktion, die wartet, bis sie sich um den angegebenen Winkel ändert. Geben Sie im ersten Argument die Änderungsbreite (Verschiebung) ein. direction_sensitive kann bestimmen, ob die Drehrichtung unterschieden werden soll.

Zum Beispiel, wenn Delta = -90 Wenn direction_sensitive = True ist, warten Sie, bis der Wert des Kreiselsensors -90 erreicht. (Drehrichtung unterscheiden) Wenn direction_sensitive = False ist, warten Sie, bis der Wert des Kreiselsensors 90 oder -90 erreicht. (Unterscheiden Sie nicht die Drehrichtung)

1-1. Programm, das die Richtung um einen bestimmten Winkel ändert ②

`gyrosensor01.py`


#!/usr/bin/env python3
from ev3dev2.motor import OUTPUT_A, OUTPUT_B, MoveTank, SpeedPercent
from ev3dev2.sensor.lego import GyroSensor

#Instanzgenerierung
tank = MoveTank(OUTPUT_A, OUTPUT_B)
#Weisen Sie der Variablen Kreisel in der Klasse MoveTank eine Instanz des Kreiselsensors zu
tank.gyro = GyroSensor()
#Stellen Sie den aktuellen Wert des Kreiselsensors auf 0 ein
tank.gyro.calibrate()

#30 Grad drehen
tank.turn_degrees(
speed=SpeedPercent(5),
target_angle=30
)

** Punkt **: Programm, das sich um 30 Grad dreht

Point : turn_degrees(speed, target_angle, brake=True, error_margin=2, sleep_time=0.01) → Dies ist eine tankspezifische Funktion, bei der mithilfe eines Kreiselsensors gewartet wird, bis die Winkelrichtung wie vor Ort angegeben geändert wird. error_margin kann bestimmen, wie viel Fehler zwischen dem target_angle und der tatsächlichen Runde zulässig ist.

1-2. Programm zur Anzeige des Winkels

`gyrosensor02.py`


#!/usr/bin/env python3
from ev3dev2.display import Display
from ev3dev2.sensor.lego import GyroSensor
from time import sleep

dsp = Display()
gy = GyroSensor()

#Endlosschleife
while True:
    dsp.update()
    #Weil ich immer den Wert des Kreiselsensors erhalten möchte
    #Die Variable ang wird in einer Schleife erstellt.
    ang = gy.angle
    #Wandeln Sie den Winkel des Kreiselsensors in Zeichen um und zeigen Sie ihn mit dem Gerät an
    dsp.text_pixels(str(ang) + 'cm',True,0,52,font = 'helvB' + '24')
    #Holen Sie sich in regelmäßigen Abständen Zeichen, um die Verarbeitung zu vereinfachen
    sleep(0.1)

** Punkt **: Ein Programm, das den Wert des Kreiselsensors anzeigt

Point : angle Eine Variable, die den numerischen Wert des Kreiselsensors speichert.

1-3 Parallelverarbeitungsprogramm

`gyrosensor03.py`


#!/usr/bin/env python3
from ev3dev2.motor import OUTPUT_A,OUTPUT_B,MoveTank
from ev3dev2.display import Display
from ev3dev2.sensor.lego import GyroSensor
from time import sleep
from threading import Thread

#Instanzgenerierung
tank_drive = MoveTank(OUTPUT_A,OUTPUT_B)
dsp = Display()
gy = GyroSensor()

#Erstellen Sie Ihre eigene Funktion(Definieren)
def angle_display():
    # loop =Wiederholt, während True
    #Programm zur Anzeige des Winkels
    while loop:
        dsp.update()
        gy = gy.angle
        dsp.text_pixels(str(angle) + 'cm',True,0,52,font = 'helvB' + '24')
        sleep(0.1)

#Halten Sie die Schleife wahr
loop = True
#Erstellen Sie eine Instanz t der Klasse Thread
#Wählen Sie den zu startenden Thread aus
t = Thread(target = angle_display)
#Starten Sie einen Thread mit einer Instanz
t.start()

#4 mal wiederholen
for i in range(4):
    #Fahren Sie zwei Kurven geradeaus
    tank_drive.on_for_rotations(10,10,2)
    #Stellen Sie den Kreiselsensorwert auf 0
    gy.reset()
    #Ändern Sie die Richtung weiter, bis sich der Wert des Kreiselsensors um 90 Grad ändert.
    tank_drive.on(5,0)
    gy.wait_until_angle_changed_by(90)
tank_drive.stop()
#Beenden Sie den Thread, indem Sie die Schleife auf False setzen
loop = False

Point : Ein Programm, das das viermalige Geradeausfahren und Drehen um 90 Grad wiederholt Dann wird der Wert des Kreiselsensors gleichzeitig mit dem Laufen angezeigt.

** Punkt **: Referenzartikel zur Parallelverarbeitung Multithreading [Im Thread implementieren](https://qiita.com/tchnkmr/items/b05f321fa315bbce4f77#:~:text=%E3%82%B9%E3%83%AC%E3%83%83%E3%83%89 % E3% 81% A8% E3% 81% AF,% E3% 82% 92% E8% A1% 8C% E3% 81% 86% E3% 81% 93% E3% 81% A8% E3% 81% 8C% E3% 81% A7% E3% 81% 8D% E3% 81% BE% E3% 81% 9B% E3% 82% 93% E3% 80% 82 & Text =% E3% 81% 9D% E3% 81% AE% E4 % B8% A6% E5% 88% 97% E5% 87% A6% E7% 90% 86% E3% 82% 92% E8% A1% 8C% E3% 81% 86,% E3% 81% AE% E4% BD% BF% E7% 94% A8% E3% 81% AB% E3% 81% AA% E3% 82% 8A% E3% 81% BE% E3% 81% 99% E3% 80% 82)

** Punkt **: Referenzartikel über Funktionen Definieren und Aufrufen einer Funktion in Python (def, return)

1-4 Parallelverarbeitungsprogramm

`main.py`


#!/usr/bin/env python3
from ev3dev2.motor import OUTPUT_A,OUTPUT_B,MoveTank
from ev3dev2.sensor.lego import GyroSensor
import subprocess

#Instanzgenerierung
tank_drive = MoveTank(OUTPUT_A,OUTPUT_B)
gy = GyroSensor()

#Führen Sie das untergeordnete Programm in einem neuen Prozess aus
subprocess.Popen(['python3','sub.py'])

for i in range(4):
    #Fahren Sie zwei Kurven geradeaus
    tank_drive.on_for_rotations(10,10,2)
    #Stellen Sie den Kreiselsensorwert auf 0
    gy.reset()
    #Ändern Sie die Richtung weiter, bis sich der Wert des Kreiselsensors um 90 Grad ändert.
    tank_drive.on(5,0)
    gy.wait_until_angle_changed_by(90)
#Erstellen Sie einen Instanzprozess der Popen-Klasse
proc = subprocess.Popen(['python3','sub.py'])
#Verwenden Sie proc, um einen untergeordneten Prozess zu beenden
proc.kill()
exit()

`sub.py`


from ev3dev2.sensor.lego import GyroSensor
from ev3dev2.display import Display
from time import sleep

dsp = Display()
us = GyroSensor()

#Endlosschleife
while True:
    dsp.update()
    #Weil ich immer den Wert des Kreiselsensors erhalten möchte
    #Die Variable ang wird in einer Schleife erstellt.
    ang = gy.angle
    #Wandeln Sie den Winkel des Kreiselsensors in Zeichen um und zeigen Sie ihn mit dem Gerät an
    dsp.text_pixels(str(ang) + 'cm',True,0,52,font = 'helvB' + '24')
    #Holen Sie sich in regelmäßigen Abständen Zeichen, um die Verarbeitung zu vereinfachen
    sleep(0.1)

** Punkt **: Ein Programm, das das viermalige Geradeausfahren und Drehen um 90 Grad wiederholt. Dann wird der Wert des Kreiselsensors gleichzeitig mit dem Laufen angezeigt.

** Punkt **: Ein Programm, das sub.py von main.py zur parallelen Verarbeitung aufruft. (Verarbeitung ist schwer) Point : subprocess.Popen() Laichen Sie einfach einen Prozess und warten Sie nicht, bis er abgeschlossen ist → Starten und verlassen Popen.terminate() Stoppen Sie den untergeordneten Prozess. Popen.kill() Töte den untergeordneten Prozess.

** Punkt **: Referenzartikel zur Parallelverarbeitung Einführung in die Parallelverarbeitungsprogrammierung in Python [Tiefer über Unterprozess (3er Serie, aktualisierte Version)] (https://qiita.com/HidKamiya/items/e192a55371a2961ca8a4#subprocesspopen%E3%81%AB%E3%82%88%E3%82%8B%E8%87%AA%E7%94%B1%E5%BA%A6%E3%81%AE%E9%AB%98%E3%81%84%E5%87%A6%E7%90%86) [17.5. Unterprozess - Unterprozessmanagement (offiziell)] (https://docs.python.org/ja/3.5/library/subprocess.html)

1-5. Ein Programm, das mit PID-Regelung ausgeführt wird

`gyrosensor05.py`


from ev3dev2.motor import OUTPUT_A, OUTPUT_B, MoveTank, SpeedPercent, follow_for_ms
from ev3dev2.sensor.lego import GyroSensor

#Instanzgenerierung
tank = MoveTank(OUTPUT_A, OUTPUT_B)
#Weisen Sie der Variablen Gyro in der Klasse MoveTank eine Instanz der Klasse GyroSensor zu
tank.gyro = GyroSensor()
#Stellen Sie den aktuellen Wert des Kreiselsensors auf 0 ein
tank.gyro.calibrate()

try:
#4500ms(4.5 Sekunden)Nur während
#Der Wert des Kreiselsensors ist immer der Zielwert(0 in diesem Fall)Starten Sie damit
    tank.follow_gyro_angle(
    kp=11.3, ki=0.05, kd=3.2,
    speed=SpeedPercent(30),
    target_angle=0,
    follow_for=follow_for_ms,
    ms=4500
    )
#Entscheiden Sie, was zu tun ist, wenn eine Ausnahme auftritt
except FollowGyroAngleErrorTooFast:
    tank.stop()
    raise

** Punkt **: Ein Programm, das ausgeführt wird, während versucht wird, den Winkel auf 0 zu halten, egal was passiert Verwenden Sie die PID-Regelung, um den Kreiselsensorwert näher an den Zielwert zu bringen.

Point : follow_gyro_angle(kp, ki, kd, speed, target_angle=0, sleep_time=0.01, follow_for=, **kwargs)

kp, ki, kd sind PID-Konstanten. Geschwindigkeit ist die Geschwindigkeit des Roboters target_angle ist der Winkel, den Sie beibehalten möchten

** Punkt **: Referenzartikel zur PID-Regelung

PID-Regelung des Line Trace Cars

** Punkt **: Referenzartikel zur Behandlung von Python-Ausnahmen

Behandlung von Python-Ausnahmen (versuchen Sie es, außer, sonst, endlich)

Schließlich

Danke fürs Lesen! !! Nächstes Mal möchte ich über ssh control schreiben!

Ich möchte einen besseren Artikel machen ◯ Das ist leichter zu verstehen ◯ Das ist schwer zu verstehen ◯ Das ist falsch ◯ Ich möchte, dass Sie hier mehr erklären Wir freuen uns über Ihre Meinungen und Vorschläge.

[ev3dev × Python] Kreiselsensor