Project Cube: Il cubo di Rubik all'esame di stato.

Ciao a tutti! :slight_smile:
Mi chiamo Simone e sono uno studente elettronica al 5° anno di scuola superiore. Quest’anno, in “onore” al temutissimo esame di stato, dovrò portare un progetto personale da presentare alla commisione all’orale.
Ho deciso quindi di condividere questo progetto in costruzione e non ancora completo, in armonia con lo spirito di condivisione di Arduino stesso. Spero di fare cosa gradita e di non essere troppo banale, per quanto non abbia grandi pretesse da me stesso. Aggiungo che il topic è abbastanza lungo quindi ho dovuto suddividerlo in più post.

Cosa c’entra il Cubo di Rubik? Ebbene, quel curioso rompicapo mi ha da sempre appassionato e da quando ho imparato a risolverlo un paio di anni fa ha sempre avuto un posto dentro di me. Certo, oltre alla risoluzione con il metodo a strati non sono mai andato e mi sono accontentato di riuscire a risolverlo in un paio di minuti. Quando è venuto il tempo di decidere quale progetto portare all’esame ho avuto la “migliore” idea della mia vita: perché non creare un circuito elettro-meccanico in grado di risolverlo? Da allora la mia umile esistenza si è incentrata su quello. Partendo da abbozzi e fugaci idee annotate su un piccolo quaderno sono arrivato a scrivere migliaia di righe di codice per riuscire nel mio intento. Adesso, a quattro mesi dall’esame, ho deciso di esporre i miei risultati, i miei dubbi e tutto quello che ho ancora da fare perché qualsiasi consiglio e suggerimento è sempre ben accetto.
Ripeto, non ho mai avuto grosse pretese perché riconosco che sono solo uno studente con conoscenze e capacità limitate ma quello che per ora sono riuscito a fare mi ha dato molta soddisfazione e per questo ho deciso di andare fino in fondo, anche se magari non riuscirò a completarlo in tempo. Sicuramente nei vari schemi e sketch che inserirò in questo topic troverete errori, inutili complicanze o altro perciò vi chiedo di essere costruttivi nei vostri commenti e di avere pazienza con me. :wink:
Detto questo…da cosa inizio? Domada difficile.
All’inizio dell’anno scolastico ho suddiviso il mio lavoro in tre grandi sezioni che spiegherò mano mano:

1)IDEAZIONE, PROGETTAZIONE E COSTRUZIONE DI UNA “MATRICE” DI LED RGB
2)SVILUPPO DEL SOFTWARE RISOLUTIVO DEL CUBO
3)COSTRUZIONE DELLA PARTE MECCANICA

La prima sezione, che riconosco possa apparire abbastanza strana per non dire superflua, si è invece rivelata fondamentale durante lo sviluppo del programma per la risoluzione del cubo. Tutto è iniziato quando, ragionando con un mio professore, è sorto uno dei primi ostacoli al mio progetto. In che modo il mio caro Arduino avrebbe acquisito lo stato iniziale del cubo? Personalmente pensai di utilizzare una fotocamera la quale avrebbe inviato le foto a un computer che le avrebbe analizzate per poi inviare i dati all’Arduino. Purtroppo questo avrebbe comportato la creazione di un vero e proprio programma per il computer in C+ o Java e per me che studio elettronica e non informatica si sarebbe rivelato una pazzia dato che, sebbene avessi 9 mesi di tempo, non potevo dedicarmi solo ed esclusivamente a questo progetto. Anche perché nel mio corso di studi non avevo mai affrontato ne l’Arduino ne il wiring, avendo studiato solo le basi del mikroC, e quindi solo questo avrebbe comportato un’ulterore mole di lavoro. Ho deciso di utilizzare l’Arduino attirato dalla sua semplicità sia a livello software ma anche nell’hardware, data la possibilità di utilizzare una vasta quantità di shield. Scartai anche l’idea di utilizzare un sensore di colori, il quale avrebbe potuto falsare il riconoscimento del giallo o dell’arancione in ambienti con poca luminosità e l’utilizzare qualche LED per risolvere il problema sarebbe stato controproducente, vista la superficie riflettente del cubo. Ecco che il mio professore mi suggerì di utilizzare una semplice pulsantiera, grazie alla quale avrei inserito lo stato iniziale del cubo che sarebbe stato poi visualizzato tramite 54 LED RGB, disposti per rappresentare un cubo sviluppato in 2 dimensioni, uno per ogni piccolo quadratino presente nel cubo.

