Rubyx

Robot solveur de Rubik's Cube automatique : Arduino Nano + 8 servomoteurs + Python + kociemba.

Comment ca marche

Le robot tient un Rubik's Cube avec 4 bras mecaniques (tours). Chaque tour a 2 servomoteurs : un pour pivoter (tourner une face du cube) et un pour avancer/reculer la pince (emboiter ou degager du cube).

Le workflow complet :

1. L'utilisateur photographie les 6 faces du cube via son telephone
2. L'app Python detecte les couleurs et construit un modele du cube
3. L'algorithme kociemba calcule la solution optimale (~20 mouvements)
4. La solution est envoyee a l'Arduino via port serie
5. L'Arduino execute chaque mouvement avec les servomoteurs
6. Le cube est resolu

Architecture

Telephone (camera)              PC (Python)                Arduino Nano
  capture couleurs    -HTTP->   app/ (tkinter)   -Serie->  Rubyx.ino
  validation face              kociemba solve             8 servos MG90S
  grille editable              QR code + 2D/3D            4 tours (F/B/L/R)
                               progression               bascule U/D

Norme kociemba (WCA standard)

Tenue du cube : Blanc en haut, Vert face a toi.

U = Blanc  (dessus)       F = Vert   (devant)       L = Orange (gauche)
D = Jaune  (dessous)      B = Bleu   (derriere)     R = Rouge  (droite)

Les 18 mouvements possibles :

F   F'  F2    (Face Front = Vert)
B   B'  B2    (Face Back = Bleu)
L   L'  L2    (Face Left = Orange)
R   R'  R2    (Face Right = Rouge)
U   U'  U2    (Face Up = Blanc, via bascule)
D   D'  D2    (Face Down = Jaune, via bascule)

• Sans symbole = 90 degres sens horaire (vu depuis cette face)
• ' = 90 degres sens anti-horaire
• 2 = 180 degres (deux fois le meme mouvement)

Mapping robot

Tour 1 (pins 2,3)  = Face F (Vert)    ←→  Tour 2 (pins 4,5)  = Face B (Bleu)
Tour 3 (pins 6,7)  = Face L (Orange)  ←→  Tour 4 (pins 8,9)  = Face R (Rouge)

Les tours 1&2 se font face. Les tours 3&4 se font face.
Toutes les tours tournent dans le meme sens physique (ORIG → MVT).
Aucune inversion logicielle necessaire.

Faces U (Blanc) et D (Jaune) : accessibles via bascule du cube par les tours 3+4.
  U = preparer (basculer) → F → remettre
  D = preparer (basculer) → B → remettre

Fichiers du projet

Rubyx/
  Rubyx.ino             Firmware Arduino (18 mouvements + bascule U/D)
  rubyx.h               Calibration servos (pins, angles, timing, bascule)

TestServos/
  TestServos.ino        Calibration interactive + test des 18 mouvements
                        Commandes moniteur serie : F, F', MOVE, END, TEST, CAL, <pin> <angle>

app/
  cube_config.py        Source unique : faces, couleurs, mapping robot
  main.py               Interface graphique tkinter (wizard lineaire)
  phone_capture.py      Serveur web capture telephone (photo + grille editable)
  serial_comm.py        Communication serie Arduino (MOVE/END/OK/ERR, threaded)
  solver.py             kociemba + validation matrice + validation solution
  capture.py            Capture webcam (backup)
  cube3d.py             Rendu 3D du cube (matplotlib mplot3d)

archive/                Ancien code (reference historique)
requirements.txt        Dependances Python

Installation

Dependances Python

pip install -r requirements.txt

Contenu : opencv-python, numpy, kociemba, pyserial, qrcode, Pillow, scikit-image, magiccube

Note : kociemba necessite Visual C++ Build Tools sur Windows pour compiler l'extension C. Si la compilation echoue, installer RubikTwoPhase comme backup (pip install RubikTwoPhase).

Arduino

1. Ouvrir Rubyx/Rubyx.ino dans Arduino IDE
2. Board : Arduino Nano
3. Processor : ATmega328P (Old Bootloader) si echec upload
4. Port : le port COM de l'Arduino (ex: COM3)
5. Upload

Calibration des servos

La calibration se fait avec TestServos/TestServos.ino :

1. Upload TestServos.ino sur l'Arduino
2. Ouvrir le moniteur serie (9600 baud, Nouvelle ligne)
3. Brancher l'alimentation 5V des servos
4. Utiliser les commandes :
   • <pin> <angle> : positionner un servo (ex: 2 90)
   • MOVE : attraper le cube (toutes les pinces avancent)
   • F / F' / B / R etc. : tester un mouvement kociemba
   • TEST : jouer les 18 mouvements d'affilee
   • END : relacher le cube
   • CAL : afficher les valeurs actuelles
