Turing

Je vais vous presenter un petit projet :

Construire une machine de Turing !

Les machines de Turing sont les ancêtres des ordinateurs in venté par Alan Turing vers les années 1930.

Ce sont des modèles très puissants car très simple. Leurs seuls actions consiste à lire et écrire sur un ruban et à le déplacer !

Pour un peu plus d'informations je vous invite à voir ceci :
Browser

http://fr.wikipedia.org/wiki/Machine_de_Turing

J'ai crée la machine pour l'addition :

Attention ce n'est pas ce qu'il y a de plus beau ! De plus je l'ai un peu trafique pour qu'on puisse voir quelque chsoe sur les photos, j'ai notamment enlevé tout le cache qui se trouvait sur le capteur photosensible.

Le ruban est ici un rail dans lequel je pose des engrenages. Un engrenage gris pour les signes 1 et un engrenage blanc pour le signe +. la lecture est donc effectué grâce au capteur photosensible.

Les différentes configurations du ruban sont ( * : représente la case vue):

* 1 | 1 | + | 1 | 1
* 1 | + | 1 | 1 //effacement d'un signe
1 | * + | 1 | 1
1 | + | 1 | *1
1 | + | 1 | 1|*
1 | + | 1 | 1|*1 //ecriture d'un signe
1 | + | 1 | *1|1
1 | + | *1| 1 | 1
1 | * +| 1 | 1 | 1
*| + | 1 | 1 | 1 //effacement d'un signe
+ | 1 | 1 | 1 | * // deplacement
...
+ | 1 | 1 | 1 | *1 // ecriture d'un signe
...
* + | 1 | 1 | 1 | 1 //deplacement

et l'état finale (effacement du + )

1 | 1 | 1 | 1

2 + 2 = 4 Very Smile

c'est long mais puissant ! aucun calcul n'a été efectué

Je ne peux malheureusement pas filmé la machine en action, donc voila quelques photos :

Lecture :

Ecriture d'un signe :

effacement d'un signe :

La fin :

et voici le code source :/*
=====================================================================
=====================================================================
||
|| Turing.nxc
||
=====================================================================
||
|| Programme permettant de piloter une machine de Turing en LEGO, avec la brique programmable LEGO
|| MINDSTORMS NXT
||
|| Algorithme : addition de deux nombres
||
=====================================================================
=====================================================================
*/

#ifndef TURING
#define TURING

//====================================================================
// LES CONSTANTES
//====================================================================

// moteur pour effacer le ruban
#define MOT_EFF OUT_B
#define P_MOT_EFF 30

// moteur pour bouger le ruban
#define MOT_AV OUT_C
#define P_MOT_AV 30
#define PID 120

// moteur pour ecrire sur le ruban
#define MOT_ECR OUT_A
#define P_MOT_ECR 20

// les capteurs
#define CAPT_TACT IN_2
#define CAPT_PHOTO IN_1

// deplacement
#define N 0
#define D 1
#define G 2

#define STOP 0

//les signes
#define PLUS 2

//====================================================================
// LES STRUCTURES
//====================================================================

struct Doublet {
byte etat;
byte signe;
};

struct Triplet {
byte etat;
byte signe;
byte deplacement;
};

//====================================================================
// LES PROTOTYPES
//====================================================================

byte Lire(byte max, byte min); //lire sur le ruban
void Ecrire() ; //ecrit sur le ruban
void Effacer() ; //efface le signe sur le ruban
void Gauche(); //bouge le ruban vers la gauche
void Droite(); //bouge le ruban vers la gauche
void Algorithme(Doublet dblt, Triplet &trplt); //l'algorithme
void Analyse(Doublet dblt,Triplet trplt); //l'analyse du triplet

//====================================================================
// LES FONCTIONS
//====================================================================

byte Lire(max,min){
byte signe;
if(Sensor(CAPT_PHOTO)max){signe =PLUS;}
else {signe = 1;}

return signe;
}

void Ecrire() { //ecrire sur le ruban

RotateMotor(MOT_ECR,-P_MOT_ECR,70);
RotateMotor(MOT_ECR,P_MOT_ECR+40,70);

}

void Effacer() { //effacer un signe du ruban

RotateMotor(MOT_EFF,-P_MOT_EFF,430);
RotateMotor(MOT_EFF,P_MOT_EFF,430);

}

void Gauche() { //bouger vers la gauche
/*ClearSensor(CAPT_TACT);
until(Sensor(CAPT_TACT)==2) {
OnFwd(MOT_AV,P_MOT_AV);
}
Off(MOT_AV);*/
RotateMotorPID(MOT_AV,P_MOT_AV,120,PID,PID,PID);
}

void Droite() { //bouger vers la droite
/*ClearSensor(CAPT_TACT);
until(Sensor(CAPT_TACT)==2) {
OnRev(MOT_AV,P_MOT_AV);
}
Off(MOT_AV);*/
RotateMotorPID(MOT_AV,-P_MOT_AV,120,PID,PID,PID);
}

//====================================================================
// L'ALGORITHME
//
// pour un doublet (etat,signe) renvoie un triplet (etat,signe,deplacement)
//====================================================================

void Algorithme(dblt,trplt) {

byte etatI, etatO;
byte signeI, signeO;
byte deplacementO;

etatI = dblt.etat;
signeI = dblt.signe;

switch(etatI) {
case 1:
switch(signeI){
case 0:
etatO=1;
signeO=0;
deplacementO= D;
break;
case 1:
etatO=3;
signeO=0;
deplacementO= D;
break;
case 2:
etatO=STOP;
signeO=0;
deplacementO= N;
break;
}
break;
case 2:
switch(signeI){
case 0:
etatO=1;
signeO=0;
deplacementO= D;
break;
case 1:
etatO=2;
signeO=1;
deplacementO= G;
break;
case 2:
etatO=2;
signeO=2;
deplacementO= G;
break;
}
break;
case 3:
switch(signeI){
case 0:
etatO=2;
signeO=1;
deplacementO= N;
break;
case 1:
etatO=3;
signeO=1;
deplacementO= D;
break;
case 2:
etatO=3;
signeO=2;
deplacementO= D;
break;
}
break;
}

trplt.etat = etatO;
trplt.signe = signeO;
trplt.deplacement = deplacementO;
}

void Analyse(dblt,trplt) {

if(dblt.signe!=trplt.signe) { //efface et ecrit si besoin le signe sur le ruban
if(dblt.signe!=0){Effacer();}
if(trplt.signe==1){Ecrire();}
}

switch(trplt.deplacement){
case G:
Gauche();
break;
case D:
Droite();
break;
}
}
//====================================================================
// task main()
//====================================================================

task main()
{

byte max,min;
max=29;
min=19;
SetSensorType(CAPT_PHOTO,SENSOR_TYPE_LIGHT_ACTIVE); //capteur photosensible
SetSensorMode(CAPT_PHOTO,SENSOR_MODE_PERCENT); //en mode pourcentage
ResetSensor(CAPT_PHOTO);

Doublet dblt;
Triplet trplt;

dblt.etat=1;

ClearScreen();
until(dblt.etat==STOP)
{

dblt.signe=Lire(max,min);
NumOut(10,10,dblt.signe,0);
NumOut(40,10,dblt.etat,0);
Algorithme(dblt,trplt);
NumOut(10,20,trplt.signe,0);
NumOut(30,20,trplt.etat,0);
NumOut(60,20,trplt.deplacement,0);
Analyse(dblt,trplt);
dblt.etat = trplt.etat; //change l'état
//Wait(1000);
}

PlayTone(262,400); Wait(500);
}

#endif

//fin

Trop puissant!!! Very Smile