Aller au contenu


yougo

Inscrit(e) (le) 28 juil. 2016
Déconnecté Dernière activité janv. 08 2021 12:10
-----

Sujets que j'ai initiés

Logiciel machine learning automatique [Marche dynamique]

14 mai 2020 - 06:59

Bonjour à tous j'espère que vous allez bien en cette période difficile.

Durant ce confinement j'ai enfin pu relâcher un peu les études ce qui ma laisser le temps pour bidouiller un peu.
À l'époque où je fréquentais ce forum beaucoup d'entre vous aviez du mal a trouver des outils de simulation faciles d'accès et encore plus pour ce qui est du machine learning.

Du coup j'ai fait un petit logiciel dans lequel il suffit de glisser déposer le fichier descripteur de votre robot et hop vous venez le lendemain et il marche (en dynamique, et en théorie aussi :whistle2: ). J'ai pu tester le logiciel avec mes modèles (des bipedes) mais j'aimerais le tester avec d'autres robots. Il y en a beaucoup sur internet mais je me suis dit que quite à utiliser mon Pc autant que ça serve.

Ce que je vous propose c'est donc de m'envoyer vos fichiers URDF et en échange je vous renvoie (ici ou en prive) la vidéo des résultats pour le fun ("pour le fun" car je ne vais pas entrainer vos robots plus de quelques heures et de ce fait les résultats ne seront pas utilisables irl).