5. Reporter les valeurs finales dans Rubyx/rubyx.h

Structure de rubyx.h

// Chaque tour a 4 valeurs :
const int orig1a = 0;    // pivot position repos
const int mvt1a  = 110;  // pivot position mouvement
const int rec1b  = 0;    // pince reculee (degagee du cube)
const int avc1b  = 130;  // pince avancee (emboitee sur le cube)

// Bascule (pour U et D) : amplitude reduite pour compenser la gravite
const int bascule_mvt3 = mvt3a - 10;
const int bascule_mvt4 = mvt4a - 10;

// Delai entre chaque action servo (en ms)
const int delai = 500;

Utilisation

Lancer l'application

python -m app.main

Workflow dans l'interface

L'interface suit un wizard lineaire en 4 etapes :

Etape 1 - Connexion Arduino

• Cliquer "Connecter" (detection automatique du port COM)

Etape 2 - Capture du cube

• Choisir "Telephone" (recommande) ou "Webcam"
• Mode telephone : scanner le QR code, prendre les 6 faces en photo
• L'app detecte les couleurs et propose une grille editable
• Corriger les erreurs de detection si besoin, valider chaque face
• Le cube 2D et 3D se met a jour en temps reel

Etape 3 - Resolution

• Cliquer "Resoudre" → kociemba calcule la solution
• La solution s'affiche (ex: "F R' B2 U L2 D' ...")

Etape 4 - Execution

• Un popup confirme le placement du cube dans le robot
• Mode "fast" : tous les mouvements d'affilee avec progression
• Mode "step" : un mouvement a la fois (bouton Suivant)
• Le cube 2D/3D se met a jour apres chaque mouvement
• "END" pour relacher le cube une fois resolu

Mecanique des mouvements

Mouvement CW (sens horaire kociemba) = push

1. pivot → MVT     (pince emboitee, tourne la face)
2. pince → REC     (degage la pince)
3. pivot → ORIG    (revient a vide)
4. pince → AVC     (re-emboite)

Mouvement CCW (sens anti-horaire kociemba) = pull

1. pince → REC     (degage)
2. pivot → MVT     (tourne a vide)
3. pince → AVC     (emboite)
4. pivot → ORIG    (tire la face)

Bascule (pour U et D)

Les faces du haut (U) et du bas (D) ne sont pas directement accessibles. Le robot bascule le cube de 90 degres via les tours 3+4, puis utilise les tours 1 (F) ou 2 (B) pour tourner la face exposee.

preparer :
  1. Tour 4 recule, pivote, avance (se place en sens inverse)
  2. Tours 1+2 reculent (cube tenu par 3+4)
  3. Tour 3 → MVT, Tour 4 → ORIG (sens oppose = bascule 90 deg)
  4. Tours 1+2 avancent (rattrapent le cube bascule)
  5. Tours 3+4 reculent, reviennent ORIG, avancent

remettre : sequence inverse exacte de preparer

U  = preparer → F  → remettre
U' = preparer → F' → remettre
U2 = preparer → F  → F → remettre (un seul basculement)
D  = preparer → B  → remettre
D' = preparer → B' → remettre
D2 = preparer → B  → B → remettre

Communication serie

PC (Python)                    Arduino
-----------                    -------
"MOVE\n"           →          hold() → "Cube tenu.\n"
"F\n"              →          push(tour1) → "OK F\n"
"R'\n"             →          pull(tour4) → "OK R'\n"
"END\n"            →          releaseAll() → "Cube relache.\n"

• Baudrate : 9600
• Chaque commande terminee par \n
• L'Arduino repond OK <cmd> ou ERR <cmd> apres chaque mouvement
• Python envoie les mouvements un par un (evite le buffer overflow de 64 octets)
• Timeouts : 10s pour F/B/L/R, 20s pour U/D (bascule)

Hardware

• Arduino Nano (ATmega328P, CH340, 2KB SRAM, 32KB Flash)
• 8x Tower Pro MG90S (engrenages metal, 1.8 kg.cm @ 4.8V)
• Alimentation externe 5V 3A obligatoire (ne JAMAIS alimenter les servos via USB)
• Webcam ou telephone avec camera

Branchement

Arduino Nano          Servos              Alimentation 5V
Pin 2 → Tour 1 pivot    (F)
Pin 3 → Tour 1 pince    (F)
Pin 4 → Tour 2 pivot    (B)             +5V → tous les servos (fil rouge)
Pin 5 → Tour 2 pince    (B)             GND → tous les servos + Arduino GND
Pin 6 → Tour 3 pivot    (L)
Pin 7 → Tour 3 pince    (L)
Pin 8 → Tour 4 pivot    (R)
Pin 9 → Tour 4 pince    (R)

Important : le GND de l'alimentation 5V et le GND de l'Arduino doivent etre connectes ensemble.