Non inserirò lo schema della pulsantiera dato che lo trovo superfluo, alla fine sono solo semplicemente 7 pulsanti (6 per i vari colori più uno di START) saldati su una millefori con le loro resistenze di pull down. Segue invece la parte del software che si occupa della acquisizione degli input:

void loop() {
  lcd.setCursor(0,0);
  lcd.print("Premere START");
  lcd.setCursor(0,1);
  lcd.print("per iniziare.");
  while(!(digitalRead(START)));
  //Fino a che non premo START attendi, cioè finché ho LOW
  {
    delay(50);
  }
  digitalWrite(13,HIGH);
  delay(1000);
  digitalWrite(13,LOW);
  while((digitalRead(START)));
  //Fino a che non rilascio START attendi, cioè finché ho HIGH
  {
    delay(50);
  }
  lcd.clear();
    for (i=0;i<54;i++) 
  {
    lcd.setCursor(0,0);
    lcd.print("Inserire la");
    lcd.setCursor(0,1);
    lcd.print("SubFaccia Num");
    lcd.setCursor(14,1);
    if (i<10) {
    lcd.print("0"); 
    lcd.setCursor(15,1);
    lcd.print(i);
    } else {
    lcd.print(i);
    }
  digitalWrite(13,HIGH);
  delay(250);
  digitalWrite(13,LOW);
  delay(250);//Controllo
ripeti: //Se non ho scelto alcun colore riparti da qua    
    if (digitalRead(v)) // Ho selezionato il colore verde perché rilevo HIGH
    { 
      delay(100); //Debouncing
      cubo [i] = 'v';
      CUBO[i][0]=0;
      CUBO[i][1]=255;
      CUBO[i][2]=0;
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Colore scelto:");
      lcd.setCursor(0,1);
      lcd.print("VERDE");
      while(digitalRead(v)) //Fino a che non rilascio il verde attendi, cioè finché ho HIGH
      {
        delay(5);
      }
      delay(1000);
      continue;
     }
     if (digitalRead(a)) // Ho selezionato il colore arancio perché rilevo HIGH
    { 
      delay(100);
      cubo [i] = 'a';
      CUBO[i][0]=255;
      CUBO[i][1]=100;
      CUBO[i][2]=0;
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Colore scelto:");
      lcd.setCursor(0,1);
      lcd.print("ARANCIO");
      while(digitalRead(a)) //Fino a che non rilascio l'arancio attendi, cioè finché ho HIGH
      {
        delay(5);
      }
      delay(1000);
      continue;
     }
     if (digitalRead(b)) // Ho selezionato il colore blu perché rilevo HIGH
    { 
      delay(100);
      cubo [i] = 'b';
      CUBO[i][0]=0;
      CUBO[i][1]=0;
      CUBO[i][2]=255;
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Colore scelto:");
      lcd.setCursor(0,1);
      lcd.print("BLU");
      while(digitalRead(b)) //Fino a che non rilascio il blu attendi, cioè finché ho HIGH
      {
        delay(5);
      }
      delay(1000);
      continue;
     }
     if (digitalRead(r)) // Ho selezionato il colore rosso perché rilevo HIGH
    { 
      delay(100);
      cubo [i] = 'r';
      CUBO[i][0]=255;
      CUBO[i][1]=0;
      CUBO[i][2]=0;
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Colore scelto:");
      lcd.setCursor(0,1);
      lcd.print("ROSSO");
      while(digitalRead(r)) //Fino a che non rilascio il rosso attendi, cioè finché ho HIGH
      {
        delay(5);
      }
      delay(1000);
      continue;
     }
     if (digitalRead(B)) // Ho selezionato il colore Bianco perché rilevo HIGH
    { 
      delay(100);
      cubo [i] = 'B';
      CUBO[i][0]=255;
      CUBO[i][1]=255;
      CUBO[i][2]=255;
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Colore scelto:");
      lcd.setCursor(0,1);
      lcd.print("BIANCO");
      while(digitalRead(B)) //Fino a che non rilascio il Bianco attendi, cioè finché ho HIGH
      {
        delay(5);
      }
      delay(1000);
      continue;
     }
     if (digitalRead(g)) // Ho selezionato il colore giallo perché rilevo HIGH
    { 
      delay(100);
      cubo [i] = 'g';
      CUBO[i][0]=255;
      CUBO[i][1]=255;
      CUBO[i][2]=0;
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Colore scelto:");
      lcd.setCursor(0,1);
      lcd.print("GIALLO");
      while(digitalRead(g)) //Fino a che non rilascio il giallo attendi, cioè finché ho HIGH
      {
        delay(5);
      }
      delay(1000);
      continue;
     }
     goto ripeti;
  }
        delay(1000);
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Premere START");
      lcd.setCursor(0,1);
      lcd.print("per trasmettere.");
      ...

CUBO.zip (1.02 MB)

Utilizzando un ciclo FOR inserisco in un array da 54 variabili lo stato iniziale dei quadratini del cubo ("a"= arancio; "r"=rosso; "g"=giallo; "b"=blu; "v"=verde; "B"=bianco). Oltre a ciò riempio opportunamente una matrice che contiene il valore da 0 a 255 dei pin RED, GREEN e BLUE per permettermi di creare i 6 colori. Il vettore l'ho utilizzato per comodità durante la risoluzione del cubo stesso come potete vedere nel codice, mentre è la matrice che viene inviata tramite la connessione I2C all'altro Arduino che gestisce i LED RGB. Quale altro Arduino? Ebbene si. Un Arduino, il master, riceve in entrata l'input dalla pulsantiera e risolve il cubo. L'altro Arduino invece riceve di volta in volta dal master, dopo ogni mossa, la matrice con i valori RGB per ognuno dei 54 LED. Perciò ogni mossa che viene eseguita sul cubo non è altro che una funzione esterna che scambia tra loro i valori delle variabili (appartenenti al vettore e alla matrice) interessate dalla mossa in atto e invia allo slave il risultato. (Se conoscete la funzione swipe immaginatela fatta non su 2 variabili ma su 20). Lo slave quindi cambierà lo stato dei LED. Segue un esempio di ciò che una funzione esterna esegue:

void Len(){ //mossa Left L'
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("NUOVA MOSSA");
  delay(ddd);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Ln");
  int L1n[2];
  int L2n[2];
  int L3n[2];
  int L4n[2];
  int L5n[2];
  char l1n;
  char l2n;
  char l3n;
  char l4n;
  char l5n;
  L1n[0]=CUBO[47][0];
  L1n[1]=CUBO[47][1];
  L1n[2]=CUBO[47][2];
  l1n=cubo[47];
  CUBO[47][0]=CUBO[20][0];
  CUBO[47][1]=CUBO[20][1];
  CUBO[47][2]=CUBO[20][2];
  cubo[47]=cubo[20];
  CUBO[20][0]=CUBO[38][0];
  CUBO[20][1]=CUBO[38][1];
  CUBO[20][2]=CUBO[38][2];
  cubo[20]=cubo[38];
  CUBO[38][0]=CUBO[6][0];
  CUBO[38][1]=CUBO[6][1];
  CUBO[38][2]=CUBO[6][2];
  cubo[38]=cubo[6];
  CUBO[6][0]=L1n[0];
  CUBO[6][1]=L1n[1];
  CUBO[6][2]=L1n[2];
  cubo[6]=l1n;
  L2n[0]=CUBO[50][0];
  L2n[1]=CUBO[50][1];
  L2n[2]=CUBO[50][2];
  l2n=cubo[50];
  CUBO[50][0]=CUBO[23][0];
  CUBO[50][1]=CUBO[23][1];
  CUBO[50][2]=CUBO[23][2];
  cubo[50]=cubo[23];
  CUBO[23][0]=CUBO[41][0];
  CUBO[23][1]=CUBO[41][1];
  CUBO[23][2]=CUBO[41][2];
  cubo[23]=cubo[41];
  CUBO[41][0]=CUBO[3][0];
  CUBO[41][1]=CUBO[3][1];
  CUBO[41][2]=CUBO[3][2];
  cubo[41]=cubo[3];
  CUBO[3][0]=L2n[0];
  CUBO[3][1]=L2n[1];
  CUBO[3][2]=L2n[2];
  cubo[3]=l2n;
  L3n[0]=CUBO[53][0];
  L3n[1]=CUBO[53][1];
  L3n[2]=CUBO[53][2];
  l3n=cubo[53];
  CUBO[53][0]=CUBO[26][0];
  CUBO[53][1]=CUBO[26][1];
  CUBO[53][2]=CUBO[26][2];
  cubo[53]=cubo[26];
  CUBO[26][0]=CUBO[44][0];
  CUBO[26][1]=CUBO[44][1];
  CUBO[26][2]=CUBO[44][2];
  cubo[26]=cubo[44];
  CUBO[44][0]=CUBO[0][0];
  CUBO[44][1]=CUBO[0][1];
  CUBO[44][2]=CUBO[0][2];
  cubo[44]=cubo[0];
  CUBO[0][0]=L3n[0];
  CUBO[0][1]=L3n[1];
  CUBO[0][2]=L3n[2];
  cubo[0]=l3n;
  L4n[0]=CUBO[27][0];
  L4n[1]=CUBO[27][1];
  L4n[2]=CUBO[27][2];
  l4n=cubo[27];
  CUBO[27][0]=CUBO[33][0];
  CUBO[27][1]=CUBO[33][1];
  CUBO[27][2]=CUBO[33][2];
  cubo[27]=cubo[33];
  CUBO[33][0]=CUBO[35][0];
  CUBO[33][1]=CUBO[35][1];
  CUBO[33][2]=CUBO[35][2];
  cubo[33]=cubo[35];
  CUBO[35][0]=CUBO[29][0];
  CUBO[35][1]=CUBO[29][1];
  CUBO[35][2]=CUBO[29][2];
  cubo[35]=cubo[29];
  CUBO[29][0]=L4n[0];
  CUBO[29][1]=L4n[1];
  CUBO[29][2]=L4n[2]; 
  cubo[29]=l4n;
  L5n[0]=CUBO[28][0];
  L5n[1]=CUBO[28][1];
  L5n[2]=CUBO[28][2];
  l5n=cubo[28];
  CUBO[28][0]=CUBO[30][0];
  CUBO[28][1]=CUBO[30][1];
  CUBO[28][2]=CUBO[30][2];
  cubo[28]=cubo[30];
  CUBO[30][0]=CUBO[34][0];
  CUBO[30][1]=CUBO[34][1];
  CUBO[30][2]=CUBO[34][2];
  cubo[30]=cubo[34];
  CUBO[34][0]=CUBO[32][0];
  CUBO[34][1]=CUBO[32][1];
  CUBO[34][2]=CUBO[32][2];
  cubo[34]=cubo[32];
  CUBO[32][0]=L5n[0];
  CUBO[32][1]=L5n[1];
  CUBO[32][2]=L5n[2];
  cubo[32]=l5n;
  //motori
  trasmetti();
  }

Della funzione “trasmetti” parlerò in seguito. Al momento dico solo che ho scelto di creare e inviare la matrice solo perché, per qualche errore che non ho trovato, sebbene riuscissi a inviare anche solo il vettore allo slave, non riuscivo poi a tirare fuori il valore di RED, GREEN e BLUE corrispondente. Provo a spiegarmi meglio. Perché anziché inviare ad esempio "variabile 34: colore rosso" invio "variabile 34: RED = 255, GREEN = 0, BLUE = 0"? Perché poi nello slave non sono riuscito a creare una struttura del tipo "se la variabile x è rosso allora RED = 255, GREEN = 0, BLUE = 0". Cioè da qualche parte dovrei aver salvato la struttura che ho creato ma non riuscendo a cavare un ragno dal buco ho deciso di inviare direttamente la matrice e buonanotte al secchio. Inoltre ho aggiunto un piccolo schermo LCD in modo da sapere cosa succede mano mano che il programma viene eseguito. Quindi per riassumere: la disposizione iniziale viene inserita nel master e poi inviata allo slave. Mentre il master risolve il cubo lo slave cambia opportunamente il colore dei led RGB fino a che il cubo vero non viene risolto e pertanto il cubo sviluppato composto dai led non è sistemato.

Mi soffermo adesso sullo slave e sul circuito di comando dei 54 led RGB. Troverete allegato sia lo sketch e sto lavorando uno schema decente che allegherò il prima possibile. Innanzitutto ho preferito utilizzare due Arduino (il master è un Arduino MEGA, lo slave è un Arduino UNO) perché ho trovato difficoltà nel gestire il tutto con un solo Arduino. Mentre esso si occupa di quale mossa utilizzare o di quanto muovere un motore mi dava dei seri problemi nel tenere in funzione il circuito dei led. Quindi con l’Arduino MEGA, il master, risolvo il cubo, mentre l’Arduino UNO si occupa di tenere accesi i led. Questi 54 led RGB vengono accesi utilizzando sia il PWM, per gestire l’intensità del rosso, del verde e del blu, che il multiplexing. I led hanno in comune le tre linee RGB ma, essendo led a catodo comune, tramite un circuito creato con dei decoder 74LS138 in cascata che presentano in uscita una logica negata, ne attivo solo uno alla volta. Per 200 microsecondi solo uno dei 54 pin utilizzati dei 74LS138 viene attivato (passando da HIGH +5V a LOW 0V) e in contemporanea solo il corrispondente led si attiverà.
Inserisco una foto per mostrare il circuito su breadboard con i 74LS138…perdonate, è quasi tutto coperto dai cavetti jumper ma meglio di niente. :wink:

Quindi nonostante tutti i led ricevano in entrata un colore solo il led interessato si accenderà. Con un piccolo calcolo si può vedere quanto dura un ciclo intero: 200*10^(-6) secondi * 54 led = 10.8 millisecondi. Questo è un tempo irrisorio per l’occhio umano al quale sembrerà che tutti i led siano accesi contemporaneamente.


Ecco una piccola parte del codice:

      digitalWrite(AMD,LOW);
      digitalWrite(BMD,LOW);
      digitalWrite(CMD,LOW);
      digitalWrite(AD,LOW);
      digitalWrite(BD,LOW);
      digitalWrite(CD,LOW);
      analogWrite(RED,CUBO[k][0]);
      analogWrite(GREEN,CUBO [k][1]);
      analogWrite(BLUE,CUBO [k][2]);
      delayMicroseconds(d);
      analogWrite(RED,0);
      analogWrite(GREEN,0);
      analogWrite(BLUE,0);
      k=k+1;
      digitalWrite(AMD,LOW);
      digitalWrite(BMD,LOW);
      digitalWrite(CMD,LOW);
      digitalWrite(AD,HIGH);
      digitalWrite(BD,LOW);
      digitalWrite(CD,LOW);
      analogWrite(RED,CUBO[k][0]);
      analogWrite(GREEN,CUBO [k][1]);
      analogWrite(BLUE,CUBO [k][2]);
      delayMicroseconds(d);
      analogWrite(RED,0);
      analogWrite(GREEN,0);
      analogWrite(BLUE,0);
      k=k+1;

Quindi con…

      digitalWrite(AMD,LOW);
      digitalWrite(BMD,LOW);
      digitalWrite(CMD,LOW);
      digitalWrite(AD,HIGH);
      digitalWrite(BD,LOW);
      digitalWrite(CD,LOW);

…scelgo il led da tenere acceso per 200 microsecondi agendo sui 74LS138 e poi con…

      analogWrite(RED,CUBO[k][0]);
      analogWrite(GREEN,CUBO [k][1]);
      analogWrite(BLUE,CUBO [k][2]);
      delayMicroseconds(d);
      analogWrite(RED,0);
      analogWrite(GREEN,0);
      analogWrite(BLUE,0);
      k=k+1;

…imposto il colore da inviare al suddetto led gestendo il PWM per ottenere il giusto colore tramite analogWrite e dopo il delay da 200 micro spengo il led e passo al led successivo. Per spegnere il led si intende inviare…

      analogWrite(RED,0);
      analogWrite(GREEN,0);
      analogWrite(BLUE,0);

…in modo che quando attivo il led successivo questo, anche solo per una brevissima frazione di tempo, non stia acceso con il colore del led precedente.
Una foto nella quale si può vedere il PCB di una delle 6 facce del cubo sviluppato composto dai led:

Come potete vedere le linee RGB sono in comune a tutti mentre ogni catodo ha un suo connettore. I ponti mancanti nel file PCB si possono vedere nella foto seguente:

Mi concentro adesso sulla comunicazione I2C sfruttata per far colloquiare i due Arduino. Come ho già accennato alla fine di ogni mossa effettuata sul cubo il master invia allo slave una matrice contenente i valori di R,G e B di tutti i 54 led. Il codice utilizzato è il seguente:

 void trasmetti(){
   for (x=0;x<54;x++){
 Wire.beginTransmission(5);
   Wire.write(x);
 Wire.write(CUBO[x][0]);  //Valore di R
   Wire.write(CUBO[x][1]);  //Valore di G
   Wire.write(CUBO[x][2]);  //Valore di B
   Serial.println(x);
   Wire.endTransmission();    
  }

Nello slave invece l’interrupt generato dall’evento ricezione sposta l’attenzione dell’Arduino sul seguente codice:

void receiveEvent(int data) {
  x = Wire.read();
  CUBO[x][0]= Wire.read();
  CUBO[x][1]= Wire.read();
  CUBO[x][2]= Wire.read();
}

Ho preferito far generare esattamente 54 volte l’evento di trasmissione e utilizzare una variabile di appoggio per inviare un pezzo della matrice alla volta anziché generare solo una volta il suddetto evento e inviare quindi tutta la matrice perché ho notato che alcuni valori si confondevano durante tutto il procedimento.
Questa comunicazione viene effettuata tramite i pin SDA e SCL che vengono sfruttati anche dallo schermo LCD grazie a un convertitore seriale-I2C display LCD alfanumerico HD44780. Ciò che compare scritto sullo schermo naturalmente è gestito dal master.

Perciò, dopo aver saldato e saldato e saldato e saldato e saldato e montato e montato e montato e montato e sclerato e sclerato e sclerato e sclerato mi sono ritrovato con la mia bella pulsantiera, il circuito per la gestione dei led montato su breadboard e i miei 54 led saldati sulle 6 facce disposte a cubo sviluppato, oltre a un'enorme matassa di cavi jumper. Come dissi in precedenza, il cubo sviluppato fatto di led mi avrebbe avvantaggiato nella creazione del codice per la risoluzione del cubo, perché non sarebbe servito creare prima la parte meccanica dato che avrei potuto testare l'efficacia del programma tramite i led, e così ho fatto. Quindi, con molta pazienza e tanta voglia di programmare, ho dovuto “tradurre” il metodo di risoluzione a strati, che è l'unico che conosco, in una serie tendente all'infinito di costrutti if-else e switch case. Dopo poco più di una settimana passata solo ed escusivamente al computer (ergo vacanze di natale andate in fumo) e migliaia di righe di codice scritte sono riuscito nel mio intento. Per uno come me che difficilmente in un programmino fatto a scuola supera le 100 righe di codice è stato un gran successo. In totale le righe di codice effettive utilizzate nei due Arduino ammontavano a poco più di 6500! E più o meno qua finisce il racconto delle cose che ho già fatto. Mi manca la parte meccanica, ho intenzione di utilizzare 4 motori passo-passo con delle staffe in alluminio per ruotare le facce del cubo. Inoltre per evitare che durante certe rotazioni le staffe si tocchino devo far scorrere i 4 motori su dei carellini tramite 4 piccoli pistoni. Al momento sto cercando di imparare a muovere un motore passo-passo anche se ho un po' rallentato per via degli impegni scolastici e dello stage. Dato che ho ancora 4 mesi di tempo sono abbastanza tranquillo, infatti una volta costruita la parte meccanica e imparata bene la parte software relativa ai motori devo solo fare un upgrade del programma. Potrebbe anche succedere che io non ci riesca, però sarà comunque stata una bella esperienza perché tramite questo progetto ho dovuto approfondire parte dei miei studi e ho anche imparato molte cose nuove. Se avete avuto la voglia e la pazienza di leggere fino a qui vi ringrazio e come dico sempre, qualsiasi suggerimento o consiglio è ben accetto. Nel primo post ho allegato una cartella zippata con tutto il materiale che ho cercato di spiegare,oltre al programma completo del MASTER e dello SLAVE.

Se ne avrete cercherò di rispondere a tutte le domande che mi farete, altrimenti ve ne faccio una io: che ne pensate?

P.S. Adesso ubbidisco a gpb01 e corro a presentarmi ;)

Ho solo una cosa da dire, impressionante ;) Hai affrontato la realizzazione del progetto da vero tecnico. Mi piacerebbe vedere il progetto finito!

P.s. La risoluzione del cubo a strati è l'unica che so fare anch'io :D

Meluino

meluino: Ho solo una cosa da dire, impressionante ;) Hai affrontato la realizzazione del progetto da vero tecnico. Mi piacerebbe vedere il progetto finito!

Ti ringrazio Meluino, sei stato molto gentile. :) Si, ho intenzione di fare un video alla fine, se tutto andrà bene, e di allegarlo in un futuro post.

Ho sempre odiato quel cubo o forse non ho mai cercato di capirlo davvero :) :) Però hai fatto un bel lavoro, complimenti!

Come inizio non c'è che dire!!! Bravissimo :)...complimenti.

Antonio

Grazie ragazzi :)