Les contraintes sont :

  • Le robot est un robot à pattes/jambes (c'est pourquoi je poste ici).
  • Le fichier descripteur est au format URDF
  • Le fichier URDF lui peut être le même fichier que vousutilizez dans ROS, sans les balises gazebo de préférence.
  • Le logiciel supporte les joints en boucles que les fichiers URDF standards ne supportent pas mais il vous faudra me préciser quel lien va avec quel lien, les limites du joint et l'axe.

 

 

Voilà si ça vous intéresse vous pouvez poster vos URDF, je vais privilégier les quadru (car moins long à entrainer et j'ai déjà fait pas mal de bipedes).

(Je m'engage à supprimer vos modèles URDF + réseau de neurones après l'entrainement et à ne publier les résultats sur ce forum que sous votre autorisation)

Le logiciel est en développement et donc je preshot la question : non il n'est pas encore publiquement dispo.

 

Tout ça j'ai pu l'apprendre à grace au temps passe sur le projet Walk-e donc encore merci à ceux qui ont aidé :wub:

 

A vous de faire chauffer ma carte graphique !
 


Walk-e sondage

28 octobre 2018 - 08:47

Salut les Makers!
 
Nous aimerions prendre vos avis sur certaines question au sujet de la robotique et du projet Walk-e (https://www.robot-ma...-soutenez-nous/)
 
Pour faire simple nous avons réalisé un  questionnaire qui va nous servir à aiguiller le projet Walk-e dans le sens où vous aimeriez qu'il aille, pour continuer d'évoluer ensemble, dans un sens c'est un peu une partie "d'étude de marché".
 
Vu que les "études de marché" au niveau de la robotique, ça ne court pas les rues, nous vous partagerons la majorité des réponses ici même. (A l'exception probable de la partie 7/8 qui ne concerne que le projet Walk-e alors que les autres questions sont plus larges et concernent la robotique en général.)
 
sur ce, si cela vous intéresse, voici le lien pour participer :
 
 
Merci à tous pour le temps que vous allez consacrer à ce questionnaire  :thank_you:

Code de Servomoteur Pour Unity

09 avril 2018 - 05:01

Salut les Makers !

 

Si vous avez déjà essayé de faire votre simulation sur Unity, vous savez probablement qu'il est super-simple de faire des moteurs, mais quand on veut des servos moteurs, ben c'est foutu... On doit les faire tout seul !
 
Ce fut le cas de mon équipe pour simuler notre robot walk-E
Fichier joint  walkE.jpg   52,12 Ko   123 téléchargement(s)
 
 
Du coup on vous partage ici ce qu'on a fait pour créer des servos moteurs sous Unity. 
 
Donc ci-dessous le code en C# : 
 
//@walk-e Team
//vous pouvez utiliser et modifier ce code comme bon vous semble 
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;

public class ScriptMoteur : MonoBehaviour
{

    public HingeJoint hingeJoint3D;
    GameObject mainServo;
    private JointMotor motor;

    [Tooltip("Angle of the target servo in degrees")]
    [Range(-180f, 180f)]
    public float targetServoAngle;

    private float anglerech; //angle que le moteur cherche à atteindre 

    //boucle qui va s'exécuter au lancement de la simu juste une fois 
    void Start()
    {
        anglerech = targetServoAngle;

        this.motor = hingeJoint3D.motor;
        //unity a déjà prévu d'ajouter des moteurs surs la jointure 
        //donc hingeJoint3D.motor est un moteur que l'on va pouvoir controler
        this.motor.force = 50;
        //on peut changer la force du moteur

        this.motor.targetVelocity = 0;
        //on peut changer la vitesse de rotation 

        this.motor.freeSpin = false;
        //pour le laisser en roue libre
        
        this.hingeJoint3D.motor = motor;
        // hingeJoint3D.motor = motor pour que hingeJoint3D.motor prenne bien les modifs de motors 
        //j'oubliais ca au debut donc forcement ca marche pas trop 

        this.hingeJoint3D.useMotor = true;
        //on lui dit qu'elle doit utiliser le moteur 


        Debug.Log("ServoMoteurEnAction");


    }

    //ici c'est une boucle qui tourne tout le long de le sium à chaque rafraîchissement de l'ecran
    void Update()
    {

        //on calcule la distance entre this.hingeJoint3D.angle (angle actuel) et l'angle cible 
        float distance = Mathf.DeltaAngle(this.hingeJoint3D.angle, targetServoAngle);

        //en fonction de ca on déduit le sens de rotation
        if (distance < 0)
        {
           motorActiv(-1);
        }
        else
        {
           motorActiv(1);
        }


        this.hingeJoint3D.motor = motor;
        //on oublie pas à la fin de void Update() de bien utiliser hingeJoint3D.motor = motor; sinon les modifs appliqués a motor ne s'appliquent pas 
    }


    //un setter si jamais on veut changer l'angle cible dans une classe externe
    public void setAngle(int pvanglerech)
    {
        this.anglerech = pvanglerech;
    }


    //fonction 'principale'   
    private void motorActiv(int way)
    {
        this.motor.targetVelocity = 100 * way;
        this.motor.force = 100;
        UpdateRotationLimits(way);
        hingeJoint3D.useLimits = true;
    }

    //on change juste les limites pour stoper le moteur 
    void UpdateRotationLimits(int direction)
    {
        var limits = new JointLimits();
        if (direction == 1)
        {
            limits.max = targetServoAngle;
            limits.min = 0;
        }
        if (direction == -1)
        {
            limits.min = targetServoAngle;
            limits.max = 0;
        }
        hingeJoint3D.limits = limits;
    }

 //ce qui suit fut trouvé sur internet (Open Source bien sur)  -------------------------

    float AngleFromAngle1ToAngle2Degrees(float angle1, float angle2)
    {
        angle1 = WrapAngleDegrees(angle1);
        angle2 = WrapAngleDegrees(angle2);
        if (angle2 - angle1 < 180 && angle2 > angle1)
        {
            return angle2 - angle1;
        }
        else if (angle2 - angle1 > 180 && angle2 > angle1)
        {
            return -(360 - (angle2 - angle1));
        }
        else if (angle1 - angle2 < 180 && angle1 > angle2)
        {
            return -(angle1 - angle2);
        }
        else if (angle1 - angle2 > 180 && angle1 > angle2)
        {
            return 360 - (angle1 - angle2);
        }
        else if (angle1 - angle2 == 180)
        {
            return 180;
        }
        else if (angle2 - angle1 == 180)
        {
            return 180;
        }
        return 0;
    }
                           

    // Convenience function to keep the angles in range from -360 to 360
    static float WrapAngleDegrees(float angle)
    {
        angle = (float)Math.IEEERemainder(angle, 360);
        if (angle <= 0)
        {
            angle += 360;
        }
        else
        {
            if (angle > 360)
            {
                angle -= 360;
            }
        }
        return angle;
    }








}

 
(J'ai essayé de commenter un max mais bon je peux pas tout expliquer il vous faudra des bases en C# et Unity quand même) 
 
Et ici un projet en .zip Unity déjà tout fait contenant un petit bipède déjà tout fait spécialement pour vous qu'il ne vous reste qu'à faire courir partout :
 
Fichier joint  RobotMaker.zip   4,2 Mo   610 téléchargement(s)
 
Pour ouvrir: décompressez , ouvrez unity, cliquez sur 'open', sélectionnez le dossier.  
Une fois ouvert cliquez dans assets sur la seule scene disponible.
 
 
En espérant que vous appréciez et que ca va vous servir  ;)

Entraînement d'un réseau de neurones artificiels grâce à un algorithme d'évolut...

03 juin 2017 - 11:04

Salut tout le monde,
 
il n'y a pas mal de temps, j'avais dit sur un de mes post que j’avais fait un petit réseau de neurones entraîné par un algorithme d'évolution génétique dans le but d'en apprendre un peu plus sur le sujet. 
Il se trouve que je l'ai fini il y a environ 2 mois, mais était donné que c’était ce que je pressentais aux TP d'ISN pour mon BAC je ne pouvais pas le poster... 
Mais bon les épreuves sont finies donc je vous fais un petit explicatif de comment ça marche tout ça :
(juste un détail : je suis un AMATEUR et je rédige cet article pour vous donc ne me lapider pas si je fais une faute)    )
 
 
Avant de présenter le projet que nous allons réalisé il est nécessaire de se pencher sur les questions suivantes : 
 
1) qu’est-ce qu’un réseau de neurones artificiel ?
 
Comme son nom le laisse pensée, un réseau neuronal artificiel est un ensemble d’algorithmes très fortement inspiré de la biologie. Le but était de simuler de façon mathématique le fonctionnement d'un neurone.
 
Nous allons donc en premier temps expliquer comment marche un neurone de façon extrêmement simplifiée (oui oui c'est de la SVT déso les gars) : 
 
les neurones sont des cellules biologiques que l'on trouve dans tout le système nerveux et notamment dans le cerveau, ces cellules sont connectées les unes aux autres.
Ces connexions sont assurées par une terminaison présente sur le neurone, nommé axone.
Par cet axone un neurone peut envoyer un signal électrique aux autres neurones 
 
Le fonctionnement d'un neurone est donc la suivante : 
 
le neurone reçoit(/ou pas) un signal électrique venant des axones d'autres neurones, auquel il est lui-même connecté, et en fonction des signaux reçus , il fait quelque chose de plutôt « binaire » c'est-à-dire :
-soit il envoie aucun courant dans son axone 
-soit il envoie un signal électrique dans son axone
 
 
Fichier joint  Capture d’écran (188).png   45,84 Ko   41 téléchargement(s)
 
 
On sait aussi que la connexion entre les neurones, qui se fait par les synapses et peut-être plus ou moins forte. Lors d'un apprentissage, la force de ces connexions se modifie. 
Comme nous le montre la nature, connecter des milliards de neurones avec les bonnes connexions synaptiques peut créer un outil très puissant, mais surtout flexible qui est capable de résoudre de nombreux problèmes : le cerveau (c'est sur ça dépend chez qui hein) !
 
 
 
 
 
Maintenant que nous avons vu le fonctionnement approximatif d'un neurone, on peut extrapoler à des fonctions mathématiques qui ont pour but de reproduire leurs fonctionnements : les neurones artificiels.
 
Nous allons directement commencer par un exemple :
 
Créons donc un neurone avec 3 entrées (dendrites) qui vont envoyer des chiffres, X1,2 et 3, soit 1 ou 0 et affecter un coefficient à chacune des entrées (poids) P1, 2 et 3.
 
Le coefficient va modéliser la force de connexion des neurones, le neurone va donc additionner les valeurs reçues par les 3 entrées en prenant en compte les coefficients.
 
Fichier joint  Capture d’écran (189).png   21,73 Ko   39 téléchargement(s)
 
Si la somme est inférieure à un seuil « S » le neurone renvoyé 0 et si elle est supérieure au seuil le neurone renvoyé 1 (on aurait pu choisir n’importe quels autres chiffres) 
 
Et voilà nous avons reconstruit un neurone artificiel !! (wow) !
 
Pour résumer : le neurone artificiel est une fonction mathématique qui prend un nombre N d'entrée, en fait la somme avec un nombre N de coefficients, puis rend un nombre en sortie. 
 
C'est bien joli tout çà mais à quoi ça sert ?!?
 
Et bien tout comme dans le cerveau, ici un seul neurone n'est pas très efficace, mais combiner en réseau on peut obtenir des résultats de « cerveaux artificiels » très puissant, on peut par exemple citer le fameux algorithme de « deep learning » de Google, qui si on lui donne une image en entrée, est capable de dire ce qu'il y a dans l'image, avec une certitude de plus de 95 % (ce qui est meilleur que le meilleur des humains) !
 
Mais le grand problème avec ce type de programme c'est que l'on va devoir trouver justement tous les « poids » et « seuils » qui relient tous les neurones entrés eux.
Pour trouver les bonnes valeurs, on pourrait par exemple tout chercher a la main, mais il y a différents moyens d'y arriver, ici nous allons le faire grâce à un algorithme dévolution génétique. (à savoir que dans le monde des neurones l’apprentissage par rétroaction est bien plus coté, mais bon j'ai rien compris donc voila...)
 
 
 
2) Qu’est-ce qu’un algorithme dévolution génétique ?
 
Les algorithmes d’évolution génétiques sont inspirés de la théorie de l’évolution de Darwin et utilisent le principe selon lequel, l’entité la plus apte à résoudre un problème va survirer et se reproduire, pour participer à l'évolution de l’espèce.
 
Si nous pouvons utiliser un algorithme de ce type, alors nous n'aurions aucun problème pour trouver tous les poids et seuils, il suffirait de laisser un programme tourner et tester plein de configuration, les croiser, éliminer les moins aptes et garder les plus forts, pour au final trouver les poids qui marchent le mieux ! 
 
Et bien c'est ce qu'on va faire tout de suite ! 
 
 
En fait non je vous arrête tout de suite ! je n'ai pas poser le cadre du projet ! 
 
donc voila le but est de reproduire quelque chose de semblable a cette vidéo (elle m'avait fait triper quand j'ai découvert ça, certains membres s'en souviendront )  
 
 
Le but de ce programme est de faire évoluer des intelligences artificielles (que l'on va appeler poissons arbitrairement) dans un panel (qui sera leur environnement). 
Chacune des IA est construite d'une manière différente grâce à un réseau de neurones qui leur est propre.
Le programme consiste à trouver un poisson avec le réseau de neurone le plus adapté à résoudre un problème. 
Le problème est que: le poisson doit trouver une manière de se déplacer la plus optimisée pour manger le plus de nourriture possible en 10 secondes. 
 
Pour trouver un « super poisson » on va créer beaucoup de poissons différents, les tester puis faire reproduire ceux ayants mangés le plus de nourritures tandis que ceux qui en mangent le moins seront remplacés par les enfants des meilleurs. 
Ce procédé est appelé « algorithme d’évolution génétique » il reproduit en fait le principe de sélection naturelle comme quoi un individu apte à résoudre le problème va survivre et propager sa « solution » au fil du temps 
 
une petite image du projet :
 
Fichier joint  Capture d’écran (175).png   92 Ko   39 téléchargement(s)
 
on voit des "poissons" plus gros que d'autres car ils ont plus manger, donc que leurs réseau de neurones artificiel est plus performant 
 
 
3) Les algos le code et tout le tralala
 
le projet est en JAVA et est présenté par classes. Je ne peut pas commenter toutes les lignes du programme donc je présente les algos principaux , à vous de les adapter à votre langage de prédilection ;)
 
 
1) La classe environnement 
 
C'est la classe qui contrôle toutes les autres classes elle a pour but de faire tout marcher correctement et surtout dans le bon ordre,
Cette classe est un algorithme d'évolution génétique, il recrée dans l'ordre, toutes les étapes de la sélection naturelle , sur les poissons. 
 
Fichier joint  Capture d’écran (176).png   27,79 Ko   40 téléchargement(s)
 
1- il crée les individus et les nourritures
2- il les laisse évoluer librement 10 secondes 
3- il compare les scores grâce à la classe sélection
4- il accouple et fait muter les poissons grâce à la classe sélection
 
La classe est une boucle  qui se répète infiniment (thread) après avoir appelé la classe tableaux et créé les nourritures et les poissons
 
Fichier joint  Capture d’écran (177).png   30,95 Ko   38 téléchargement(s)
 
2) La classe tableau 
 
