Quel est cet article?

Je développe actuellement un robot qui résout un cube rubic 2x2x2. Ceci est une collection d'articles de commentaires sur le programme du robot. J'ai écrit une fois une collection d'articles représentés par l'article ici, mais depuis cette fois, le logiciel a été considérablement mis à jour, je vais donc introduire un nouveau programme. pense.

Le code applicable est disponible ici [https://github.com/Nyanyan/soltvvo/tree/master/Soltvvo3.2).

Articles Liés

"Faisons un robot qui résout le Rubik Cube!"

Logiciel mis à jour pour Rubik Cube Robot

Cette fois, nous allons introduire main.py``` comme traitement principal.

Importation de module

Importez le module que vous souhaitez utiliser.

import tkinter
from time import sleep

from basic_functions import *
from solver import solver
from controller import controller, grab_p, release_p, calibration, move_actuator
from detector import detector

Paramètres Bluetooth

Ce robot peut afficher le temps écoulé résolu en temps réel sur l'écran d'un autre PC par Bluetooth. C'est le réglage (je ne l'utilise généralement pas).

#Que faire si vous utilisez Bluetooth
bluetoothmode = False
if bluetoothmode:
    subprocess.call(['sh', 'bluetooth_script.sh'])
    PORT = 1
    server_socket=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
    print("connect...")
    server_socket.bind( ("",PORT ))
    server_socket.listen(1)
    client_socket,address = server_socket.accept()
    print("connection success!!")

GUI C'est autour de l'affichage à l'écran. J'ai utilisé tkinter.

#Créer une interface graphique
root = tkinter.Tk()
root.title("Soltvvo")
root.geometry("400x250")

grid = 20
offset = 50

entry = [[None for _ in range(8)] for _ in range(6)]

for i in range(6):
    for j in range(8):
        if 1 < i < 4 or 1 < j < 4:
            entry[i][j] = tkinter.Entry(master=root, width=2, bg='gray')
            entry[i][j].place(x = j * grid + offset, y = i * grid + offset)

inspection = tkinter.Button(root, text="inspection", command=inspection_p)
inspection.place(x=0, y=0)

solutionvar = tkinter.StringVar(master=root, value='')
solution = tkinter.Label(textvariable=solutionvar)
solution.place(x=120, y=0)

solvingtimevar = tkinter.StringVar(master=root, value='')
solvingtime = tkinter.Label(textvariable=solvingtimevar)
solvingtime.place(x=120, y=20)

grab = tkinter.Button(root, text="grab", command=grab_p)
grab.place(x=0, y=150)

release = tkinter.Button(root, text="release", command=release_p)
release.place(x=150, y=150)

calib = tkinter.Button(root, text='calibration', command=calibration)
calib.place(x=300, y=0)

start_slow = tkinter.Button(root, text="slow", command=start_slow_p)
start_slow.place(x=300, y=50)

start_medium = tkinter.Button(root, text="medium", command=start_medium_p)
start_medium.place(x=300, y=90)

start_fast = tkinter.Button(root, text="fast", command=start_fast_p)
start_fast.place(x=300, y=130)

start_superfast = tkinter.Button(root, text="super fast", command=start_superfast_p)
start_superfast.place(x=300, y=170)

root.mainloop()

De la reconnaissance de puzzle à la recherche de solutions

C'est la reconnaissance du puzzle, la recherche de la solution et le choix de la solution à adopter. Il y a une mise en garde ici. Ce robot fait tourner un puzzle à quatre bras. Par conséquent, sa résolution rapide ou non dépend de la direction du puzzle initial. Pour omettre les détails, vous pouvez rechercher une solution dans chacune des deux directions correctement sélectionnées et adopter une solution moins coûteuse (solution plus rapide). J'ai implémenté ceci

'''inspection'''
''' Inspection '''

def inspection_p():
    global solution
    #Initialisation
    solution = []
    solutionvar.set('')
    for i in range(6):
        for j in range(8):
            if 1 < i < 4 or 1 < j < 4:
                entry[i][j]['bg'] = 'gray'
    #Obtenez des informations de couleur dans l'orientation normale, recherchez une solution
    colors0 = detector()
    for i in range(6):
        for j in range(8):
            if 1 < i < 4 or 1 < j < 4:
                if colors0[i][j] != '':
                    entry[i][j]['bg'] = dic[colors0[i][j]]
                else:
                    entry[i][j]['bg'] = 'gray'
    with open('log.txt', mode='w') as f:
        f.write(str(colors0) + '\n')
    solution0, cost0 = solver(colors0)
    if solution0 == -1:
        print('cannot solve!')
        solutionvar.set('cannot solve!')
        return
    #Faites pivoter le puzzle de 90 degrés et recherchez à nouveau une solution
    colors1 = rotate_colors(colors0)
    solution1, cost1 = solver(colors1)
    #Adoptez une solution à faible coût
    if cost0 <= cost1:
        solution = solution0
        cost = cost0
        with open('log.txt', mode='a') as f:
            f.write('0\n')
    else:
        solution = solution1
        cost = cost1
        with open('log.txt', mode='a') as f:
            f.write('1\n')
        move_actuator(0, 0, -90, 200)
        move_actuator(1, 0, 90, 200)
        sleep(0.3)
    if solution == -1:
        solution = []
        print('cannot solve!')
        solutionvar.set('cannot solve!')
        return
    with open('log.txt', mode='a') as f:
        f.write(str(cost) + '\n')
        f.write(str(solution) + '\n')
    #Affichage du coût et du temps estimé
    solutionvar.set('cost: ' + str(cost) + ' ex: ' + str(round(cost * 0.083, 2)) + 's')
    #Prêt à faire tourner le puzzle
    grab = solution[0][0][0] % 2
    for j in range(2):
        move_actuator(j, grab, 1000)
    sleep(0.2)
    for j in range(2):
        move_actuator(j, (grab + 1) % 2, 2000)
    print(solution)

La fonction `` rotate_colors '' qui est sortie lors de la rotation du puzzle de 90 degrés est la suivante. Utilisez cette fonction pour remplacer les informations de couleur et représenter la rotation de l'ensemble du puzzle.

'''Faites pivoter virtuellement le puzzle'''
''' Rotate puzzle (don't rotate it in real world) '''

def rotate_colors(colors):
    #Remplacer les informations de couleur
    replace = [
        [[-1, -1], [-1, -1], [2, 2], [2, 3], [-1, -1], [-1, -1], [-1, -1], [-1, -1]],
        [[-1, -1], [-1, -1], [3, 2], [3, 3], [-1, -1], [-1, -1], [-1, -1], [-1, -1]],
        [[2, 1], [3, 1], [4, 2], [4, 3], [3, 4], [2, 4], [1, 3], [1, 2]],
        [[2, 0], [3, 0], [5, 2], [5, 3], [3, 5], [2, 5], [0, 3], [0, 2]],
        [[-1, -1], [-1, -1], [3, 7], [3, 6], [-1, -1], [-1, -1], [-1, -1], [-1, -1]],
        [[-1, -1], [-1, -1], [2, 7], [2, 6], [-1, -1], [-1, -1], [-1, -1], [-1, -1]]
    ]
    res = [['' for _ in range(8)] for _ in range(6)]
    for i in range(6):
        for j in range(8):
            if 1 < i < 4 or 1 < j < 4:
                res[replace[i][j][0]][replace[i][j][1]] = colors[i][j]
    return res

opération

Il y a quatre étapes de vitesse pour la conduite. Chaque fonction ne diffère que par l'argument de `` contrôleur ''.

'''opération'''
''' Drive '''

def start_slow_p():
    #conduite prudente
    # Slow
    global solution
    solutionvar.set(controller(0.15, 0.15, 300, 1.2, solution))
    solution = []

def start_medium_p():
    #Fonctionnement normal
    # Medium
    global solution
    solutionvar.set(controller(0.1, 0.1, 400, 1, solution))
    solution = []

def start_fast_p():
    #Conduite rapide
    # Fast
    global solution
    solutionvar.set(controller(0.095, 0.095, 550, 0.9, solution))
    solution = []

def start_superfast_p():
    #Conduite explosive
    # Super Fast
    global solution
    solutionvar.set(controller(0.1, 0.1, 600, 1, solution))
    solution = []

Résumé

Jusqu'à présent, j'ai sérialisé sept articles sur une semaine. Merci d'avoir lu jusqu'ici. Surtout, je pense que l'article sur la recherche de solutions sera utile pour quelqu'un. Veuillez commenter si cela est utile ou si le programme de l'article n'est pas très bon!

Logiciel mis à jour pour Rubik Cube Robot 7. Opérations clés