Que signifie la variable linguistique "orientation" ? Pourquoi ne pas avoir directement la vitesse des roues (gauche et droite) ?

 

Le fait de mettre plus de variables linguistiques en entrée te permettra d'avoir plus de règles et donc d'affiner le calcul des sorties (même si c'est toujours une vitesse entre 0 et 1, la manière de calculer cette vitesse sera différente et (on peut l'espérer), plus adaptée). Le tout, c'est de savoir si les variables d'entrées ont une réelle influence sur la sortie ou non.

C'est un peu comme l'age du capitaine : c'est une info que tu as mais qui ne te sert pas à résoudre le problème. Si tu la prend en compte, tu complique le système sans rien changer au résultat

 

Mon robot est une base de voiture télécommandée, pour tourner je dois donc orienter les roues avant (comme quand on tourne le volant dans une vraie voiture) et non pas changer la vitesses des roues (d'ailleurs je n'ai qu'un seul moteur pour les deux roues arrières). Le contrôle de cet orientation se fait par l'envoi d'une valeur comprise entre -1 et 1, -1 étant roue tourné a fond vers la gauche 1 étant roues tourné ) fond vers la droite et 0 étant roues droites

 

Je commence à comprendre mieux l’intérêt des variables linguistique, dans mon cas il faudrait donc que j'ai 3 variables linguistique pour la distance: petit pour la détection des bordures, moyen pour la détection des virages et grand pour la détection des grandes lignes droites à l'avant du robot

Black Templar, j'ai lu tes articles sur le sujet et ça a effectivement l'aire de correspondre à ce dont j'ai besoin, je vais donc partir la dessus 

 

Dans un premier temps, je vais essayer de centrer le robot sur la piste en utilisant la logique floue (je le faisais jusqu'à maintenant en utilisant une simple règle de proportionnalité).

 

Je vais donc utilisé les capteurs droite et gauche (comme dans l'exemple du robot de ton article) pour contrôler l'orientation des roues avant.

 

J'aurais donc pour chaque capteur deux variables linguistique distance_petite et distance_grande et pour l'orientation des roues une variables linguistique "orientation" (Cette valeur me donnera la valeur de l'orientation, il me suffira de déterminer si elle doit être positive ou négative en fonction du sens)

 

Les variables linguistiques aurait ces fonctions d'appartenance :

 

 

Et les règles serait les suivantes:

 

SI distance_gauche = grande ET distance_droite = petite ALORS orientation = grande

SI distance_gauche = petite ET distance_droite = grande ALORS orientation = grande

SI distance_gauche = petite ET distance_droite = petite ALORS orientation = moyenne

 

Cela te semble correct ? Si non qu'est ce qui ne va pas ?

 

Autres questions: Quel est l’intérêt de mettre plus de variables linguistiques pour un problème sachant que le résultat sera toujours un pourcentage ? Comment est ce qu'on "code", les fonctions d'appartenance des variables linguistiques ?

 

Merci pour tout en tout cas les gars

 

La communication se fais en texte via un socket en C. J'envois mes commandes sur la sortie standards (on bosse sur un environnement UNIX) et j'ai un retour en texte aussi sur l'entrée standards (que je dois parser pour récup les informations de contrôle).

 

De ce que je me rappelle de la logique floue c'est un système de prise de décision basés sur des probabilités. Ca donnerais un truc comme ca dans mon cas SI capteur_droit SUPERIEUR A capteur_gauche ET QUE capteur_avant INFERIEUR A un_seuil ALORS on se trouve surement dans un virage vers la droite. C'est ca ?

 

J'ai regardé aussi le réseau de neurone, ça à l'aire cool, mais de ce que j'ai compris, pour que ca marche, il faut naviguer plusieurs fois dans le circuit pour l'analyser et on aura le droit qu'à un essais le jour de la présentation (sur un circuit inconnu qui plus est) :/

 

Je ne passe pas par matlab, tout se fais via le socket :/

 

Je suis en première années à Epitech, et cette école est justement connu pour ne pas guider les étudiants pour les pousser à chercher par eux même

Salut les gars,

 

Je bosse actuellement sur un projet (pour mon école) qui consiste à créer un algorithme (en C) permettant de faire naviguer un robot doté d'un lidar à l'avant dans un circuit le plus vite possible sans toucher de murs.

 

Quelques infos à propos du robot:

 

Le lidar à un angle d'ouverture de 60 dégrée vers l'avant du robot (voir photo) et il retourne 32 mesures de distance (environ une tout les 2 degrées donc).

Je peux contrôler la puissance du moteur (de 0 à 100%), ainsi que l'angle des roues avant pour contrôler le robot.

Je peux aussi connaitre la vitesse absolut du robot (en Km/h).

La fréquence de rafraîchissement du lidar est assez longue (3 mesures par secondes je dirais) donc ça complique pas mal la tache sachant que le robot peut aller (très) vite.

Les essais sont pour l'instant fait sur un logiciel de simulation robotique (V-REP pour les connaisseurs).

 

Voici une image de la simulation (les lignes bleu partant du robot représentent les extrémités du capteur):

 

 

J'ai déjà fais un algo très simple qui consiste à juste tourner les roues dans un le sens opposé quand on se rapproche d'un mur. Ca marche à peut près, mais quand il y à des virages trop serrés il se plante et il ne va du coup pas tout droit même en ligne droite.

 

Je suis sur qu'avec autant de données venant du lidar, on peut faire un algo bien plus intelligent pour par exemple appréhender les virages et choisir exactement la bonne vitesse/orientation pour le prendre etc...

 

Le truc c'est que je ne vois pas du tout comment faire ça et je ne trouve rien sur le net :/ 

 

Voilà voilà, donc si quelqu'un à une idée de comment faire ou un lien vers des éventuels informations, je suis preneurs

10 cm me parait largement suffisant pour commencer J'ai regarder le VL6180, je pense que sa précision correspond bien à ce je recherche (je vais voir si je le trouve un peut moins cher que 24$ l'unité parce que, sachant qu'il m'en faudrait 4... ^^)

 

Pour ce qui est de l'équilibre du robot, j'ai fais quelques test et je pense pouvoir faire en sorte qu'il tienne en equilibre sur seulement 3 roues. Le seul problème qui se pose encore est le cas ou le robot rencontre deux obstacles en même temps devant ses roues avant :/

 

J'avais effectivement pensé aussi à detecter l'inclinaison absolut du robot de manière à, en ajustant la hauteur des roues, le rendre le plus horizontale possible. Mais cette solution ne s'applique qu'en cas d’obstacles franchissables. L'idéal serait donc de combiner les deux solutions pour avoir un robot vraiment souple

Salut les gars,

 

De retour sur le forum après quelques mois (années ?) avec un projet que j'ai en tête depuis longtemps. J'aimerais faire un petit robot qui ajuste la hauteur de ses roues en fonction des obstacles qu'il passe (qui en principe devrait rendre le déplacement du robot fluide sur tout type de surface).

 

A peine le projet commencé, je bloque déjà... En effet, afin d'ajuster la hauteur de mes roues il me faut connaitre la hauteur relative au sol de l'objet et je ne sais pas comment arrivé à ca.

 

Un petit schéma pour rendre le problème plus clair :

 

 

 

J'ai d'abords pensé mettre un capteur en direction du sol qui détecterais la hauteur d'un objet arrivant dans son champ mais les distances mesuré son trop petites et avec des capteurs "accesibles" la mesure serait trop vague.

J'ai ensuite pensé à mettre le capteur face à l'objet et à le faire remonter doucement mécaniquement jusqu'à ce que son champ passe au dessus de l'objet pour en déduire sa hauteur mais ca me parait compliqué à mettre en oeuvre et pas forcement plus précis :/

 

Avez vous une idée ?

Mon dieu... Je suis stupide. J'oubliais le second delay... 

 

Sujet résolu X)

 

( J'ai quand même passé une heure à faire fonctionner un Blink() )

Salut les gars,

 

J'écris ici car je suis désespéré... Je suis en train de faire une carte de contrôle pour une bande de LEDs basée sur une arduino Nano et des transistor TIP120 pour contrôler les LEDs 12V. 

 

Pour tester ma carte, j'ai donc écrit un petit code permettant de les faire clignoter. Mais alors que les LEDs devraient clignoter toute les secondes comme le code l'indique, elles s'allument et reste allumées indéfiniment...

 

Quelqu'un à une idée ? J'en reviens pas de bloquer sur un truc comme ca...

 

Mon code :

 
int BLUEPIN = 3;
int GREENPIN = 5;
int REDPIN = 6;

 
void setup() {
  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(BLUEPIN, OUTPUT);
}
 
 
void loop() {
 analogWrite(BLUEPIN, 255);
 analogWrite(GREENPIN, 255);
 analogWrite(REDPIN, 255);
 delay(1000);
 analogWrite(BLUEPIN, 0);
 analogWrite(GREENPIN, 0);
 analogWrite(GREENPIN, 0);
}

Salut les gars,

 

Je suis en train de faire une maquette d'un projet pour le bac ou je dois piloter un moteur en sens et vitesse de rotation en fonction de l'inclinaison.

J'ai donc fait mon montage, tout fonctionne parfaitement mais quand j'ai finalement attaché la roue au moteur, cela a posé problème. En effet, ma roue étant d'assez grand diamètre et tournant à des vitesse parfois très rapides, elle constitue donc un volant d'inertie. Le problème est donc que, quand j'ai ordonné au moteur de s’arrêter, la roue à continuer de tourner et donc générer un courant de retour qui est venu détruire la moitié  de mon contrôleur moteur ( il pouvait contrôler deux moteur, maintenant une des "voie" est morte ).

 

La question est donc de savoir comment protéger mon contrôleur de ces courant de retour généré par mon moteur ? Je connais le système de la diode de roue libre, mais comment l'installer sur un moteur dont le sens de rotation ( et donc la polarité d’alimentation ) varie ?

 

Voilà le contrôleur moteur que j'utilise : https://www.pololu.com/docs/0j55/all

 

 

Merci d'avance !

Merci pour vos réponse

 

J'ai effectivement trouvé moi aussi sans trop de difficulté des adaptateurs AC DC 12V 5A déjà tout fait. Le truc c'est que j'aimerais que le circuit d'alimentation ( transfo compris ) soit directement sur la carte de contrôle de mon vérin ( comme ça, je n'ai qu'un PCB à faire faire ). 

 

Pour cela, il me faudrait plus les schémas de ces adaptateur plutôt que des tout fait et c'est ca que je ne trouve

 

@ChristianR : Pour ce qui est du "pic" de consommation des moteurs au démarrage, je pensais plutôt mettre un gros condo en parallèle pour envoyer le jus du démarrage. Vous en pensez quoi ?

Transfo branché sur secteur.

Salut les gars,

 

Je cherche en vain depuis quelques jours un schéma de circuit d'alimentation pour la carte de contrôle de mon vérin ( que j'ai déjà faite ).

 

J'ai besoin d'un circuit d'alimentation 12V avec minimun 5A en sortie ( le vérin fait 60W, donc, si mes calculs sont bon I = 60/12 ce qui fait bien 5A ).

 

Le circuit doit aussi être relativement fiable et efficient ( il sera sollicité en permanence ) ainsi que bon marché de préférence ( car pour production à moyenne/grande échelle ).

 

Les seuls circuits que j'ai trouvé pour l'instant sont soit vraiment trop "cheap", soit à base de régulateurs de tension de la série des 78xxx qui ne permette une intensité de sortie de max 1A...

 

Donc si quelqu'un une solution, ou d'un lien pour m'orienter dans mes recherches, je prend !

 

Voila les specs du vérin : http://www.gemingag.com/sell-high_load_miniature_linear_actuator_ul_rohs_chair_mechanisms-113453.html

Merci d'avance !

Merci de votre soutien, j'en suis à 10 votes . Je vais essayé de faire du mailing ( j'aime spammer ) pour recolter un max de vote

Salut les gars,

Intel et Lenovo on lancé une sorte de concours dans lequel il promettent de réaliser un projets par catégories ( aventure, musique, pro ou artistique ) et par mois avec un budget de 25 000 E par projet. J'y ai donc soumis mon projet de poubelle domestique avec système de compression des déchets ( pour réduire le nombre de sacs poubelles jetés )et si je fais appelle à vous aujourd'hui c'est qu'il vient d'être retenu par le jury du concours et qu'il me faut maintenant 250 votes pour qu'ils soit réaliser.

Donc si vous avez deux minutes, ce serais cool de voter pour mon projet ici : http://www.fallaitlefaire.fr/projet.php?id=1690

Merci

Problème résolu, c’était en fait un bug récurrent de ma version du kernel ( 3.12 ). J'ai donc "downgradé" ma version du kernel pour 3.10 et tout à marché niquel

Maintenant, espérons que je puisse faire marcher mon écran tactile sur cette vielle version :/

Autre chose, je viens d'essayer et de réussir à envoyer des données de mon arduino jusqu'à ma Raspberry via bluetooth ( J'ai utiliser minicom pour les lire sur la raspberry ). Il faut juste qu'on arrive à faire l'inverse maintenant

Salut les gars,

Je suis, depuis deux jours, en train d'essayer de faire dialoguer ma Raspberry Pi avec mon Arduino sans succès...

J'ai pourtant TOUT essayé, suivi TOUT les guides, lu TOUTES les documentations sur le sujet mais il m'est toujours impossible d'établir cette maudite connexion...

Je possède donc une raspberry Pi modèle B avec un dongle bluetooth https://www.adafruit.com/products/1327 et une arduino Uno avec un module bluetooth https://www.adafruit.com/product/1588.

J'ai donc commencé par suivre ce guide http://blog.dawnrobotics.co.uk/2013/11/talking-to-a-bluetooth-serial-module-with-a-raspberry-pi/, puis celui la https://learn.adafru...-g-raspberry-pi mais aucun n'a abouti à quelque chose de concluant.

En effet, après avoir "pairer" ma raspberry et mon module en suivant les guides, j'ai donc essayer d'envoyer depuis ma raspberry Pi du texte en bluetooth a l'Arduino ( qui l’interprétera comme une commande ) en utilisant PySerial ( comme dans le premier guide ). Je configure donc mon port série, la "baudrate" toussatoussa et exécute mon code... Et la bim, une erreur :

write failed: [Errno 107] Transport endpoint is not connected

Je me renseigne donc sur internet et tombe sur ce site https://bugzilla.red....cgi?id=1060457 ou ils expliquent que c'est un bug récurant sur les nouvelles versions ( 3.12.6 et 3.12.8 ) du kernel ( dont ma version de Raspbian fait partie ) mais qu'il suffit de rajouter un délais pour laisser le temps à la connexion de s'établir. J'ajoute donc un délais ( de 5 seconde ) à mon code, le re éxecute... Et voila encore l'erreur qui réapparais...

Voila donc mon code de test :

#! /usr/bin/python
 
import serial
import time
 
bluetoothSerial = serial.Serial( "/dev/rfcomm0", baudrate=9600 )
time.sleep(5)
bluetoothSerial.write( "avancer") #Qui doit être reçu par l'Arduino

Voila voila, donc si quelqu'un a une idée

merci

Vérifie que tu à bien activé la detection des "sources inconnus" sur ton téléphone.

Sinon, tu pourrais, plutôt que d'utiliser une applis, utilisé une liaison série ( c'est beaucoup plus facile )

Demande moi pour plus d'info sur les liaisons série

En fait, tout les exemples de code que je trouves utilisant les interruptions utilise des changement d'états provenant de l'exterieur et neccesite donc un "numéro de pin" comme support à AttachIterrupt() :/

Sinon je viens d'essayer d'utiliser break; pour sortir de la boucle while() mais encore une fois, je reste bloqué dedans...

Plus d'explications ou c'est assez claire comme ça ?

Euh... Oui, c'est encore un peut trouble dans mon esprit Doit t'on utiliser la fonction Interrupt() pour ca ?

dans ton second code tu restes bloqué en boucle dans " while (c==6) " Du coup tu ne peux pas en sortir pour changer la valeur de C ...

Ah ok, je croyais que si la valeur de c changeait, la condition de la boucle while était brisée et on en sortait donc

Enfin avec la solution que je te propose ça permet de lancer la boucle mode auto un certain nombre de fois mais ne te permet pas de la coupée à nimporte quelle moment. Par contre si ton but c'est de la couper quand tu veux, le plus propre pour cela serait de le faire via des interruptions.

Mon but est effectivement que le mode auto ne s’arrête qu'à l'envoi d'un nouvel ordre. Je me suis donc un peut renseigner sur la fonction interrupt()mais ne vit pas comment l'utiliser dans mon cas :/

Je viens d'essayer, quand le robot passe en mode "autonome", il se met à faire n'importe quoi ( même en bidouillant les delays et la valeur de nboucle ) :/ En revanche, cette fois je peut arreté la fonction en envoyant un nouvel ordre

Mais je ne comprend surtout pas pourquoi ca ne marche pas avec mon second code

Ok je viens d'essayer en rajoutant une boucle while( c == '6'){ la fonction auto tourne en boucle }. Ca marche plutot bien sauf que maintenant, une fois la fonction auto lancé, je peut plus en sortir pour reprendre le contrôle manuel...

Des idées ?
Le code tel qu'il est maintenant :

#include <DistanceSRF04.h>
DistanceSRF04 Dist;
int distance;
int VAL;
int motorD1 = 6; // H-bridge leg 1 
int motorD2 = 7; // H-bridge leg 2 
int motorG1 = 4;
int motorG2 = 5;
int speedG = 2;
int speedD = 3; // H-bridge enable pin 
int vitesse = 130;

void setup() {
  Dist.begin(13,12);
  pinMode(motorD1, OUTPUT); 
  pinMode(motorD2, OUTPUT); 
  pinMode(speedD, OUTPUT);
  pinMode(motorG1, OUTPUT); 
  pinMode(motorG2, OUTPUT); 
  pinMode(speedG, OUTPUT);
  pinMode(9, INPUT);
  pinMode(10, INPUT);
  Serial.begin(9600);
}

void loop() {
   while (Serial.available() == 0); // On attend l'arrivé d'ordre par bluetooth
   char c = Serial.read();
   if(c =='1') { // Si on recoit l'odre 1
    digitalWrite(motorD1, HIGH);  // On avance
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, HIGH);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   if(c == '2'){ // Si on recoit l'ordre 2
    digitalWrite(motorD1, LOW);  // On recule
    digitalWrite(motorD2, HIGH);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, HIGH);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '3'){ // si on recoit l'ordre 3
    digitalWrite(motorD1, LOW);  // On tourne a gauche
    digitalWrite(motorD2, HIGH);
    digitalWrite(motorG1, HIGH);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '4'){  // Si on recoit l'ordre 4
    digitalWrite(motorD1, HIGH);  // On tourne a droite
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, HIGH);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '5'){ // Si on recoit l'ordre 5
    digitalWrite(motorD1, LOW); // On stop
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
  while(c == '6'){  // Si on recoit l'ordre 6
    int distance = Dist.getDistanceCentimeter(); // On passe en mode "autonome"
    if (distance <= 10){
        digitalWrite(motorD1, LOW);
        digitalWrite(motorD2, HIGH);
        digitalWrite(motorG1, LOW);
        digitalWrite(motorG2, HIGH);
        analogWrite(speedD, vitesse);
        analogWrite(speedG, vitesse);
    }
    if (distance < 25 && distance > 10) {
        digitalWrite(motorD1, HIGH);
        digitalWrite(motorD2, LOW);
        digitalWrite(motorG1, LOW);
        digitalWrite(motorG2, HIGH);
        analogWrite(speedD, vitesse);
        analogWrite(speedG, vitesse);
    }
    if (distance > 25) {
        digitalWrite(motorD1, HIGH);
        digitalWrite(motorD2, LOW);
        digitalWrite(motorG1, HIGH);
        digitalWrite(motorG2, LOW);
        analogWrite(speedD, vitesse);
        analogWrite(speedG, vitesse);
    }
    }
    
       Serial.println(c);
       delay(500);
    }