Nous avons fait une classe nommée « tableaux »  qui a pour but de créer tous les tableaux et de garantir le stockage de toutes les informations et l’accès par toutes les autres classes, c'est elle qui va donc le plus remplir la RAM .
Elle stocke : 
 
-Un tableau 2D (2*50 cases) pour les positions des nourritures 
-Un tableau 2D (100*8 cases ) pour les 8 gènes de chaque poissons
-Un tableau 2D (100*3) pour les 3 parties de couleurs RGB de chaque poissons 
-Un tableau 1D qui stocke les scores de chaque poissons
-Elle stocke aussi une variable booléenne qui sert d’interrupteur aux poissons
 
Les tableaux sont tous remplis plus ou moins sur le même modèle : 
prenons l’exemple du remplissage aléatoire du tableau qui contient les couleurs de chaque poissons. On a un algorithme qui part de la colonne 0 , (celle ou va se servir le poisson 0 ), jusqu’à la 99 , à chaque colonne il va entrer un entier aléatoire compris entre 0 et 255 dans les 3 lignes puis passer a la suivante.
 
Fichier joint  Capture d’écran (178).png   19,09 Ko   41 téléchargement(s)
 
Fichier joint  Capture d’écran (179).png   49,78 Ko   41 téléchargement(s)
 
