Sistemas_Embarcados_Fischer_Marina-7

Prévia do material em texto

MINISTÉRIO DA DEFESA
EXÉRCITO BRASILEIRO
DEPARTAMENTO DE CIÊNCIA E TECNOLOGIA
INSTITUTO MILITAR DE ENGENHARIA
CURSO DE GRADUAÇÃO EM ENGENHARIA DE COMPUTAÇÃO
1o Ten TAYNÁ LARISSA FISCHER VIEIRA
1o Ten MARINA PESSOA MOTA
RESOLVENDO UM CUBO MÁGICO COM UM SISTEMA EMBARCADO
Rio de Janeiro
2018
INSTITUTO MILITAR DE ENGENHARIA
1o Ten TAYNÁ LARISSA FISCHER VIEIRA
1o Ten MARINA PESSOA MOTA
RESOLVENDO UM CUBO MÁGICO COM UM SISTEMA
EMBARCADO
Orientador: Prof. PAULO FERNANDO FERREIRA ROSA -
D.Sc.
Rio de Janeiro
2018
c2018
INSTITUTO MILITAR DE ENGENHARIA
Praça General Tibúrcio, 80 - Praia Vermelha
Rio de Janeiro - RJ CEP 22290-270
Este exemplar é de propriedade do Instituto Militar de Engenharia, que poderá incluí-lo
em base de dados, armazenar em computador, microfilmar ou adotar qualquer forma de
arquivamento.
É permitida a menção, reprodução parcial ou integral e a transmissão entre bibliotecas
deste trabalho, sem modificação de seu texto, em qualquer meio que esteja ou venha a
ser fixado, para pesquisa acadêmica, comentários e citações, desde que sem finalidade
comercial e que seja feita a referência bibliográfica completa.
Os conceitos expressos neste trabalho são de responsabilidade do(s) autor(es) e do(s)
orientador(es).
004.69 VIEIRA, TAYN. LARISSA FISCHER
S586e Resolvendo um Cubo Mágico com um Sistema Em-
barcado / TAYNÁ LARISSA FISCHER VIEIRA, MA-
RINA PESSOA MOTA, orientado por PAULO FER-
NANDO FERREIRA ROSA - Rio de Janeiro: Instituto
Militar de Engenharia, 2018.
51p.: il.
Projeto de Fim de Curso (graduação) - Instituto
Militar de Engenharia, Rio de Janeiro, 2018.
1. Curso de Graduação em Engenharia de Compu-
tação - projeto da cadeira de sistemas embarcados. 1.
Rubik. 2. Lego. 3. Robô. I. ROSA, PAULO FER-
NANDO FERREIRA . II. Título. III. Instituto Militar
de Engenharia.
1
INSTITUTO MILITAR DE ENGENHARIA
1o Ten TAYNÁ LARISSA FISCHER VIEIRA
1o Ten MARINA PESSOA MOTA
RESOLVENDO UM CUBO MÁGICO COM UM SISTEMA
EMBARCADO
Orientador: Prof. PAULO FERNANDO FERREIRA ROSA - D.Sc.
Aprovado em de OUTUBRO de 2018 pela seguinte Banca Examinadora:
Prof. PAULO FERNANDO FERREIRA ROSA - D.Sc. do IME - Presidente
Rio de Janeiro
2018
2
Ao Instituto Militar de Engenharia, alicerce da minha formação e
aperfeiçoamento.
3
AGRADECIMENTOS
Agradeço a todas as pessoas que me incentivaram, apoiaram e possibilitaram esta
oportunidade de ampliar meus horizontes.
Meus familiares, cônjuge e mestres.
Em especial ao meu Professor Orientador Professor Paulo Rosa por sua disponibili-
dade e atenção.
4
“Sem publicação, a ciência é morta. ”
GERARD PIEL
5
SUMÁRIO
LISTA DE ILUSTRAÇÕES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.1 Motivação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Trabalhos Relacionados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Estrutura da Monografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 TÓPICOS TUTORIAIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1 Kit Lego Education EV3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2 Algoritmo de resolução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Bibliotecas de Python utilizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3 ENUNCIADO DO PROBLEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1 Formulação do Problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2 Premissas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Aparato Experimental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.4 Resultados Esperados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4 MATERIAIS E MÉTODOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.1 Levantamento de material . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.2 Organização Experimental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3 Simulações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5 EXPERIMENTOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.1 Programa para o Sistema Embarcado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.2 Dificuldades encontradas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.3 Validação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6 CONSIDERAÇÕES FINAIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.1 Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.2 Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7 REFERÊNCIAS BIBLIOGRÁFICAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6
8 ANEXO A - CÓDIGO DO PROGRAMA EM PYTHON . . . . . . . . . 32
7
LISTA DE ILUSTRAÇÕES
FIG.1.1 Cubestormer 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
FIG.1.2 Rubik’s Contraption . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
FIG.2.1 Kit LEGO Mindstorms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
FIG.2.2 Bloco de Programação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
FIG.2.3 Sensor de cor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
FIG.2.4 Passo 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
FIG.2.5 Passo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
FIG.2.6 Passo 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
FIG.2.7 Passo 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
FIG.2.8 Passo 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
FIG.2.9 Passo 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
FIG.2.10 Passo 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
FIG.2.11 Passo 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
FIG.3.1 Esboço do trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
FIG.3.2 Aparato Experimental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
FIG.5.1 Kit Representação do cubo no algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
8
RESUMO
O objetivo deste trabalho é adquirir e consolidar conhecimentos da áreade Sistemas
Embarcados. Para isso resolveremos o Cubo Mágico utilizando os kits educacionais de
Lego NXT e Lego EV3 com o algoritmo embarcado em Python. Como resultado, espera-se
que o robô resolva o cubo em torno de 5 minutos.
9
ABSTRACT
The objective of this work is to acquire and consolidate knowledge in the area of
Embedded Systems. For this we will solve the Magic Cube using the educational kits of
Lego NXT and Lego EV3 with the algorithm embarked in Python. As a result, the robot
is expected to resolve the cube in about 5 minutes.
10
1 INTRODUÇÃO
1.1 MOTIVAÇÃO
A motivação desse trabalho é adquirir e consolidar conhecimentos da área de Sistemas
Embarcados. Para isso, resolveremos o Cubo Mágico utilizando os kits educacionais de
Lego NXT e Lego EV3.
Resover o cubo mágico é um desafio até o momento em que se conhece um algoritmo.
Em um sistema embarcado o desafio é ajustar os sensores e servomotores para executarem
o algoritmo escolhido.
1.2 TRABALHOS RELACIONADOS
Como pesquisa inicial foram procurados trabalhos relacionados sobre o tema.
Algumas soluções para resolver o cubo mágico com sistemas embarcados já foram
propostas, discorreremos aqui sobre três delas. O primeiro trabalho publicado na área
foi o do professor David Singmaster, da universidade London South Bank. Ele publicou
a primeira análise matemática em 1981 no livro Notes on Rubik’s "Magic Cube", sua
solução resolve o cubo camada a camada e após muita prática, resolver o cubo dessa
forma pode ser feito em menos de um minuto. Inúmeras competições foram feitas para
decobrir quem era o mais rápido em revolver. [Singmaster (1979)] Hoje, o recorde humano
é 4,59 segundos.
Anos depois, a competição mudou. Com a robótica em alta, o objetivo se tornou
então criar robôs que solucionassem o cubo mágico. E mais rápido que o ser humano.
Um dos mais eficientes robôs que resolvem o cubo de Rubik é o Cubestormer 3 cujo
recorde é 3.253 segundos. O robô foi construído por Mike Dobson and David Gilday
utilizando o Lego Mindstorms e um celular Samsung 4. A arquitetora utilizada é a ARM
e o celular analiza os quadrados do cubo com um aplicativo que calcula o número correto
de movimentos para resolver o quebra-cabeças. [CNET (2014)]
O recorde atual é da máquina desenvolvida por Ben Katz and Jared DiCarlo no
laboratório de Biometics do MIT e é chamado por eles de "The new Rubik’s Contraption".
Eles conseguiram resolver o robô em 0.38 segundos em março de 2018.
11
FIG. 1.1: Cubestormer 3
Composto por uma combinação de câmeras e atuadores, o sftware dessa máquina é
programado para reconhecer as cores e retornar os lados corretos. Os seis motores são
Servodiscos Kollmorgen U9-series e as câmeras são dois PlayStation Eye. [Alert (2018)]
FIG. 1.2: Rubik’s Contraption
1.3 ESTRUTURA DA MONOGRAFIA
Este trabalho apresenta seis capítulos. O Capítulo 1, Introdução, discorre sobre a
mativação, os trabalhos relacionados ao tema e a estrutura da monografia.
No Capítulo 2, Tópicos tutoriais, encontram-se alguns conceitos utilizados no traba-
lho. Nele constam um estudo sobre o Kit Lego Education EV3, o algoritmo de resolução
do cubo mágico que foi utilizado e as bibliotecas de python usadas no código.
No Capítulo 3, Enuncioado do Problema, tem-se o problema, as premissas, o resultado
esperado e a metodologia.
No Capítulo 4, Materiais e Métodos, consta o levantamento dos materiais utilizados,
a descrição da organização experimental e as simulações realizadas.
No Capítulo 5, Experimentos, encontra-se a explicação do programa gerado para
solucionar o caso, as dificuldades encontradas e a validação dos resultados.
Por último, No Capítulo 6, Considerações Finais, encontra-se a conclusão e uma
proposta de trabalhos futuros.
12
2 TÓPICOS TUTORIAIS
2.1 KIT LEGO EDUCATION EV3
O Kit LEGO Mindstorms é composto por diversas peças para montagem de diferentes
sistemas. Abaixo encontra-se todas as peças do kit. Cerp (2014).
FIG. 2.1: Kit LEGO Mindstorms
Uma das peças mais importante é o bloco de programação. A linguagem nativa dele
é a ev3, mas ele aceita outras linguagens como python. Esse bloco é o sistema embarcado
que comandará todos os movimentos do robô. [FIG. 2.2]
FIG. 2.2: Bloco de Programação
Outra peça importante é o sensor de cor [FIG. 2.3]. Ele mostrará as cores de cada
quadrado da face do cubo mágico analisada e após a análise de todas as faces será possível
13
o cálculo das posições certas dos quadradinhos.
FIG. 2.3: Sensor de cor
2.2 ALGORITMO DE RESOLUÇÃO
Para resolver o cubo mágico existentem algumas técnicas. A que será utilizada nesse
trabalho será explicada abaixo. Cerp (2014)
Dada a configuração inicial deve-se realizar os movimentos para alcançar oitos passos
para atigir o objetico.A seguir tem a imagem e descrição de cada um dos passos, conside-
rando que será escolhido a face branca para iniciar a resolução. Esses passos são:
1o Passo: cruz branca.
FIG. 2.4: Passo 1
14
2o Passo: alinhar a cruz branca.
FIG. 2.5: Passo 2
3o Passo: finalizar a camada branca.
FIG. 2.6: Passo 3
4o Passo: finalizar a segunda camada.
FIG. 2.7: Passo 4
15
5o Passo: cruz amarela.
FIG. 2.8: Passo 5
6o Passo: face amarela.
FIG. 2.9: Passo 6
7o Passo: quina da última camada.
FIG. 2.10: Passo 7
16
8o Passo: meios da última camada.
FIG. 2.11: Passo 8
2.3 BIBLIOTECAS DE PYTHON UTILIZADAS
Para programar robôs criados com os kits de Lego educacional é possível usar uma
plataforma disponibilizada pela a Lego. Nessa plataforma o programa é escrito através da
concatenação de caixas, sendo casa uma dessa a representação de um movimento. Para
esse trabalho não será usada tal forma de programção. O programa do sistema embarcado
será escrito em Python, usando a biblioteca EV3 Python.
17
3 ENUNCIADO DO PROBLEMA
O Cubo de Rubik, também conhecido como cubo mágico, foi inventado pelo o húngaro
Ernö Rubik em 1974. O intuito da criação desse cubo foi ilustrar para o seus alunos o
conceito da tri dimensão, mostrando assim um objeto que rotacionasse as suas faces. Para
resolver esse pela a primeira vez seu criador demorou um mês.
A versão mais tradicional do cubo, que será a usada nesse trabalho, é 3x3x3, é com-
posta de seis faces com cores distintas. O desafio proposto por Rubik é, dado qualquer
configuração inicial do cubo o objetivo, rotacionar as suas faces até que cada uma esteja
apenas com uma cor.
O total de combinações possíveis para o cubo mágico é 43.252.003.274.859.000. Se
uma pessoa conseguisse alternar uma permutação a cada 1 segundo, demoraria 1400
trilhões de anos para realizar todas as combinações possíveis desse brinquedo.
O intuito desse trabalho é confeccionar um robô utilizando o material da edição NXT
da LEGO education, que solucione qualquer configuração inicial do cubo mágico.
3.1 FORMULAÇÃO DO PROBLEMA
Dado qualquer configuração inicial do cubo o objetivo é o robô efetuar movimentos
de forma que a configuração final seja todas as faces com uma única cor.
3.2 PREMISSAS
Este trabalho possui as seguintes premissas:
- Existe bibliotecas em python compatíveis com o bloco de programação do minds-
torms.
- Existe solução para qualquer combinação do cubo mágico.
- É possível resolver o cubo mágico com apenas um servomotor em torno de 5 minutos.
3.3 APARATO EXPERIMENTAL
O aparato experiemental é montado com as peças do kit LEGO Mindstorms.
Primeiro, foi montado uma base para apoiar o cubo mágico, sendo essa conectada a
um servomotor. Esse é um dos graus de movimento do cubo, onde o servomotor gira a
18
base no sentido horário ou anti-horário.
Outra forma de movimentar é através da garra construída, que também está sendo
guiada por um servomotor. Já o terceiro servomotor controla o sensor de cor.
A figura abaixo 3.1 representa um esboço do aparato experimental. Nele estão repre-
sentados a garra, o sensor, o bloco de programação e a área onde fica o cubo mágico.
FIG. 3.1: Esboço do trabalho
A figura seguinte mostra a montagem parcialdo aparato experimental, sem as cone-
xões do bloco de programação e os servomotores.
FIG. 3.2: Aparato Experimental
19
3.4 RESULTADOS ESPERADOS
Espera-se que ao final do projeto o robô resolva o cubo mágico em torno de 5 minutos.
Ao testar o algoritmo, levamos cerca de 15 minutos para resolver, mas com prático deve-se
conseguir resolver em menos de 1 minuto.
O robô será um pouco mais lento, pois só será utilizado um servomotor e o sensor
em apenas uma direção, ou seja, ele precisará trocar de face (girar o cubo) para executar
cada passo, enquanto o ser humano pode olhar todas as faces e trabalhar nelas sem girar
o cubo.
3.5 METODOLOGIA
Primeiro foram definidos os objetivos do projeto, bem como desenhado um esboço do
resultado esperado. Em seguida, foi levantado um estudo sobre os trabalhos relacionados.
Depois foi enunciado e problema e foram definidos os materiais necessários para a
resolução do projeto. Foram adquiridos os materiais que faltavam no laboratório de
Robótica do Instituto Militar de Engenharia.
O passo seguinte foi realizar um estudo sobre os tópicos tutoriais. Foi estudado como
utilizar os kits educacionais de Lego NXT e Lego EV3 e escolheu-se um algoritmo para
resolução do Cubo Mágico.
Montou-se o robô utilizando os kits LEGO e o código em Python com o algoritmo de
resolução foi escrito. Depois, foi realizados testes para validação do projeto.
20
4 MATERIAIS E MÉTODOS
4.1 LEVANTAMENTO DE MATERIAL
Na construção do Robô foi utilizado os kits educacionais de Lego NXT e Lego EV3
disponíveis no laboratório de Robótica do Instituto Militar de Engenharia. Dos kits serão
utilizados:
- peças dos kits educacionais de Lego NXT e Lego EV3 para montar a estrutura;
- uso de três servos motores dos kits educacionais;
- um bloco de programação, onde estará o sistema embarcado;
- um sensor de cor, para detectar as cores no cubo; e
- cabos RJ45 para conexão do bloco de programação com os servomotores e sensor.
- cartão microSD para o bloco de programção.
Foi necessária a aquisição dos seguintes materiais:
- 1 cubo Mágico da Rubik’s.
- 6 pilhas alcalinas Duracell.
4.2 ORGANIZAÇÃO EXPERIMENTAL
Para a organização experimental foi montado o aparato experimental explicado no
capítulo anterior. Nesse foi conectado o servormotor da base na saída D, o do sensor de
cor na saída C e o da garra na B. O sensor de cor foi conectado a porta 1.
No bloco de programação do Lego EV3 foi instalado, usando cartão SD, o firmware
do software do EV3DEV. Essa plataforma possibilita o uso de linguagens de programação
sem ser a convencional desenvolvida pela a Lego, que consiste de caixas educativas.
Para transferir o programa para o bloco de programação foi usado a comunicação
usando SSH pelo o terminal.
21
4.3 SIMULAÇÕES
Por se tratar de um projeto extenso o processo de simulação do sistema embarcado
foi divido em etapas, nas quais foram possíveis verificar o funcionamento de cada parte.
A primeira foi o teste do algoritmo de resolução em Python no computador. Para isso
era instanciado manualmente a configuração inicial do cubo no programa, e então esse
retornava os movimentos a serem executados. Esses eram representados por uma cor, o
operador então deveria rotacionar no sentido horário a face dessa cor.
A segunda etapa consistia de simular cada um dos movimentos necessários para o
funcionamento do robô. Esses movimentos serão explicados melhor no próximo capítulo.
E a terceira simular o funcionamento do robô ao tentar solucionar o cubo mágico.
22
5 EXPERIMENTOS
5.1 PROGRAMA PARA O SISTEMA EMBARCADO
Foi criado um programa em Python que usa o algoritmo explicado anteriormente para
resolução do cubo mágico e aplica tais movimentos no robô.
Para resolver o cubo mágico o primeiro passo é o robô identificar a posição inicial do
cubo. Para isso o intuito é usar o sensor de cor para scanear todas as faces na ordem:
branca, vermelha, amarela, laranja, azul e verde. E ao mesmo tempo instanciar a matriz
de cor que é identificada de acordo com a FIG 5.1. Vale lembrar que ao colocá-lo na base
é preciso posicionar a face branca para cima, e a vermelha na posição mais próxima do
sensor(essa é a posição inicial das cores que está instanciada no programa).
FIG. 5.1: Kit Representação do cubo no algoritmo
Agora que já está instanciado a posição inicial do cubo é possível calcular os movi-
mentos que devem ser executados para chegar ao objetivo. O algoritmo é o explicado no
capítulo anterior. Em que:
• 1o Passo e 2o Passo são executados na função solve_white_cross().
• 3o Passo é executado na função solve_white_corners().
• 4o Passo é executado na função solve_middle_layer().
23
• 5o Passo é executado na função solve_yellow_cross().
• 6o Passo, 7o Passo e 8o Passo são executados nas funções solve_yellow_corners(),
yellow_corner_orientation() e yellow_edges_colour_arrangement().
Todos os movimentos no cubo gerados pelo o algoritmo, são equivalentes a rotação
de 90o no sentido horário na face de certa cor. Vale resaltar que a cor da face é definida
pela a peça do meio, que nunca muda.
Agora será explicado cada movimento que o cubo executa. No esquema montado o
servomotor da base está conectado a saída D e o servomotor da garra a saída B. A garra
ela pode executar o movimento de descer que é abaixar até o cubo, de forma a prendê-lo
a base, e de subir que é voltar a posição anterior, tais movimentos podem ser realizados
pelas as funções a seguir:
def desce r ( ) :
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 , speed_sp = 500)
s l e e p (1 )
def sub i r ( ) :
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 , speed_sp = −500)
s l e e p (1 )
Para rotacionar uma face do cubo basta que essa esteja virada para o sentido da base,
deixar a garra pressionado o cubo(posição que se obtêm pela a função descer explicada
acima), e então girar a base 90o, pela a função a seguir:
def rotac ionar_90 ( ) :
base_motor = ev3 . LargeMotor ( ’ outD ’ )
base_motor . run_timed ( time_sp = 1000 , speed_sp = 245)
s l e e p (1 )
O outro movimento que a garra pode executar é o obtido pela a função alavancar()
a seguir. Nesse a garra que inicialmente está pressionando o cubo puxa um pouco para
trás, e em seguida volta. Esse movimento faz com que o cubo rotacione sobre a base,
mudando assim a face que está posicionada sobre essa.
def a lavancar ( ) :
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
24
garra_motor . run_timed ( time_sp = 150 , speed_sp = −500)
s l e e p (1 )
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 , speed_sp = 500)
Usando as funções alanvancar() e rotacionar_90() sem que a garra esteja pressi-
onando o cubo, é possível modificar a cor da face que está virada na base. Por isso
é necessário ter em qualquer momento o controle de qual face está para cada lado.
Para tal controle usa-se o vetor colors que inicialmente no início está instacioando com
colors = [′w′,′ r′,′ y′,′ o′,′ b′,′ g′]. Para controlar os movimentos das faces é usado as funções
rotate_color_alavanca() e rotate_colors_clock():
def ro tate_co lo r s_c lock ( ) :
global c o l o r s
aux = co l o r s [ 1 ]
c o l o r s [ 1 ] = c o l o r s [ 5 ]
c o l o r s [ 5 ] = aux
aux = co l o r s [ 5 ]
c o l o r s [ 5 ] = c o l o r s [ 3 ]
c o l o r s [ 3 ] = aux
aux = co l o r s [ 3 ]
c o l o r s [ 3 ] = c o l o r s [ 4 ]
c o l o r s [ 4 ] = aux
def rotate_color_alavanca ( ) :
global c o l o r s
aux = co l o r s [ 0 ]
c o l o r s [ 0 ] = c o l o r s [ 3 ]
c o l o r s [ 3 ] = aux
aux = co l o r s [ 0 ]
c o l o r s [ 0 ] = c o l o r s [ 1 ]
c o l o r s [ 1 ] = aux
aux = co l o r s [ 1 ]
c o l o r s [ 1 ] = c o l o r s [ 2 ]
c o l o r s [ 2 ] = aux
Então pode-se agora entender o movimento de girar 90o o cubo na cor c:
25
def r o t a t e_th i s c o l o r ( c ) :
i f c o l o r s [2]==c :
de s c e r ( )
rotac ionar_90 ( )
sub i r ( )
else :
change_color( c )
rotac ionar_90 ( )
sub i r ( )
Se a cor virada para a base já corresponde a desejada a garra desce, rotaciona 90o e
então sobe. Caso contrário primeiro muda para a cor virada para a base correta, através
da função change_color() a seguir, rotaciona 90o e em seguida sobe.
def change_color ( c ) :
global c o l o r s
i f c==co l o r s [ 0 ] :
d e s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
a lavancar ( )
rotate_color_alavanca ( )
e l i f c==co l o r s [ 1 ] :
d e s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
a lavancar ( )
rotate_color_alavanca ( )
a lavancar ( )
rotate_color_alavanca ( )
e l i f c==co l o r s [ 3 ] :
d e s c e r ( )
a lavancar ( )
26
rotate_color_alavanca ( )
e l i f c==co l o r s [ 4 ] :
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
de s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
e l i f c==co l o r s [ 5 ] :
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
de s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
5.2 DIFICULDADES ENCONTRADAS
Foi verificado, através de testes, que o sensor de cor não estava identificado correta-
mente as cores do cubo mágico em boa parte das vezes. Tal obstáculo impossibilitou o uso
desse sensor para a identificação da configuração inicial do robô. Uma forma de contornar
tal impecílio foi já instanciar no programa a configuração inicial de cada face. Como esse
problema foi identificado antes, a função scanear(), que tinha o intuito de instanciar a
matriz de cores, não foi codificada no programa.
Outra fato que ocasionou uma dificuldade foi a precisão dos movimentos dos servo-
motores. Usando o time_sp ∗ speed_sp corretos não era possível rotacionar exatamente
o que na teoria era para fazer. Ou seja, os servomotores não estavam calibrados corre-
tamente. Para produzir os movimentos foi testado pelo método da tentativa e erro os
valores de time_sp e speed_sp.
27
5.3 VALIDAÇÃO
A primeira etapa de de simulação, que consistia de testar o algoritmo de resolução do
cubo mágico foi concluída com sucesso. Pode-se fazer diversos teste e em todos obteve-se
uma solução de resolução do cubo mágico.
Na segunda etapa foi possível regular os valores de time_sp e de speed_sp em cada
um dos movimentos para obter o resultado esperado. Sendo que em alguns experimentos
não obtinha o resultado esperado. Nessa também foi verificado que o funcionamento do
sensor de cor não iria ser adequado, visto que na maioria das vezes identificava cores
erradas. Logo foi decidido abrir mão dessa parte como explicado anteriormente.
Na última etapa não foi possível conseguir que todos os passos fossem executados
corretamente todas as vezes. Sendo que um erro já ocasionava a não resolução correta
do cubo mágico, visto que o programa iria comportar como se tal movimento tivesse sido
executado de maneira correta.
28
6 CONSIDERAÇÕES FINAIS
6.1 CONCLUSÃO
Devidos a problemas no funcionamento do sensor e na calibração dos ângulos dos
motores não foi possível que todos os passos necessários para a resolução do cubo fossem
executados corretamente.
Como um erro já ocasionava a não resolução correta do cubo mágico, já que por
não utilizarmos o sensor não havia verificação de como estava o cubo e o algoritmo se
comportava como se o robô estivesse executando todos os passos, o robô não conseguiu
resolver corretamente o cubo.
Apesar disso, o objetivo de consolidar os conhecimentos da área de Sistemas Embar-
cados foi atigido, já que consegui-se embarcar um programa em python que manipulasse
os servomotores de um robô feito com LEGO.
6.2 TRABALHOS FUTUROS
Um trabalho futuro vem doo problema encontrado com o sensor de cor. Uma possível
forma de contornar essa situação é identificar a configuração inicial usando o celular. Para
isso pode-se tirar foto de cada face usando a câmera do celular, e então criar um programa
para identificar tais cores, em seguida instanciar o programa feito e executá-lo no bloco
de programação. Para a comunicação do celular com o bloco de programação pode-se
continuar usando SSH.
Outro trabalho futuro pode ser otimizar o algoritmo de resolução do cubo mágico
para realizar menos passos. Para isso basta avaliar os passos antes de enviar para o robô
executar. Isso é importante para melhorar o desempenho e rapidez na resolução. Tal
necessidade existe por exemplo nos momentos em que o programa manda o robô executar
três vezes o movimento de rotacionar 90o no sentido horário, seria bem mais simples
rotacionar 90o graus no sentido antihorário. Para isso ser possível, basta os movimentos do
robo ser armazenado em uma lista, ou seja, obteria uma lista com letras que representam
o movimento no sentido horário de uma face. Quando o próximo movimento corresponder
a rotação de uma face sem ser a da lista, o robô executa os movimentos da lista de forma
29
otimizada(se for 3 movimentos executa rotação no sentido antihorário e se for mais de 4
calcula o movimento otimizado módulo 4), e coloca a nova cor a lista.
Por último, pode-se propor pensar em um outro amparato experimental que possibilite
a movimentação do cubo em mais de um lugar, assim sendo possível otimizar o tempo de
resolução do cubo mágico.
30
7 REFERÊNCIAS BIBLIOGRÁFICAS
SCIENCE ALERT. This Robot Can Solve a Rubik’s Cube in Less Than Half
a Second. Disponível em: <https://www.sciencealert.com/robot-solves-rubiks-cube-
breaks-record-0-38-seconds-contraption>. Acesso em: 10 mar. de 2018.
CERP, R. O Segredo do Cubo Mágico. São Paulo: Cuber Brasil, 2014.
CNET. Lego robot sets new Rubik’s Cube world record. Disponível
em: <https://www.cnet.com/news/lego-robot-sets-new-rubiks-cube-world-record/>.
Acesso em: 18 mar. de 2014.
SINGMASTER, D. Notes on the "magic cube
. London: [s.n.], 1979.
31
8 ANEXO A - CÓDIGO DO PROGRAMA EM PYTHON
import ev3dev . ev3 as ev3
from time import s l e e p
linha_com_zeros = [ 0 ] ∗ 9
cubo = [ linha_com_zeros ]∗ 6 # white , red , ye l low , orange , b lue , green
c o l o r s = [ ’w ’ , ’ r ’ , ’ y ’ , ’ o ’ , ’ b ’ , ’ g ’ ]
cubo = [ [ ’ y ’ , ’ o ’ , ’ r ’ , ’w ’ , ’ b ’ , ’ r ’ , ’ y ’ , ’w ’ , ’w ’ ] ,
[ ’ b ’ , ’ r ’ , ’ y ’ , ’ o ’ , ’ r ’ , ’w ’ , ’ g ’ , ’ g ’ , ’ r ’ ] ,
[ ’ g ’ , ’ g ’ , ’ y ’ , ’ y ’ , ’ o ’ , ’ r ’ , ’ g ’ , ’ g ’ , ’ y ’ ] ,
[ ’ b ’ , ’ y ’ , ’ b ’ , ’w ’ , ’ r ’ , ’ b ’ , ’ o ’ , ’ g ’ , ’ o ’ ] ,
[ ’ b ’ , ’ r ’ , ’w ’ , ’ o ’ , ’ o ’ , ’w ’ , ’ y ’ , ’ b ’ , ’ b ’ ] ,
[ ’ o ’ , ’ b ’ , ’ g ’ , ’w ’ , ’ y ’ , ’ r ’ , ’w ’ , ’ o ’ , ’ g ’ ] ]
def d i sp lay_face ( f a c e ) :
for i in f a c e :
print ( i + "␣" )
print ( "\n" )
def swap ( ladoA , a , ladoB , b ) :
global cubo
aux = cubo [ ladoA ] [ a ]
cubo [ ladoA ] [ a ] = cubo [ ladoB ] [ b ]
cubo [ ladoB ] [ b ] = aux
def d i sp l ay_co l o r s ( ) :
global c o l o r s
for i in range ( 6 ) :
print ( c o l o r s [ i ] + "␣" )
print ( "\n" )
def ro tate_co lo r s_c lock ( ) :
global c o l o r s
32
aux = co l o r s [ 1 ]
c o l o r s [ 1 ] = c o l o r s [ 5 ]
c o l o r s [ 5 ] = aux
aux = co l o r s [ 5 ]
c o l o r s [ 5 ] = c o l o r s [ 3 ]
c o l o r s [ 3 ] = aux
aux = co l o r s [ 3 ]
c o l o r s [ 3 ] = c o l o r s [ 4 ]
c o l o r s [ 4 ] = aux
def rotate_color_alavanca ( ) :
global c o l o r s
aux = co l o r s [ 0 ]
c o l o r s [ 0 ] = c o l o r s [ 3 ]
c o l o r s [ 3 ] = aux
aux = co l o r s [ 0 ]
c o l o r s [ 0 ] = c o l o r s [ 1 ]
c o l o r s [ 1 ] = aux
aux = co l o r s [ 1 ]
c o l o r s [ 1 ] = c o l o r s [ 2 ]
c o l o r s [ 2 ] = aux
def desce r ( ) :
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 , speed_sp = 500)
s l e e p (1 )
def rotac ionar_90 ( ) :
base_motor = ev3 . LargeMotor ( ’ outD ’ )
base_motor . run_timed ( time_sp = 1000 , speed_sp = 245)
s l e e p (1 )
def sub i r ( ) :
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 ,speed_sp = =−500)
s l e e p (1 )
def a lavancar ( ) :
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 , speed_sp = −500)
33
s l e e p (1 )
garra_motor = ev3 . LargeMotor ( ’ outB ’ )
garra_motor . run_timed ( time_sp = 150 , speed_sp = 500)
def change_color ( c ) :
global c o l o r s
i f c==co l o r s [ 0 ] :
d e s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
a lavancar ( )
rotate_color_alavanca ( )
e l i f c==co l o r s [ 1 ] :
d e s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
a lavancar ( )
rotate_color_alavanca ( )
a lavancar ( )
rotate_color_alavanca ( )
e l i f c==co l o r s [ 3 ] :
d e s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
e l i f c==co l o r s [ 4 ] :
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
de s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
34
e l i f c==co l o r s [ 5 ] :
rotac ionar_90 ( )
ro tate_co lo r s_c lock ( )
de s c e r ( )
a lavancar ( )
rotate_color_alavanca ( )
def r o t a t e_th i s c o l o r ( c ) :
i f c o l o r s [2]==c :
de s c e r ( )
rotac ionar_90 ( )
sub i r ( )
else :
change_color ( c )
rotac ionar_90 ( )
sub i r ( )
def rotate_c lock ( cho i c e ) :
i f cho i c e==’w ’ :
#pr in t ("White\n")
r o t a t e_th i s c o l o r ( ’w ’ )
swap (0 , 7 , 0 , 3 )
swap (0 , 6 , 0 , 4 )
swap (0 , 0 , 0 , 2 )
swap (0 , 7 , 0 , 5 )
swap (0 , 0 , 0 , 4 )
swap (0 , 1 , 0 , 3 )
#−−−−−−−−−−−−−−−−−−−−−−−−−
swap (4 , 0 , 3 , 0 )
swap (4 , 7 , 3 , 7 )
swap (4 , 6 , 3 , 6 )
swap (3 , 6 , 5 , 6 )
swap (3 , 7 , 5 , 7 )
swap (3 , 0 , 5 , 0 )
swap (5 , 6 , 1 , 6 )
swap (5 , 7 , 1 , 7 )
swap (5 , 0 , 1 , 0 )
#−−−−−−−−−−−−−−−−−−−−−−−−−
e l i f cho i c e==’ r ’ :
#pr in t ("Red\n")
35
r o t a t e_th i s c o l o r ( ’ r ’ )
swap (1 , 0 , 1 , 4 )
swap (1 , 7 , 1 , 5 )
swap (1 , 1 , 1 , 3 )
swap (1 , 0 , 1 , 6 )
swap (1 , 1 , 1 , 5 )
swap (1 , 2 , 1 , 4 )
#−−−−−−−−−−−−−−−−−−−−−−−−−
swap (4 , 6 , 0 , 3 )
swap (4 , 5 , 0 , 2 )
swap (4 , 4 , 0 , 1 )
swap (0 , 1 , 5 , 0 )
swap (0 , 2 , 5 , 1 )
swap (0 , 3 , 5 , 2 )
swap (5 , 0 , 2 , 3 )
swap (5 , 1 , 2 , 2 )
swap (5 , 2 , 2 , 1 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
#−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
e l i f cho i c e==’y ’ :
#pr in t (" Yel low\n")
r o t a t e_th i s c o l o r ( ’ y ’ )
swap (2 , 1 , 2 , 5 )
swap (2 , 2 , 2 , 4 )
swap (2 , 0 , 2 , 6 )
swap (2 , 1 , 2 , 3 )
swap (2 , 0 , 2 , 4 )
swap (2 , 7 , 2 , 5 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
swap (4 , 4 , 1 , 4 )
swap (4 , 3 , 1 , 3 )
swap (4 , 2 , 1 , 2 )
swap (1 , 2 , 5 , 2 )
swap (1 , 3 , 5 , 3 )
swap (1 , 4 , 5 , 4 )
swap (5 , 4 , 3 , 4 )
swap (5 , 3 , 3 , 3 )
swap (5 , 2 , 3 , 2 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
#−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
e l i f cho i c e==’ o ’ :
36
#pr in t ("Orange\n")
r o t a t e_th i s c o l o r ( ’ o ’ )
swap (3 , 4 , 3 , 0 )
swap (3 , 3 , 3 , 1 )
swap (3 , 5 , 3 , 7 )
swap (3 , 4 , 3 , 2 )
swap (3 , 5 , 3 , 1 )
swap (3 , 6 , 3 , 0 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
swap (4 , 2 , 2 , 5 )
swap (4 , 1 , 2 , 6 )
swap (4 , 0 , 2 , 7 )
swap (2 , 5 , 5 , 6 )
swap (2 , 6 , 5 , 5 )
swap (2 , 7 , 5 , 4 )
swap (5 , 6 , 0 , 7 )
swap (5 , 5 , 0 , 6 )
swap (5 , 4 , 0 , 5 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
#−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
e l i f cho i c e==’ g ’ :
#pr in t ("Green\n")
r o t a t e_th i s c o l o r ( ’ g ’ )
swap (5 , 6 , 5 , 2 )
swap (5 , 5 , 5 , 3 )
swap (5 , 7 , 5 , 1 )
swap (5 , 4 , 5 , 6 )
swap (5 , 7 , 5 , 3 )
swap (5 , 0 , 5 , 2 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
swap (0 , 5 , 3 , 2 )
swap (0 , 4 , 3 , 1 )
swap (0 , 3 , 3 , 0 )
swap (2 , 3 , 3 , 2 )
swap (2 , 4 , 3 , 1 )
swap (2 , 5 , 3 , 0 )
swap (2 , 3 , 1 , 6 )
swap (2 , 4 , 1 , 5 )
swap (2 , 5 , 1 , 4 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
#−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
37
e l i f cho i c e==’b ’ :
#pr in t (" Blue\n")
r o t a t e_th i s c o l o r ( ’b ’ )
swap (4 , 1 , 4 , 7 )
swap (4 , 2 , 4 , 6 )
swap (4 , 5 , 4 , 3 )
swap (4 , 2 , 4 , 0 )
swap (4 , 7 , 4 , 3 )
swap (4 , 6 , 4 , 4 )
#−−−−−−−−−−−−−−−−−−−−−−−−−−
swap (2 , 1 , 3 , 4 )
swap (2 , 0 , 3 , 5 )
swap (2 , 7 , 3 , 6 )
swap (0 , 7 , 3 , 4 )
swap (0 , 0 , 3 , 5 )
swap (0 , 1 , 3 , 6 )
swap (0 , 7 , 1 , 0 )
swap (0 , 0 , 1 , 1 )
swap (0 , 1 , 1 , 2 )
def white_bottom (q ) :
global cubo
i f ( cubo [2 ] [ 0 ]== ’w ’ and cubo [4 ] [ 3 ]==q) or ( cubo [2 ] [ 2 ]== ’w ’ and cubo [1 ] [ 3 ]==q) or
( cubo [2 ] [ 4 ]== ’w ’ and cubo [5 ] [ 3 ]==q) or ( cubo [2 ] [ 6 ]== ’w ’ and cubo [3 ] [ 3 ]==q) :
i f q==’b ’ :
while cubo [ 4 ] [ 3 ] ! = q or cubo [ 2 ] [ 0 ] ! = ’w ’ :
ro tate_c lock ( ’ y ’ )
i f q==’ r ’ :
while cubo [ 1 ] [ 3 ] ! = q or cubo [ 2 ] [ 2 ] ! = ’w ’ :
ro tate_c lock ( ’ y ’ )
i f q!= ’b ’ :
while cubo [ 0 ] [ 0 ] ! = ’w ’ and cubo [ 4 ] [ 7 ] ! = ’b ’ :
ro tate_c lock ( ’w ’ )
i f q==’ g ’ :
while cubo [ 5 ] [ 3 ] ! = q or cubo [ 2 ] [ 4 ] ! = ’w ’ :
ro tate_c lock ( ’ y ’ )
i f q!= ’b ’ :
while cubo [ 0 ] [ 0 ] ! = ’w ’ and cubo [ 4 ] [ 7 ] ! = ’b ’ :
ro tate_c lock ( ’w ’ )
i f q==’ o ’ :
while cubo [ 3 ] [ 3 ] ! = q or cubo [ 2 ] [ 6 ] ! = ’w ’ :
38
rotate_c lock ( ’ y ’ )
i f q!= ’b ’ :
while cubo [ 0 ] [ 0 ] ! = ’w ’ and cubo [ 4 ] [ 7 ] ! = ’b ’ :
ro tate_c lock ( ’w ’ )
rotate_c lock (q )
rotate_c lock (q )
def r ight_alg ( a , c ) :
ro tate_c lock ( a )
rotate_c lock ( a )
rotate_c lock ( a )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( a )
white_bottom ( c )
def white_right (q ) :
global cubo
i f cubo [4 ] [ 1 ]== ’w ’ or cubo [1 ] [ 1 ]== ’w ’ or cubo [5 ] [ 1 ]== ’w ’ or cubo [3 ] [ 1 ]== ’w ’ :
i f cubo [4 ] [ 5 ]==q and cubo [1 ] [ 1 ]== ’w ’ :
r ight_alg ( ’b ’ , q )
i f cubo [1 ] [ 5 ]==q and cubo [5 ] [ 1 ]== ’w ’ :
r ight_alg ( ’ r ’ , q )
i f cubo [5 ] [ 5 ]==q and cubo [3 ] [ 1 ]== ’w ’ :
r ight_alg ( ’ g ’ , q )
i f cubo [3 ] [ 5 ]==q and cubo [4 ] [ 1 ]== ’w ’ :
r ight_alg ( ’ o ’ , q )
def l e f t_a l g (a , c ) :
ro tate_c lock ( a )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( a )
rotate_c lock ( a )
rotate_c lock ( a )
white_bottom ( c )
39
def whi te_le f t ( q ) :
global cubo
i f cubo [4 ] [ 5 ]== ’w ’ or cubo [1 ] [ 5 ]== ’w ’ or cubo [5 ] [ 5 ]== ’w ’ or cubo [3 ] [ 5 ]== ’w ’ :
i f cubo [4 ] [ 5 ]== ’w ’ and cubo [1 ] [ 1 ]==q :
l e f t_a l g ( ’ r ’ , q )
i f cubo [1 ] [ 5 ]== ’w ’ and cubo [5 ] [ 1 ]==q :
l e f t_a l g ( ’ g ’ , q )
i f cubo [5 ] [ 5 ]== ’w ’ and cubo [3 ] [ 1 ]==q :
l e f t_a l g ( ’ o ’ , q )
i f cubo [3 ] [ 5 ]== ’w ’ and cubo [4 ] [ 1 ]==q :
l e f t_a l g ( ’b ’ , q )
def top_alg ( a , b , c ) :
ro tate_c lock ( a )
rotate_c lock ( a )
rotate_c lock ( a )
rotate_c lock ( ’w ’ )
rotate_c lock (b)
rotate_c lock ( ’w ’ )
rotate_c lock ( ’w ’ )
rotate_c lock ( ’w ’ )
white_bottom ( c )
def white_top (q ) :
global cubo
i f cubo [4 ] [ 7 ]== ’w ’ and cubo [0 ] [ 0 ]==q :
top_alg ( ’b ’ , ’ r ’ , q )
i f cubo [1 ] [ 7 ]== ’w ’ and cubo [0 ] [ 2 ]==q :
top_alg ( ’ r ’ , ’ g ’ , q )
i f cubo [5 ] [ 7 ]== ’w ’ and cubo [0 ] [ 4 ]==q :
top_alg ( ’ g ’ , ’ o ’ , q )
i f cubo [3 ] [ 7 ]== ’w ’ and cubo [0 ] [ 6 ]==q :
top_alg ( ’ o ’ , ’ b ’ , q )
def inv_alg ( a , b , c ) :
ro tate_c lock ( a )
rotate_c lock (b)
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
40
rotate_c lock ( ’ y ’ )
rotate_c lock (b)
rotate_c lock (b)
rotate_c lock (b)
rotate_c lock ( a )
rotate_c lock ( a )
rotate_c lock ( a )
white_bottom ( c )
def white_bottom_inverted (q ) :
global cubo
i f cubo [4 ] [ 3 ]== ’w ’ or cubo [1 ] [ 3 ]== ’w ’ or cubo [5 ] [ 3 ]== ’w ’ or cubo [3 ] [ 3 ]== ’w ’ :
i f cubo [4 ] [ 3 ]== ’w ’ and cubo [2 ] [ 0 ]==q :
inv_alg ( ’b ’ , ’ r ’ , q )
i f cubo [1 ] [ 3 ]== ’w ’ and cubo [2 ] [ 2 ]==q :
inv_alg ( ’ r ’ , ’ g ’ , q )
i f cubo [5 ] [ 3 ]== ’w ’ and cubo[2 ] [ 4 ]==q :
inv_alg ( ’ g ’ , ’ o ’ , q )
i f cubo [3 ] [ 3 ]== ’w ’ and cubo [2 ] [ 6 ]==q :
inv_alg ( ’ o ’ , ’ b ’ , q )
def so lve_white_cross ( ) :
global cubo
p r e f e r= [ ’b ’ , ’ r ’ , ’ g ’ , ’ o ’ ]
for i in range ( 4 ) :
i f cubo [0 ] [ 0 ]== ’w ’ and cubo [4 ] [ 7 ]== p r e f e r [ i ] :
ro tate_c lock ( ’b ’ )
i f cubo [0 ] [ 2 ]== ’w ’ and cubo [1 ] [ 7 ]== p r e f e r [ i ] :
ro tate_c lock ( ’ r ’ )
i f cubo [0 ] [ 4 ]== ’w ’ and cubo [5 ] [ 7 ]== p r e f e r [ i ] :
ro tate_c lock ( ’ g ’ )
i f cubo [0 ] [ 6 ]== ’w ’ and cubo [3 ] [ 7 ]== p r e f e r [ i ] :
ro tate_c lock ( ’ o ’ )
white_bottom ( p r e f e r [ i ] )
white_bottom_inverted ( p r e f e r [ i ] )
wh i t e_le f t ( p r e f e r [ i ] )
white_right ( p r e f e r [ i ] )
white_top ( p r e f e r [ i ] )
41
i f i !=0:
while cubo [ 4 ] [ 7 ] ! = ’b ’ :
ro tate_c lock ( ’w ’ )
i f cubo [0 ] [ 0 ]== ’w ’ and cubo [0 ] [ 2 ]== ’w ’ and cubo [0 ] [ 4 ]== ’w ’ and cubo [0 ] [ 6 ]== ’w ’ and
cubo [4 ] [ 7 ]== ’b ’ and cubo [1 ] [ 7 ]== ’ r ’ and cubo [5 ] [ 7 ]== ’ g ’ and cubo [3 ] [ 7 ]== ’ o ’ :
break
def white_corners_alg_le f t ( ) :
ro tate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’b ’ )
def white_corners_alg_right ( ) :
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ y ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
def so lve_white_corners ( ) :
global cubo
while cubo [ 1 ] [ 0 ] ! = ’ r ’ or cubo [ 1 ] [ 6 ] ! = ’ r ’ or cubo [ 4 ] [ 0 ] ! = ’b ’ or cubo [ 4 ] [ 6 ] ! = ’b ’ or
cubo [ 3 ] [ 0 ] ! = ’ o ’ or cubo [ 3 ] [ 6 ] ! = ’ o ’ or cubo [ 5 ] [ 0 ] ! = ’ g ’ or cubo [ 5 ] [ 6 ] ! = ’ g ’ :
while cubo [ 1 ] [ 7 ] ! = ’ r ’ :
ro tate_c lock ( ’w ’ )
i f cubo [4 ] [ 4 ]== ’w ’ or cubo [1 ] [ 4 ]== ’w ’ or cubo [5 ] [ 4 ]== ’w ’ or cubo [3 ] [ 4 ]== ’w ’ :
while cubo [ 4 ] [ 4 ] ! = ’w ’ :
ro tate_c lock ( ’ y ’ )
while cubo [ 1 ] [ 2 ] ! = cubo [ 1 ] [ 7 ] :
ro tate_c lock ( ’w ’ )
white_corners_alg_le f t ( )
while cubo [ 1 ] [ 7 ] ! = ’ r ’ :
ro tate_c lock ( ’w ’ )
e l i f cubo [4 ] [ 2 ]== ’w ’ or cubo [1 ] [ 2 ]== ’w ’ or cubo [5 ] [ 2 ]== ’w ’ or cubo [3 ] [ 2 ]== ’w ’ :
while cubo [ 1 ] [ 2 ] ! = ’w ’ :
42
rotate_c lock ( ’ y ’ )
while cubo [ 1 ] [ 7 ] ! = cubo [ 2 ] [ 1 ] :
ro tate_c lock ( ’w ’ )
white_corners_alg_right ( )
while cubo [ 1 ] [ 7 ] ! = ’ r ’ :
ro tate_c lock ( ’w ’ )
e l i f cubo [2 ] [ 1 ]== ’w ’ or cubo [2 ] [ 3 ]== ’w ’ or cubo [2 ] [ 5 ]== ’w ’ or cubo [2 ] [ 7 ]== ’w ’ :
while cubo [ 2 ] [ 1 ] ! = ’w ’ :
ro tate_c lock ( ’ y ’ )
while cubo [ 1 ] [ 2 ] ! = cubo [ 4 ] [ 7 ] :
ro tate_c lock ( ’w ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’b ’ )
while cubo [ 4 ] [ 4 ] ! = ’w ’ :
ro tate_c lock ( ’ y ’ )
while cubo [ 1 ] [ 2 ] ! = cubo [ 1 ] [ 7 ] :
ro tate_c lock ( ’w ’ )
white_corners_alg_le f t ( )
while ( cubo [ 1 ] [ 7 ] ! = ’ r ’ ) :
ro tate_c lock ( ’w ’ )
else :
while cubo [1 ] [ 7 ]== cubo [ 1 ] [ 0 ] :
ro tate_c lock ( ’w ’ )
white_corners_alg_le f t ( )
while cubo [ 1 ] [ 7 ] ! = ’ r ’ :
ro tate_c lock ( ’w ’ )
def middle_place_left_alg ( l e f t , c en t e r ) :
ro tate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( l e f t )
rotate_c lock ( l e f t )
rotate_c lock ( l e f t )
rotate_c lock ( ’ y ’ )
rotate_c lock ( l e f t )
rotate_c lock ( ’ y ’ )
43
rotate_c lock ( c ente r )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( c ente r )
rotate_c lock ( c ente r )
rotate_c lock ( c ente r )
def middle_place_right_alg ( center , r i g h t ) :
ro tate_c lock ( ’ y ’ )
rotate_c lock ( r i g h t )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( r i g h t )
rotate_c lock ( r i g h t )
rotate_c lock ( r i g h t )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( c ente r )
rotate_c lock ( c ente r )
rotate_c lock ( c ente r )
rotate_c lock ( ’ y ’ )
rotate_c lock ( c ente r )
def solve_middle_layer ( ) :
global cubo
while cubo [ 1 ] [ 5 ] ! = ’ r ’ or cubo [ 1 ] [ 1 ] ! = ’ r ’ or cubo [ 4 ] [ 1 ] ! = ’b ’ or cubo [ 4 ] [ 5 ] ! = ’b ’ or
cubo [ 3 ] [ 1 ] ! = ’ o ’ or cubo [ 3 ] [ 5 ] ! = ’ o ’ or cubo [ 5 ] [ 1 ] ! = ’ g ’ or cubo [ 5 ] [ 5 ] ! = ’ g ’ :
i f ( cubo [ 3 ] [ 1 ] ! = ’ o ’ and cubo [ 5 ] [ 5 ] ! = ’ g ’ ) and ( cubo [ 3 ] [ 1 ] ! = ’ y ’ or cubo [ 5 ] [ 5 ] ! = ’ y ’ ) :
while cubo [ 5 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 4 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
middle_place_right_alg ( ’ g ’ , ’ o ’ )
e l i f ( cubo [ 3 ] [ 5 ] ! = ’ o ’ and cubo [ 4 ] [ 1 ] ! = ’b ’ ) and ( cubo [ 3 ] [ 5 ] ! = ’ y ’ or cubo [ 4 ] [ 1 ] ! = ’ y ’ ) :
while cubo [ 3 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 6 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
middle_place_right_alg ( ’ o ’ , ’ b ’ )
44
e l i f ( cubo [ 4 ] [ 5 ] ! = ’b ’ and cubo [ 1 ] [ 1 ] ! = ’ r ’ ) and ( cubo [ 4 ] [ 5 ] ! = ’ y ’ or cubo [ 1 ] [ 1 ] ! = ’ y ’ ) :
while ( cubo [ 4 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 0 ] ! = ’ y ’ ) :
ro tate_c lock ( ’ y ’ )
middle_place_right_alg ( ’b ’ , ’ r ’ )
e l i f ( cubo [ 1 ] [ 5 ] ! = ’ r ’ and cubo [ 5 ] [ 1 ] ! = ’ g ’ ) and ( cubo [ 1 ] [ 5 ] ! = ’ y ’ or cubo [ 5 ] [ 1 ] ! = ’ y ’ ) :
while cubo [ 1 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 2 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
middle_place_right_alg ( ’ r ’ , ’ g ’ )
while cubo [1 ] [ 3 ]== ’y ’ or cubo [2 ] [ 2 ]== ’y ’ :
ro tate_c lock ( ’ y ’ )
i f cubo [1 ] [ 3 ]== ’ r ’ and cubo [ 2 ] [ 2 ] ! = ’ y ’ :
i f cubo [2 ] [ 2 ]== ’ g ’ :
middle_place_right_alg ( ’ r ’ , ’ g ’ )
e l i f cubo [2 ] [ 2 ]== ’b ’ :
middle_place_left_alg ( ’b ’ , ’ r ’ )
e l i f cubo [1 ] [ 3 ]== ’b ’ and cubo [ 2 ] [ 2 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
i f cubo [2 ] [ 0 ]== ’ r ’ :
middle_place_right_alg ( ’b ’ , ’ r ’ )
e l i f cubo [2 ] [ 0 ]== ’ o ’ :
middle_place_left_alg ( ’ o ’ , ’ b ’ )
e l i f cubo [1 ] [ 3 ]== ’ o ’ and cubo [ 2 ] [ 2 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ ) ; ro tate_c lock ( ’ y ’ )
i f cubo [2 ] [ 6 ]== ’b ’ :
middle_place_right_alg ( ’ o ’ , ’ b ’ )
e l i f cubo [2 ] [ 6 ]== ’ g ’ :
middle_place_left_alg ( ’ g ’ , ’ o ’ )
e l i f cubo [1 ] [ 3 ]== ’ g ’ and cubo [ 2 ] [ 2 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ ) ; ro tate_c lock ( ’ y ’ ) ; ro tate_c lock ( ’ y ’ )
i f cubo [2 ] [ 4 ]== ’ o ’ :
middle_place_right_alg ( ’ g ’ , ’ o ’ )
e l i f cubo [2 ] [ 4 ]== ’ r ’ :
middle_place_left_alg ( ’ r ’ , ’ g ’ )
45
def yel low_cross_algor ithm ( ) :
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ y ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
def so lve_yel low_cross ( ) :
global cubo
while cubo [ 2 ] [ 0 ] ! = ’ y ’ or cubo [ 2 ] [ 2 ] ! = ’ y ’ or cubo [ 2 ] [ 4 ] ! = ’ y ’ or cubo [ 2 ] [ 6 ] ! = ’ y ’ :
i f ( cubo [2 ] [ 0 ]== ’y ’ and cubo [2 ] [ 6 ]== ’y ’ ) or ( cubo [2 ] [ 4 ]== ’y ’ and cubo [2 ] [ 6 ]== ’y ’ )or ( cubo [2 ] [ 2 ]== ’y ’ and cubo [2 ] [ 4 ]== ’y ’ ) or ( cubo [2 ] [ 0 ]== ’y ’ and cubo [2 ] [ 2 ]== ’y ’ ) :
while cubo [ 2 ] [ 0 ] ! = ’ y ’ and cubo [ 2 ] [ 6 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_cross_algor ithm ( )
i f ( cubo [2 ] [ 2 ]== ’y ’ and cubo [2 ] [ 6 ]== ’y ’ ) or ( cubo [2 ] [ 0 ]== ’y ’ and cubo [2 ] [ 4 ]== ’y ’ ) :
while cubo [ 2 ] [ 0 ] ! = ’ y ’ and cubo [ 2 ] [ 4 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_cross_algor ithm ( )
yel low_cross_algor ithm ( )
e l i f cubo [2 ] [ 8 ]== ’y ’ :
ye l low_cross_algor ithm ( )
rotate_c lock ( ’ y ’ )
ye l low_cross_algor ithm ( )
yel low_cross_algor ithm ( )
def yellow_corners_algor ithm ( ) :
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ g ’ )
46
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
def so lve_yel low_corners ( ) :
while cubo [ 2 ] [ 1 ] ! = ’ y ’ or cubo [ 2 ] [ 3 ] ! = ’ y ’ or cubo [ 2 ] [ 5 ] ! = ’ y ’ or cubo [ 2 ] [ 7 ] ! = ’ y ’ :
i f ( cubo [2 ] [ 1 ]== ’y ’ and cubo [ 2 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 5 ] ! = ’ y ’ and cubo [ 2 ] [ 7 ] ! = ’ y ’ ) or
( cubo [2 ] [ 3 ]== ’y ’ and cubo [ 2 ] [ 1 ] ! = ’ y ’ and cubo [ 2 ] [ 5 ] ! = ’ y ’ and cubo [ 2 ] [ 7 ] ! = ’ y ’ ) or
( cubo [2 ] [ 5 ]== ’y ’ and cubo [ 2 ] [ 1 ] ! = ’ y ’ and cubo [ 2 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 7 ] ! = ’ y ’ ) or
( cubo [2 ] [ 7 ]== ’y ’ and cubo [ 2 ] [ 1 ] ! = ’ y ’ and cubo [ 2 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 5 ] ! = ’ y ’ ) :
while cubo [ 2 ] [ 1 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corners_algor ithm ( )
e l i f ( cubo [5 ] [ 2 ]== ’y ’ and cubo [5 ] [ 4 ]== ’y ’ and cubo [2 ] [ 1 ]== ’y ’ and cubo [2 ] [ 7 ]== ’y ’ )
or ( cubo [3 ] [ 2 ]== ’y ’ and cubo [3 ] [ 4 ]== ’y ’ and cubo [2 ] [ 1 ]== ’y ’ and cubo [2 ] [ 3 ]== ’y ’ ) or
( cubo [4 ] [ 2 ]== ’y ’ and cubo [4 ] [ 4 ]== ’y ’ and cubo [2 ] [ 3 ]== ’y ’ and cubo [2 ] [ 5 ]== ’y ’ ) or
( cubo [1 ] [ 2 ]== ’y ’ and cubo [1 ] [ 4 ]== ’y ’ and cubo [2 ] [ 5 ]== ’y ’ and cubo [2 ] [ 7 ]== ’y ’ ) :
while cubo [ 1 ] [ 2 ] ! = ’ y ’ and cubo [ 1 ] [ 4 ] ! = ’ y ’ and cubo [ 2 ] [ 5 ] ! = ’ y ’ and cubo [ 2 ] [ 7 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corners_algor ithm ( )
e l i f ( cubo [1 ] [ 4 ]== ’y ’ and cubo [3 ] [ 2 ]== ’y ’ and cubo [2 ] [ 1 ]== ’y ’ and cubo [2 ] [ 7 ]== ’y ’ )
or ( cubo [4 ] [ 2 ]== ’y ’ and cubo [5 ] [ 4 ]== ’y ’ and cubo [2 ] [ 1 ]== ’y ’ and cubo [2 ] [ 3 ]== ’y ’ ) or
( cubo [1 ] [ 2 ]== ’y ’ and cubo [3 ] [ 4 ]== ’y ’ and cubo [2 ] [ 3 ]== ’y ’ and cubo [2 ] [ 5 ]== ’y ’ ) or
( cubo [4 ] [ 4 ]== ’y ’ and cubo [5 ] [ 2 ]== ’y ’ and cubo [2 ] [ 5 ]== ’y ’ and cubo [2 ] [ 7 ]== ’y ’ ) :
while cubo [ 1 ] [ 2 ] ! = ’ y ’ and cubo [ 3 ] [ 4 ] ! = ’ y ’ and cubo [ 2 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 5 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corners_algor ithm ( )
e l i f ( cubo [5 ] [ 2 ]== ’y ’ and cubo [5 ] [ 4 ]== ’y ’ and cubo [4 ] [ 2 ]== ’y ’ and cubo [4 ] [ 4 ]== ’y ’ )
or ( cubo [1 ] [ 2 ]== ’y ’ and cubo [1 ] [ 4 ]== ’y ’ and cubo [3 ] [ 2 ]== ’y ’ and cubo [3 ] [ 4 ]== ’y ’ ) :
while cubo [ 5 ] [ 2 ] ! = ’ y ’ and cubo [ 5 ] [ 4 ] ! = ’ y ’ and cubo [ 4 ] [ 2 ] ! = ’ y ’ and cubo [ 4 ] [ 4 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corners_algor ithm ( )
47
e l i f ( cubo [5 ] [ 2 ]== ’y ’ and cubo [3 ] [ 2 ]== ’y ’ and cubo [3 ] [ 4 ]== ’y ’ and cubo [4 ] [ 4 ]== ’y ’ )
or ( cubo [1 ] [ 4 ]== ’y ’ and cubo [3 ] [ 2 ]== ’y ’ and cubo [4 ] [ 2 ]== ’y ’ and cubo [4 ] [ 4 ]== ’y ’ ) or
( cubo [1 ] [ 2 ]== ’y ’ and cubo [1 ] [ 4 ]== ’y ’ and cubo [5 ] [ 4 ]== ’y ’ and cubo [4 ] [ 2 ]== ’y ’ ) or
( cubo [5 ] [ 2 ]== ’y ’ and cubo [5 ] [ 4 ]== ’y ’ and cubo [3 ] [ 4 ]== ’y ’ and cubo [1 ] [ 2 ]== ’y ’ ) :
while cubo [ 5 ] [ 2 ] ! = ’ y ’ and cubo [ 3 ] [ 2 ] ! = ’ y ’ and cubo [ 3 ] [ 4 ] ! = ’ y ’ and cubo [ 4 ] [ 4 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corners_algor ithm ( )
e l i f ( cubo [2 ] [ 1 ]== ’y ’ and cubo [2 ] [ 5 ]== ’y ’ and cubo [ 2 ] [ 3 ] ! = ’ y ’ and cubo [ 2 ] [ 7 ] ! = ’ y ’ )
or ( cubo [2 ] [ 3 ]== ’y ’ and cubo [2 ] [ 7 ]== ’y ’ and cubo [ 2 ] [ 1 ] ! = ’ y ’ and cubo [ 2 ] [ 5 ] ! = ’ y ’ ) :
while cubo [ 1 ] [ 2 ] ! = ’ y ’ and cubo [ 5 ] [ 4 ] ! = ’ y ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corners_algor ithm ( ) ;
def ye l low_corner_or ientat ion_algor i thm ( ) :
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ o ’ )
rotate_c lock ( ’ o ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ o ’ )
rotate_c lock ( ’ o ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
48
def ye l low_corner_or i entat ion ( ) :
while cubo [ 1 ] [ 2 ] ! = ’ r ’ or cubo [ 1 ] [ 4 ] ! = ’ r ’ or cubo [ 5 ] [ 2 ] ! = ’ g ’ or cubo [ 5 ] [ 4 ] ! = ’ g ’ or
cubo [ 3 ] [ 2 ] ! = ’ o ’ or cubo [ 3 ] [ 4 ] ! = ’ o ’ or cubo [ 4 ] [ 2 ] ! = ’b ’ or cubo [ 4 ] [ 4 ] ! = ’b ’ :
i f ( cubo [1 ] [ 2 ]== cubo [ 1 ] [ 4 ] ) or ( cubo [5 ] [ 2 ]== cubo [ 5 ] [ 4 ] ) or ( cubo [3 ] [ 2 ]== cubo [ 3 ] [ 4 ] ) or ( cubo [4 ] [ 2 ]== cubo [ 4 ] [ 4 ] ) :
while cubo [ 3 ] [ 2 ] ! = cubo [ 3 ] [ 4 ] :
ro tate_c lock ( ’ y ’ )
ye l low_corner_or ientat ion_algor i thm ( )
while cubo [ 4 ] [ 2 ] ! = ’b ’ :
ro tate_c lock ( ’ y ’ )
i f ( cubo [ 1 ] [ 2 ] ! = cubo [ 1 ] [ 4 ] ) and ( cubo [ 5 ] [ 2 ] ! = cubo [ 5 ] [ 4 ] ) and
( cubo [ 3 ] [ 2 ] ! = cubo [ 3 ] [ 4 ] ) and ( cubo [4 ] [ 2 ]== cubo [ 4 ] [ 4 ] ) :
while cubo [ 3 ] [ 4 ] ! = ’ o ’ and cubo [ 1 ] [ 4 ] ! = ’ r ’ :
ro tate_c lock ( ’ y ’ )
ye l low_corner_or ientat ion_algor i thm ( )
while cubo [ 3 ] [ 2 ] ! = cubo [ 3 ] [ 4 ] :
ro tate_c lock ( ’ y ’ )
ye l low_corner_or ientat ion_algor i thm ( )
while cubo [ 4 ] [ 2 ] ! = ’b ’ :
ro tate_c lock ( ’ y ’ )
def yellow_edges_colour_arrangement_right ( ) :
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
49
def yel low_edges_colour_arrangement_left ( ) :
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’ y ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
ro tate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’b ’ )
rotate_c lock ( ’ g ’ )
rotate_c lock ( ’ y ’ )
rotate_c lock ( ’ r ’ )
ro tate_c lock ( ’ r ’ )
def yellow_edges_colour_arrangement ( ) :
while cubo [ 1 ] [ 2 ] ! = ’ r ’ :
ro tate_c lock ( ’ r ’ )
i f cubo [1 ] [ 3 ]== ’ o ’ and cubo [3 ] [ 3 ]== ’ r ’ and cubo [4 ] [ 3 ]== ’ g ’ and cubo [5 ] [ 3 ]== ’b ’ :
yel low_edges_colour_arrangement_left ( )
e l i f cubo [1 ] [ 3 ]== ’b ’ and cubo [4 ] [ 3 ]== ’ r ’ :
yel low_edges_colour_arrangement_left ( )
e l i f cubo [1 ] [ 3 ]== ’ g ’ and cubo [5 ] [ 3 ]== ’ r ’ :
yel low_edges_colour_arrangement_left ( )
while cubo [ 3 ] [ 2 ] ! = cubo [ 3 ] [ 3 ] :
ro tate_c lock ( ’ y ’ )
i f cubo [1 ] [ 3 ]== cubo [ 5 ] [ 2 ] :
yel low_edges_colour_arrangement_right ( )
e l i f cubo [1 ] [ 3 ]== cubo [ 4 ] [ 2 ] :
yel low_edges_colour_arrangement_left ( )
50
while cubo [ 1 ] [ 3 ] ! = ’ r ’ :
ro tate_c lock ( ’ y ’ )
i f __name__ == ’__main__ ’ :
#scanear_color ( )
so lve_white_cross ( )
so lve_white_corners ( )
solve_middle_layer ( )
so lve_yel low_cross ( )
so lve_yel low_corners ( )
ye l low_corner_or i entat ion ( )
yellow_edges_colour_arrangement ( )
51