Salut les gars,

Je me suis lancé recement dans un projet qui consiste ( entre autres ) à pouvoir contrôler mon robot depuis une interface graphique sur un écran tactile de ma raspberry pi. Ayant déjà fais l'interface graphique, je me suis lancé hier dans la rédaction du code arduino de mon robot.

Le robot est muni d'un module bluetooth et recevra à terme les commande via la raspberry Pi.

En gros le robot reçoit des valeurs en bluetooth de 1 à 5 ( chaque numero correspondant à un mouvement ) et la valeur 6 correspond au passage du robot en mode "autonome" ( il est muni d'un petit capteur ulrasonique à l'avant ).

Mais voila mon problème : Quand j'envoi une valeur de 1 à 5, tout marche bien, le robot execute ce qui est écrit dans le code. En revanche quand j'envois l'ordre de passer en mode "autonome", le robot bouge n'importe comment...

C'est assez difficile à expliqué mais j'ai en fait l'impression que le robot exécute la fonction "auto_mode" pendant une fraction de seconde quand il en reçoit l'ordre puis le robot reste " bloqué" dans le mouvement qu'il a commencé durant cette fraction de seconde.

Merci d'avance

#include <DistanceSRF04.h>
DistanceSRF04 Dist;
int distance;
int VAL;
int motorD1 = 6; // H-bridge leg 1 
int motorD2 = 7; // H-bridge leg 2 
int motorG1 = 4;
int motorG2 = 5;
int speedG = 2;
int speedD = 3; // H-bridge enable pin 
int vitesse = 130;