Le tableau des scores quant à lui n'est pas rempli car de base un tableau créé est rempli de 0 , ce qui nous arrange car tous les poissons commencent avec un score de 0.
 
La classe tableau , en plus de la méthode principale , se compose de pleins de méthodes getters/setters , qui quand elles sont appelées dans d'autres classes permettent de modifier les tableaux de cette classe. C'est grâce à ces méthodes qu'il y a échange entre les classes. 
 
 
3) La Classe sélection : 
 
En réalité elle s’occupe aussi des accouplements.
 
A) La méthode sélection:
 
Voyons comment nous sommes parvenus à classer les poissons en fonction de leurs codes : 
C'est en fait l'utilisation d'un tableau intermédiaire qui permet ça , 
1 ère ligne : nom 
deuxième : score 
on le remplis la première fois avec tous les scores des poissons :
 
Fichier joint  Capture d’écran (180).png   5,52 Ko   38 téléchargement(s)
 
Puis on prend les premières cases et on regarde si le score qui correspond est plus grand dans la case d'après , si oui , alors on « pose » notre score dans cette case , puis on continue avec la case plus grande jusqu’à arriver a la fin du tableau : 
 
Fichier joint  Capture d’écran (181).png   25,77 Ko   37 téléchargement(s)
 
Fichier joint  Capture d’écran (182).png   44,33 Ko   36 téléchargement(s)
 
