[PYTHON] Aktualisierte Software für Rubik Cube Robot 4. Statuserkennung
Was ist dieser Artikel?
Ich entwickle gerade einen Roboter, der einen 2x2x2 Rubikwürfel löst. Dies ist eine Sammlung von Kommentaren zum Roboterprogramm.
Ich habe einmal eine Sammlung von Artikeln geschrieben, die durch den Artikel [hier] repräsentiert werden (https://qiita.com/Nyanyan_Cube/items/60f3699db96dba4a4bf5), aber seitdem wurde die Software erheblich aktualisiert, sodass ich ein neues Programm einführen werde. Überlegen.
Der entsprechende Code ist hier verfügbar [https://github.com/Nyanyan/soltvvo/tree/master/Soltvvo3.2].
Zum Thema passende Artikel
"Lass uns einen Roboter bauen, der den Zauberwürfel löst!"
Aktualisierte Software für Rubik Cube Robot
- Grundfunktion
- Vorberechnung
- Lösungssuche
- Staatliche Anerkennung (dieser Artikel)
- Maschinenbetrieb (Python)
- Maschinenbetrieb (Arduino)
- Hauptverarbeitung
Dieses Mal werden wir `` `detector.py``` als State Recognition Edition einführen.
Importieren Sie die zu verwendenden Module
Importieren Sie das Modul, das Sie verwenden möchten.
import cv2
from time import sleep
from basic_functions import *
from controller import move_actuator
Hier ist `controller``` das Programm, das beim nächsten Mal erklärt wird, aber die Funktion` move_actuator``` in dieser Funktion sendet einen Befehl zum Bewegen des Aktuators (hier des Motors), wie der Name schon sagt.
Erstellen Sie 6 Seiten mit Informationen aus 4 Seiten des Puzzles
Mit dem 2x2x2 Rubik Cube können Sie die Farbe der gesamten Oberfläche erraten, indem Sie sich die Farben auf den vier Seiten ansehen. Um diese Eigenschaft nutzen zu können, benötigen wir eine Funktion, die die ungefüllte Farbe aus den gefüllten Farbinformationen ableitet. Ich werde die Funktion vorstellen.
Bitte lassen Sie mich zuerst entschuldigen. Diese Funktion wurde ursprünglich mit Schwung in der Ära der manuellen Eingabe von Farben (vor einigen Monaten) erstellt, und ich weiß nicht wirklich, was ich jetzt mache! Und jetzt muss es keine so vielseitige Funktion sein, da wir die Farben der verbleibenden zwei Seiten ableiten, indem wir die Farben einer bestimmten vier Seiten betrachten. Mit anderen Worten, die hier vorgestellten Funktionen sind ** Funktionen, die etwas redundant sind, und ich bin nicht sicher, was sie tun, aber sie funktionieren **. Es tut uns leid. Sei vorsichtig mit dir selbst, "füge wenigstens einen Kommentar hinzu."
Nebenbei schreibe ich diesen Artikel in Zukunft für mich. Damit ich diesen Code in Zukunft nicht mehr lesen kann, habe ich jetzt einen Kommentar geschrieben und einen Kommentar hinterlassen.
'''Füllen Sie die Stelle, an der die Farbe fixiert ist, wo sie nicht gefüllt ist'''
''' Fill boxes if the color can be decided '''
def fill(colors):
for i in range(6):
for j in range(8):
if (1 < i < 4 or 1 < j < 4) and colors[i][j] == '':
done = False
for k in range(8):
if [i, j] in parts_place[k]:
for strt in range(3):
if parts_place[k][strt] == [i, j]:
idx = [colors[parts_place[k][l % 3][0]][parts_place[k][l % 3][1]] for l in range(strt + 1, strt + 3)]
for strt2 in range(3):
idx1 = strt2
idx2 = (strt2 + 1) % 3
idx3 = (strt2 + 2) % 3
for l in range(8):
if parts_color[l][idx1] == idx[0] and parts_color[l][idx2] == idx[1]:
colors[i][j] = parts_color[l][idx3]
done = True
break
if done:
break
break
if done:
break
return colors
Ich werde es durch Raten erklären.
Die `for``` -Anweisung, die die ersten beiden` i, j``` dreht, betrachtet einfach die folgenden Farben nacheinander.
colors = [
['', '', 'w', 'o', '', '', '', ''],
['', '', 'w', 'g', '', '', '', ''],
['b', 'o', 'g', 'y', 'r', 'w', 'b', 'r'],
['o', 'o', 'g', 'g', 'w', 'r', 'b', 'b'],
['', '', 'y', 'r', '', '', '', ''],
['', '', 'y', 'y', '', '', '', '']
]
Wobei `` `w, y, g, b, o, r``` jeweils Weiß, Gelb, Grün, Blau, Orange und Rot darstellen. Es ist anzumerken, dass die Art und Weise, diese Vereinbarung zu treffen, verschwenderisch ist, da sie die Tradition von Programmen erbt, die in der Vergangenheit in eine schlechte Richtung gemacht wurden. Ich möchte es eines Tages reparieren.
Nachfolgendes `if (1 <i <4 oder 1 <j <4) und Farben [i] [j] == '':`, wobei die Farbinformationen ursprünglich enthalten sind oder nicht Ich werde es teilen.
for k in range(8):Geben Sie alle möglichen Teilekandidaten ab, wenn[i, j] in parts_place[k]:Wenn die beiden Farben übereinstimmen, für strt in range(3):Überprüfen Sie alle drei Richtungen der Teile mit.
Ich denke, dass die Verarbeitung auf diese Weise erfolgt.
# Zustandserkennung mit einer Kamera
Verwenden Sie die Kamera, um den Zustand des Puzzles zu erkennen. Dieses Mal verwenden wir eine Bibliothek namens OpenCV, um Farben zu erkennen.
```python
'''Holen Sie sich den Stand des Puzzles'''
''' Get colors of stickers '''
def detector():
colors = [['' for _ in range(8)] for _ in range(6)]
#Schnapp dir das Rätsel
for i in range(2):
move_actuator(i, 0, 1000)
for i in range(2):
move_actuator(i, 1, 2000)
sleep(0.3)
rpm = 200
capture = cv2.VideoCapture(0)
#Jede Farbe(HSV)Bereich von
#color: g, b, r, o, y, w
color_low = [[40, 50, 50], [90, 50, 70], [160, 50, 50], [170, 50, 50], [20, 50, 30], [0, 0, 50]]
color_hgh = [[90, 255, 255], [140, 255, 200], [170, 255, 255], [10, 255, 255], [40, 255, 255], [179, 50, 255]]
#Position jedes Teils auf dem Farbarray
surfacenum = [[[4, 2], [4, 3], [5, 2], [5, 3]], [[2, 2], [2, 3], [3, 2], [3, 3]], [[0, 2], [0, 3], [1, 2], [1, 3]], [[3, 7], [3, 6], [2, 7], [2, 6]]]
#Andere Konstanten
d = 10
size_x = 130
size_y = 100
center = [size_x // 2, size_y // 2]
dx = [-1, -1, 1, 1]
dy = [-1, 1, -1, 1]
#Laden Sie die vier Seiten des Puzzles
for idx in range(4):
#Da es Zeiten gibt, in denen das Lesen nicht gut läuft, lassen Sie den Dummy fünfmal lesen
for _ in range(5):
ret, frame = capture.read()
tmp_colors = [['' for _ in range(8)] for _ in range(6)]
loopflag = [1 for _ in range(4)]
#Während bis alle Farben der vier Aufkleber auf einer Seite geladen sind
while sum(loopflag):
ret, show_frame = capture.read()
show_frame = cv2.resize(show_frame, (size_x, size_y))
hsv = cv2.cvtColor(show_frame,cv2.COLOR_BGR2HSV)
#Untersuche die vier Aufkleber der Reihe nach
for i in range(4):
y = center[0] + dy[i] * d
x = center[1] + dx[i] * d
val = hsv[x, y]
#Finden Sie heraus, welche der 6 Farben
for j in range(6):
flag = True
for k in range(3):
if not ((color_low[j][k] < color_hgh[j][k] and color_low[j][k] <= val[k] <= color_hgh[j][k]) or (color_low[j][k] > color_hgh[j][k] and (color_low[j][k] <= val[k] or val[k] <= color_hgh[j][k]))):
flag = False
if flag:
tmp_colors[surfacenum[idx][i][0]][surfacenum[idx][i][1]] = j2color[j]
loopflag[i] = 0
break
#Speichern Sie die Werte im Farbarray
for i in range(4):
colors[surfacenum[idx][i][0]][surfacenum[idx][i][1]] = tmp_colors[surfacenum[idx][i][0]][surfacenum[idx][i][1]]
#Drehen Sie den Motor, um die nächste Seite zu sehen
move_actuator(0, 0, -90, rpm)
move_actuator(1, 0, 90, rpm)
sleep(0.2)
capture.release()
colors = fill(colors)
return colors
Das Problem hierbei ist, dass der Farbbereich entscheidend ist. Dies kann aufgrund von Störungen zu einer schlechten Farberkennung führen. Eigentlich hat es am Veranstaltungsort der Maker Faire Tokyo 2020 aufgrund der hellen Umgebung nicht gut funktioniert (ich habe den Wert leicht korrigiert und überlebt).
Zusammenfassung
Dieses Mal habe ich den Teil vorgestellt, der den Zustand mit der Kamera erkennt und die nicht sichtbare Oberfläche wiederherstellt. Nächstes Mal werde ich den Roboter tatsächlich bewegen.
Recommended Posts