void setup() {
  Dist.begin(13,12);
  pinMode(motorD1, OUTPUT); 
  pinMode(motorD2, OUTPUT); 
  pinMode(speedD, OUTPUT);
  pinMode(motorG1, OUTPUT); 
  pinMode(motorG2, OUTPUT); 
  pinMode(speedG, OUTPUT);
  pinMode(9, INPUT);
  pinMode(10, INPUT);
  Serial.begin(9600);
}

void loop() {
   while (Serial.available() == 0); // wait for character to arrive
   char c = Serial.read();
   if(c =='1') {
    digitalWrite(motorD1, HIGH);
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, HIGH);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   if(c == '2'){
    digitalWrite(motorD1, LOW);
    digitalWrite(motorD2, HIGH);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, HIGH);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '3'){
    digitalWrite(motorD1, LOW);
    digitalWrite(motorD2, HIGH);
    digitalWrite(motorG1, HIGH);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '4'){
    digitalWrite(motorD1, HIGH);
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, HIGH);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '5'){
    digitalWrite(motorD1, LOW);
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
   }
   
   if(c == '6'){
     auto_mode();
   }
   delay(500);
}

void auto_mode(){
int distance = Dist.getDistanceCentimeter();
Serial.print("\nDistance in centimers: ");
Serial.print(distance); 
delay(100); //make it readable
// check the average distance and move accordingly
if (distance <= 10){
    digitalWrite(motorD1, LOW);
    digitalWrite(motorD2, HIGH);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, HIGH);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
}
if (distance < 25 && distance > 10) {
    digitalWrite(motorD1, HIGH);
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, LOW);
    digitalWrite(motorG2, HIGH);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
}
if (distance > 25) {
    digitalWrite(motorD1, HIGH);
    digitalWrite(motorD2, LOW);
    digitalWrite(motorG1, HIGH);
    digitalWrite(motorG2, LOW);
    analogWrite(speedD, vitesse);
    analogWrite(speedG, vitesse);
}
}
  