on peut noter l'utilisation de variables de stockage temporaires ce qui est très commun en programmation 
 
 
(je vous conseille de taper trie a bulle sur Wikipédia ils ont un GIF très bien pour expliquer le concept :                  https://fr.wikipedia...i/Tri_à_bulles                                )
 
 
B) La méthode accouplement :
 
Ensuite on procède a la partie accouplement , qui en réalité n'est rien d'autre que le remplacement du code génétique des plus mauvais pas celui du plus fort , c'est donc une méthode dite élitiste.
 
Comment ça marche :
 
on va prendre dans le tableau que l'on viens de classer la dernière case, donc celle avec le score le plus important , on peut donc avoir son nom.
 
Une fois que l'on a récupéré le nom du poisson le plus « performant » 
on va procéder à un nombre « d’accouplement »  aléatoire qui va simplement remplacer 
 
Fichier joint  Capture d’écran (183).png   42,19 Ko   36 téléchargement(s)
 
4) La  classe objets :
 
Cette classe était là pour ajouter des nourritures qui font perdre du score et que les bettes auraient dû esquiver mais ça ne s'est pas fait , elle est donc un peu inutile car elle ne sert qu'en superclasse de la classe nourritures.
 
5) La classe nourritures :
 
Une classe nourritures descend donc de la classe objet mais ce n'est pas si important 
ce sont de simples ronds affichés dans la fenêtre, leurs positions sont stockées dans un tableau à 2 dimensions qui se trouve dans une classe qui regroupe tous les tableaux utilisés dans l’ensemble du programme . 
Cette classe objet est appelée dans la classe Environnement, qui est en quelque sorte la classe qui regroupe toutes les autres, elle est appelée autant de fois que l'on veut de nourritures  (50 fois ici ).
 