Salut les gars,

Etant encore au lycée, j'ai décidé, cet été, de bosser 1 mois dans un boite de développement web ou autre. Je fini donc par décroché un job dans une boite de développement web. Bref arrivé la bas, le patron me propose de réaliser pour lui et, en un mois, le prototype d'un de ses projets qui utilise un système concu par lui même ( et qu'il à déjà breveté pour les petits malins ).

Ce système est un système de saisie et de navigation pour écran tactile de petites tailles ( montres, eletroménager, etc... ). Il se base sur un menu comportant 6 touches. A l'appuis sur l'une des touche, les autres prennent la couleurs de cette dernière et change donc d'utilité. Il suffit alors, sans avoir relâché le doigt après l'appuis de la première touche, de faire glisser son doigt vers une des nouvelles touches qui aura apparut. Ce système permet donc en très peut de place ( 6 cases ) d’accéder rapidement à beaucoup d'autres ( 36 cases ).

( Pour les explications, j’appellerais "touches de niveau 1" les 6 premières touches et "touche de niveau 2" les touches "crées" par l'appuis sur une des touches de niveau 1 )

Le prototype que je doit réaliser reprend ce système, il sera constitué d'un Raspberry Pi sur lequel sera branché une dalle tactile ( http://www.adafruit.com/products/1601 ). Sur cet écran devront apparaître les 6 touches de couleurs differentes ( voir photo ), l'appuis sur une de ces touches changera la couleurs des autres en celle de cette dernière. Aussi et, pour montrer les capacité de ce système à ce connecter à son environnement, une des touches de niveau 2 devra ouvrir un petit panneau de contrôle afin de piloté un robot sous arduino ( que j'ai déjà ) via bluetooth et une autre touche de niveau deux permettra de faire passer le robot en mode autonome.

N'ayant que les (grosses) bases du python, je n'ais aucune idée de par ou commencer ( surtout au niveau de l'interface graphique que je compte faire en python aussi ) ni des éventuels outils permettant de crée ce genre d’interfaces.

Je compte donc sur votre aide pour : m'orienter dans mes recherches, me dire si mon projet vous semble réalisable, si une interface graphique peut être fait en python et si oui comment

J'ai déjà vue sur le site d'Adafruits un moyen de faire tourné un version un peut modifiée de Raspian sur leur écran tactile https://learn.adafru...ay-raspberry-pi

Le matériel me sera fournit par la boite et j'ai un mois pile pour arriver à un résultat.

Merci d'avance

Ci dessous, un aperçu de ce a quoi devra ressemblé l’interface :