Leurs positions d'affichage est définie grâce au tableau qui stocke leurs position dans la classe tableau 
 
 
6) La classe poissons :
 
C'est la deuxième classe objet que nous verrons ici , bien plus compliquée , c'est justement la classe qui va créer tous les poissons.
Cette classe va se servir de tableaux qui sont créés dans la classe Tableaux  :
 
1 tableau dans lequel des poids ont été mis aléatoirement, à chaque poisson , est assigné 8 poids. Ce tableau va nous être très utile lors des croisements notamment.  
 
1 tableau des couleurs , pour rendre le programme plus compréhensible , chaque poisson aura de base une couleur qui lui est définie de la même façon que les poids.
Des chiffres compris entre 0 et 255 (rgb) sont mis aléatoirement dans un tableau , et chaque poisson utilise ses 3 cases qui lui sont assignées pour savoir de quelle couleur ils seront. 
 
1 tableau de scores , encore une fois une case est assignée à un poisson , et si le poisson détecte qu'il a manger une nourriture , il va ajouter +1 au chiffre qui se trouve dans le tableau de score , ceci va être utile lors de la sélection des poissons , pour savoir lequel est le plus performant.
 
Une fois que les poissons ont récupérés tour ces tableaux et les valeurs
 
les poissons sont une classe spéciale qui contient une implémentation de « runnable »
ce qui veut dire que la méthode principale de cette classe va se répéter sans arrêt ,
 voici un schéma de ce qu'il va se passer :
 
Fichier joint  Capture d’écran (184).png   26,2 Ko   37 téléchargement(s)
 
A) La méthode scanner : 
 
Elle prend en entrée le X et Y du poisson et va ressortir le X et Y de la nourriture la plus proche.
Pour faire ça on utilise une formule de maths simple : 
 
√[(Xpoisson - Xnouriture)² +(Ypoisson+Ynourriture)²] = distance Poisson/Nourriture 
 
on va donc scanner le tableau des positions de nourriture colonne par colonne, 
 
si colonne actuelle sup colonne précédente , alors  on enregistre les coordonnées x y dans des variables de stockage temporaire 
 
 c'est aussi dans la méthode scanner qu'on regarde si le poisson a « mangé »  la nourriture , en effet on va regarder si la distance retenue entre nourriture et poisson n'est pas inférieure au diamètre du poisson , dans ce cas le poisson a donc mangé la nourriture , on ajoute donc +1 dans sa case au tableau de nourritures 
 
B) La méthode Réseau Neuronal.
 
C'est la méthode la plus difficile à comprendre de tout le programme malgré qu’elle soit simple à coder, il faut bien comprendre le principe de réseau de neurones.
 
le neurone artificiel est une fonction mathématique qui prend un nombre N d'entrée , en fait la somme avec un nombre N de coefficient (1 par entrée)  , puis rend un nombre en sortie.
 
Les coefficients multiplicateurs représentent la force de connexion entre les neurones, elle est comprise entre -1,1 et 1,1 
 
elle prend en entrée 4 variables :
les position X et Y du poisson 
les positions X et Y de la nourriture la plus proche trouvée par la méthode scanner
 
Ces quatre données sont entrées dans les 2 neurones et additionnées entre elles après avoir étaé multipliées par les poids qui se trouvent dans le tableau prévu a cet effet 
 
Fichier joint  Capture d’écran (185).png   20,39 Ko   41 téléchargement(s)
 
En fonction du résultat de ces deux sommes ont va réaliser des actions différentes : 
Se déplacer de 1px  vers la gauche ou la droite 
Se déplacer de 1px  vers le haut ou le bas  
 
J'ai fait un schéma pour se rendre compte  du réseau :
 
Fichier joint  Capture d’écran (186).png   317,49 Ko   35 téléchargement(s)
 
7) La classe chrono :
 
Cette classe sert à rafraîchir la fenêtre à intervalle régulier, elle supprime toutes les entités présentes dans la fenêtre toutes les 1 ms ce qui permet de voir des mouvements fluides à l’écran 
 
 
8) La classe fenêtre :
 
Rien de très spectaculaire encore , la classe fenêtre fait une fenêtre dans laquelle elle affiche un panel qui est rempli par la classe environnement. 
 
9) La classe Main:
 
C'est la classe qui se lance quand on clique sur le programme, 
elle lance la classe tableau puis la classe fenêtre , qui va déclencher une cascade d'appel de classes : Environnement, poissons , nourritures, chrono , ect ect …  
 
 
 
Voila voila les amis c'est mon expérience perso que j'essaye d'expliquer ici, il doit y avoir des centaines d'autre façons de faire bien plus cool, c'est juste pour vous montrer comment moi j'ai fait !
 
Si il y a des endroit pas clairs dites le moi que j’arrange tout ça, sachez que je fais de mon mieux , c'est très dur de vulgariser des sujets comme ça...   
 
Le code complet arrive bientôt, mais j'ai un problème : les commentaires sont remplis de fautes ! je dois donc arranger ça !
Et aussi je suis pas super douer en français et je viens d'écrire ça aux alentours de minuit donc si vous voyez des fautes partout signalez le ;)   
 
 
 
 
 
 
 
 
 
 
 
 

 

 

 

 

 

 

 

 


WALK-E, Crowdfunding sur Ulule, Soutenez nous !!!

29 mai 2017 - 08:27

Fichier joint  header.jpg   52,12 Ko   134 téléchargement(s)
 
Salut à tous les Makers ! 
 
Après une petite absence due à la préparation du projet, nous y sommes enfin ! Notre projet de robot bipède est en financement participatif sur Ulule  :yahoo:  
 
Certains le savent déjà mais nous préparons la création d'un robot bipède depuis longtemps, notre idée est de vous partager cette création sur une chaîne YouTube pour, on lespère, vous aider et vous inspirer pour faire des projets de plus grandes envergures ! 
(les vidéos seront sur le style "colinfurze" ou "the hacksmith" pour les connaisseurs )   
 
Donc si vous souhaitez nous soutenir et participer à laventure ou juste en savoir un peu plus c'est juste ici :
 
https://fr.ulule.com/robot-walk-e/
 
 
La chaîne YouTube :  
 
 
 
 
Avant de finir quelques petits détails qui me semblent importants pour être transparents avec vous : 
 
Premièrement les visuels que vous pourrez voir sont principalement là pour épater et faire joli.
Réalisées par notre graphiste (qu'on embrasse d'ailleurs et qui nous a fait un très beau travail. merci Andrianasolo Thierry !) les images que vous pourrez voir sont là pour montrer le concept général aux non connaisseurs. 
 
Et comme vous pourrez le voir ce projet est très inspirer par le robot Cassie nous n'allons pas ce le cacher.
[Pour les curieux:
évidement pour être en règle au niveau de la loi mais aussi par simple respect nous avons contacté l'équipe d'ingénieurs qui est actuellement sur le vrai projet Cassie , et ceux-ci nous ont répondu qu'il n'y avait aucun souci (Sisi !).]
 
Voilà si vous avez des questions nhésitez pas !  :heart: