Oui j’espère que tu y arriveras je t’apporte juste mon expérience perso ! mais je pense qu'il est très probable (si échec il y a )  que la raison vienne de là

l'idée de griffes est pas bête R1D1 ou sinon des roues qui ne tournent que dans un sens  

Je suis vraiment curieux de comment tu vas faire avancer ça ! j'ai j'aimais réussit a faire marcher quelque chose avec un seul servo par patte a chaque fois j’avais ce problème :

Imaginons que tu avances une des pattes avant  et la patte inverse à l’arrière (au pif hein) , avec un seul servo le problème c'est que la patte touche le sol tout le temps , elle ne se lève pas , donc quand elle avance le robot recule , et quand elle recule ben il avance...et au final on fait du sur place !

Alors qu'en vrai c'est : on avance la patte en la levant donc le robot ne bouge pas , puis on la recule en la plaquant au sol pour faire avancer le robot ! (comme dans la vidéo sur les page prétendantes on voit bien le principe ) 

La solution que j'ai fait c'est , faire des sauts de lapins (ou grenouille comme vous voulez)    à la place de faire une patte avant + une patte arrière il avançait en ce propulsant avec les deux pattes arrières en même temps, ça marche mais bon c'est pas ce que tu veux je pense 

J'avais bien compris ton objectif Oracid bon courage 

Ahah ça y est Oracid ce lance ! bon courage, j'ai hâte de voir comment tu fais avec 4 servos , surtout ceux ci qui sont vraiment faibles , j'avais essayer avec le même modèle mais le chassie et la batterie étaient trop lourds pour ces petits servos , le résultat : un bruit infect car les servos forcent en permanence et un vitesse de déplacement de 0.00001 km/h 

Oui par exemple, je ne sais pas encore ce que je vais en faire, peut être que je vais acheter une raspberry et l'overclocker vraiment beaucoup.

Mais pour l'instant c'est plus un test pour voir si on peu faire du watercooling sans pompe,

juste en utilisant le fait qu'un gaz plus chaud est moins dense et j'espere que ca va créer un courant ! 

Mais c'est la théorie ça  j'ai bien envie de voir si ça marche assez bien pour refroidir quelque chose 

Salut a tous,

J'ai décider de faire un petit watercooling pour raspbeyry pi juste comme ça , je vous le met ici au cas ou ça vous intéresse.

Avant de commencer : Oui je sais très bien que c'est inutile , que les cartes ne chauffent pas temps que ça ect ect ... mais bon ça avait l'air fun 

donc : 

Pour commencer j'ai fait le WaterBloc : 

Il est composé d'une pièce en allu qui va transmettre la chaleur du CPU à l'eau. Pour la faire je me suis servi d'un vieux ventirad de carte graphique que j'ai découpé

le bloc en lui même est fait avec 3 plaques de pvc transparent (extrêmement) grossièrement découpés (mais j’arrange ça plus tard)   ,

-2 qui sont percés de la taille de la pièce en allu 

-1 qui est percée de 2 trous pour les raccords

(sur la première photo le trou des plaques n'est pas fini mais vous voyez le principe)   

ensuite ces plaques vont être collés en sandwich :

après je vais limer les plaques pour avoir un truc moins sale puis ajouter des plaque en allu sur les cotés  (car je trouve ça plus joli)  et les raccords et au final : 

voila c'est un petit waterbloc tout mimi (bon les finitions sont a revoir mais bon c’était juste pour le fun , je n'ai même pas de raspberry ) 

je vous mettrez la suite un jour, 

Bizzz

Sympa ta signature Path, merci 

Ahahahah oui c'est un membre de la famille, ils sont géniaux ! 

nvaste, on va pas faire des vidéos de 15 heures, mais si ca vous interresse de savoir comment marche un proco de l'interieur (pas l’architecture car jsuis nul , mais plutôt portes logiques et tout ) je le note

Un second post pour dire que :

Nous sommes a la recherche d'une PRUSA I3 MK2 

donc si quelqu'un veut vendre la sienne par le pur des hasards on la reprend prix neuf, car on doit attendre 7 semaines sans rien faire sinon...

J'ai contacté Prusa eux mêmes ils disent qu'ils ne veulent pas faire de favoritisme, ce qui est respectable de leur part.

Rien a redire Léon a tout dit c'est exactement ça !

Oui ça peut être utile car le sujet semble flou pour beaucoup de monde (dont moi il y a pas si longtemps) 

Mais si il y un seul truc que je devrais dire : c'est pas simple que vous pouvez l'imaginer ! Je ne dis pas ça pour vous faire peur au contraire lancez vous, mais ne sous estimez pas le travail qu'il y a derrière  

Salut Oracid, pour en avoir discuter avec des pro du modélisme, la Li-po semble plus flexible, plus dure a faire péter que la lithium-ion, d’après ce que j'ai compris:

les grosses Li-po / lithium-ion  doivent même être placés en coffre anti-feu si tu ne t'en sert pas et ne doivent pas être quitté de vue si tu recharges en intérieur 

(mais bon je en vrai personne ne fait ça ) 

Il me semble que la grosse différence c'est que la Li-po explose que si tu la surcharge très fort , mais en plus de ça la lithium-ion si elle se perfore ou quelle prend un coup, c'est la fin ! 

une petite vidéo a ne pas reproduire pour illustrer :

https://www.youtube.com/watch?v=CQ4E5CmpRsY 

la première est une lithium-ion la seconde une lipo. 

mais les lipos ont aussi leur problèmes :

https://www.youtube.com/watch?v=osfgkFyq7lA 

et pour finir une vidéo du JPL qui a fait exploser la batterie de leur robot en lithium-ion  (et ils utilisent pas le bon extincteur en plus ralalala ) : 

https://www.youtube....h?v=JECJAgRsp-4

Oracid , oui le servo est le asme-03A donc 24V et j'ai acheté exactement à ce lien la   j’espère juste que le délai n'est pas si long ...

il y a 5 articulations par jambes en fait , seulement 2 pour la hanche,je ne vois pas trop ou tu vois une double hanche, mais c'est vraiment dur a expliquer de façon écrite ... j'ai fait une mini présentation pour l’apéro-bot Toulouse , j'en parle normalement et on a filmé donc je vais essayer de le mettre par ici.

dans une ancienne vidéo que je fais sur blender on voyait bien que les 2 articulations permettent une très grand liberté de mouvement 

https://www.youtube....h?v=UgbziD1ECw0

pour ce qui est des deux articulations, elles ne font pas du tout la même chose, je m'explique  :

le premier servo en partant du haut , fait bien ce que tu dis "basculer la jambe d'avant en arrière selon un axe horizontal latéral." 

petit schéma en vue latérale : 

-en rouge = servo 

-blanc = articulation libre

mais le second, et c'est la qu'est toute l'astuce de cette structure ne fait pas du tout la même chose, en fait si on l'actionne, par effet levier  (grâces aux tiges bleu qui ne se déforment pas) on va réussir à lever la jambe , et donc le mouvement qu'engendre ce servo est en fait un élèvement VERTICAL du pied comme ceci : 

donc avec 2 servos on peut placer la jambe comme on veut sur ce plan et ça a en plus plein d'avantages

Salut,

un petit coucou pour dire que depuis qu'on a changé les pieds de walk-e, le robot tien très bien debout, mais juste un petit truc

La stabilisation sur les cotés se fait assez facilement grâce aux hanches, par contre il a une tendance assez forte a se péter la tronche vers l'avant 

on voit ce qu'on peut faire pour ca.

Si vous avez des questions style celle que Path a faite sur des trucs que l'on a déjà fait et que vous aimeriez que l'on explique hésitez pas je suis en vacances pour 5 jours donc je repasse du temps par ici   

Sinon dans le discord Robot Maker aussi c'est super cool ce qu'ils font sur le discord alors allez-y  

On prend toujours les infos Léon, on apprécie le mot de la fin 

J'ai compris qu'il faut faire de la simulation ne vous en faites pas, on va travailler la dessus 

et encore une fois je parle de simulation physique car la simulation de l’IA est déjà prévue...

C'est inutile donc d'encore essayé d'argumenter la dessus

Ce serrait plus utile que vous donniez des pistes pour la création physique, merci

bah c'est le projet ahah donc ne vous en faites pas, par contre comme on l'a dit, c'est des vidéos explicatives il faut donc faire de la vulgarisation robotique, passer à coté de quelques trucs , et bien sur il y a des parties qui vont vous faire dormir, comme "c'est quoi une carte arduino" ... mais bon on fait du grand public hein  

Oui il y a eu un grooooooos rush , la première vidéo va traiter du crowdfunding en lui même donc vous aurez donc des réponses plus précises  

C'est vrai que c'est exactement ca ! on attend on va faire un financement pour les réacteurs !!!

Ahhhhh, non de plus c’était un test cette modélisation il manque une partie de jambe dans l'ancienne.

celle si est plus proche (même si on voit mal la cheville) j'ai essayer de faire les asme-03A plus réalistes pour mieux voir :

C'est super tous les retours, merci beaucoup

J'ai installé AnyKode, je découvre, ça parait plutôt simple pour l’instant, tant mieux ! 

Par contre les tutos a ma dispositions sont vraiment basiques, si vous avez des ressources, notamment par simulé un servomoteur (ou une articulation) ça serait sympa  

C'est intéressant bonne chance avec ta M-E  

C'est vrai qu'actuellement 1200 e pour un pauvre robot a chenilles c'est cher payer... surtout que l'on peu déplacer une caravane a la main avec un peu d'aide,

J'ai déjà vu la même chose sur une remorque pour bateau c'est pas mal aussi !

Salut a tous;  j'ai un petit problème :

comment utiliser les getters (et setters) avec un tableau multidimensionnel ?

voila c'est pas très long comme question mais ça me pose un gros problème donc merci d'avance pour vos raiponces car je commence a m’énerver / perdre espoir la ...  

Ok bon c'est vrai que c'est pas très clair donc je vais mettre des bouts de code pour expliquer;

j'ai cette classe dans la quelle je creer un tableau "tablPosNouriture" :

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.ImageIcon;
import javax.swing.JPanel;

import objets.Nouriture;
import objets.Objets;

@SuppressWarnings("serial")
public class Envir extends JPanel {

//ne vous souciez pas de ca 
		// classe qui va tout gerer en gros 
	//penser a changer 200 par une variable qu'on va pouvoir changer
	private Nouriture[]nouriture = new Nouriture[200];// on creer un tableau d'objets
	private ImageIcon icoFond;
	private Image imgFond;
	private int Xfond1;
///////////////////////////////////////////////////////////
/////////////////////ici//////////////////////////////////
///////////////////////////////////////////////////////
	public int[][] tablPosNouriture= new int[3][200]; //on créer un grand tableau vide avec tte les positions + les noms genre {"x","y","nom"}
    private ArrayList<Nouriture> tabNour; // tableau d'objet qui contien tout les nouriture
	
	//constructeur
	public Envir(){
		super();
		//ici on déclare tt nos merdes
		
		this.Xfond1 = 0;
		icoFond = new ImageIcon(getClass().getResource("/images/Fond.png"));
		this.imgFond = this.icoFond.getImage();
		
		
		
		// peut etre metre ca dans main
		for(int i=0; i<200 ; i++){
			Random rand = new Random();
			int nombX = rand.nextInt(1450); //création d'un nombre aléatoire 
			int nomby = rand.nextInt(950); //création d'un nombre aléatoire 
		nouriture[i] = new Nouriture(nombX,nomby,i);//création de 200 nouritures aléatoire
		tablPosNouriture[0][i] = i;// 1er ligne = nom (utile plus tard pour colisions (quand la bete et la nouriture seront au meme endroite on utilisera le nom pour changer sa position pour pas que la bte sois statique
		tablPosNouriture[1][i] = nombX;//2eme = X
		tablPosNouriture[2][i] = nomby;// 3 eme = Y
		}
		
		
		//test ci la tableau marche bien 
		System.out.println(tablPosNouriture[0][130]);

		System.out.println(tablPosNouriture[1][130]);

		System.out.println(tablPosNouriture[2][130]);
//ca marche bien okok 
		
		
		
	tabNour = new ArrayList<Nouriture>();
	
	
	for(int c=0; c<200 ; c++){
		this.tabNour.add(nouriture[c]);	//on remplis tabnour}
	
	}
		
		
		
		
		
		
		
		
		Thread chronoEcran = new Thread(new Chrono());// petit programe qui tourne en fond qui repeind oklm
	chronoEcran.start();
	}
	
	
	
	
	
	public void paintComponent(Graphics g){
	super.paintComponent(g);
	Graphics g2 = (Graphics2D)g;
	g2.drawImage(imgFond, Xfond1, 0, null);
	
	
	for(int b=0 ;b<tabNour.size();b++){
		g2.drawImage(this.tabNour.get(b).getImgNouriture(), this.tabNour.get(b).getX(), this.tabNour.get(b).getY(), null);
	}}
	

///////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////


	public int[][] getTablPosNouriture() {
		return tablPosNouriture;
	}

	public void setTablPosNouriture(int[][] tablPosNouriture) {
		this.tablPosNouriture = tablPosNouriture;
	}
	
	/////////////////////////////////////////////////////////////
	///////////////////////////ici j'ai fait les getters de base que eclipse donne /////////////////////////////////
	
	
	public  void Scaner (int Xp,int Yp){
		
	int varX=0 ;
	int nomX =0 ;
	int varY=0 ;
	int nomY= 0  ;

	int comparaison ;
	//foncion qui va scaner le tableau tablPosNouriture pour rendre la position de la nouriture la plus proche 
	//enfin si jarrive a faire marcher les getters putin de merde
	for(int u= 0; u<200; u++){

		if(Xp-Math.abs(varX) > tablPosNouriture[1][u]){//varX prends la coordoné du X le plus proche de ceului qu'on lui a doner 
			varX= tablPosNouriture[1][u] ;
			nomX = u ;

			
			}
		if(Yp-Math.abs(varY) > tablPosNouriture[1][u]){//varY prends la coordoné du Y le plus proche de ceului qu'on lui a doner 
			varY= tablPosNouriture[1][u] ;
			nomY = u ;
			}	
		}
	
	//a la fin de la boucle on regarde lequel des deux est le plus pret :
	comparaison = varX-varY ;
	
	//si varX est plus proche 
	if (comparaison>0){
		System.out.println("nouriture la plus proche");

		//on renvoi les coordonées finalles de nomX
		System.out.println(tablPosNouriture[1][nomX]);
		System.out.println(tablPosNouriture[2][nomX]);
		
	}
	
	if (comparaison<=0){
		System.out.println("nouriture la plus proche");

		//on renvoi les coordonées finalles de nomX
		System.out.println(tablPosNouriture[1][nomY]);
		System.out.println(tablPosNouriture[2][nomY]);
		
	}
	
	
		
		
	
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	}
//metre un setters plus tard 
	

et j'ai cette classe ou j'aimerais réutiliser le fameux tableau 

package personages;

import java.awt.Image;
import java.util.Objects;

import javax.swing.ImageIcon;

import objets.Objets;

public class Poisson extends Objets implements Runnable{

	private int PAUSE = 8 ;
	private Image imgPoisson;
	private ImageIcon icoPoisson;
	
	
	public Poisson(int xi, int yi) {
		super(xi, yi);
	    
		this.icoPoisson = new ImageIcon(getClass().getResource("/images/Poisson.png"));
		this.imgPoisson = this.icoPoisson.getImage();
		
		
	Thread chronoPoiss = new Thread(this);
	chronoPoiss.start();
	
	
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	
		
	}

	public Image imgPoisson() {return imgPoisson;}
	
	
	
	
	
	
	int varibletabl;
	
	
	private void scan(){
	int Nom ;
	int X ;
	int Y;

		//foncion qui va scaner le tableau tablPosNouriture pour rendre la position de la nouriture la plus proche 
	       //enfin si jarrive a faire marcher les getters ‹

	
	///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////ici j'aimerais me reservir du tableau , comment faire ????/////////////////////////////////////////////‹
	
	
	
}}

ps : merci de la réactivité sérieusement j'ai poster dans plusieurs forums (de programmation surtout ) ben vous êtes les seuls a répondre

////////////////////////////////////////////////////////////////////////////////////////////////////MAJ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

j'ai donc essayer de contourner le problème en insèrent ce que je voulais faire dans la deuxième classe a l’intérieur de la première ça donne ceci :

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.ImageIcon;
import javax.swing.JPanel;

import objets.Nouriture;
import objets.Objets;

@SuppressWarnings("serial")
public class Envir extends JPanel {
		// classe qui va tout gerer en gros 
	//penser a changer 200 par une variable qu'on va pouvoir changer
	private Nouriture[]nouriture = new Nouriture[200];// on creer un tableau d'objets
	private ImageIcon icoFond;
	private Image imgFond;
	private int Xfond1;
	public int[][] tablPosNouriture= new int[3][200]; //on créer un grand tableau vide avec tte les positions + les noms genre {"x","y","nom"}
    private ArrayList<Nouriture> tabNour; // tableau d'objet qui contien tout les nouriture
	
	//constructeur
	public Envir(){
		super();
		//ici on déclare tt nos merdes
		
		this.Xfond1 = 0;
		icoFond = new ImageIcon(getClass().getResource("/images/Fond.png"));
		this.imgFond = this.icoFond.getImage();
		
		
		
		// peut etre metre ca dans main
		for(int i=0; i<200 ; i++){
			Random rand = new Random();
			int nombX = rand.nextInt(1450); //création d'un nombre aléatoire 
			int nomby = rand.nextInt(950); //création d'un nombre aléatoire 
		nouriture[i] = new Nouriture(nombX,nomby,i);//création de 200 nouritures aléatoire
		tablPosNouriture[0][i] = i;// 1er ligne = nom (utile plus tard pour colisions (quand la bete et la nouriture seront au meme endroite on utilisera le nom pour changer sa position pour pas que la bte sois statique
		tablPosNouriture[1][i] = nombX;//2eme = X
		tablPosNouriture[2][i] = nomby;// 3 eme = Y
		}
		
		
		//test ci la tableau marche bien 
		System.out.println(tablPosNouriture[0][130]);

		System.out.println(tablPosNouriture[1][130]);

		System.out.println(tablPosNouriture[2][130]);
//ca marche bien okok 
		
		
		
	tabNour = new ArrayList<Nouriture>();
	
	
	for(int c=0; c<200 ; c++){
		this.tabNour.add(nouriture[c]);	//on remplis tabnour}
	
	}
		
		
		
		
		
		
		
		
		Thread chronoEcran = new Thread(new Chrono());// petit programe qui tourne en fond qui repeind oklm
	chronoEcran.start();
	}
	
	
	
	
	
	public void paintComponent(Graphics g){
	super.paintComponent(g);
	Graphics g2 = (Graphics2D)g;
	g2.drawImage(imgFond, Xfond1, 0, null);
	
	
	for(int b=0 ;b<tabNour.size();b++){
		g2.drawImage(this.tabNour.get(b).getImgNouriture(), this.tabNour.get(b).getX(), this.tabNour.get(b).getY(), null);
	}}
	


	private int getTablPosNouriture1(int x,int y) {return this.tablPosNouriture[x][y];}


	public int[][] getTablPosNouriture() {
		return tablPosNouriture;
	}

	public void setTablPosNouriture(int[][] tablPosNouriture) {
		this.tablPosNouriture = tablPosNouriture;
	}
	
	
	
	//////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////ici je fait mes manips avec le tableau donc plus de problèmes///////////////
	
	public  int[] Scaner (int Xp,int Yp){
		
	int varX=0 ;
	int nomX =0 ;
	int varY=0 ;
	int nomY= 0  ;
	int Xproche=0;
	int Yproche=0;
    int comparaison ;
	//foncion qui va scaner le tableau tablPosNouriture pour rendre la position de la nouriture la plus proche 
	//enfin si jarrive a faire marcher les getters putin de merde
	for(int u= 0; u<200; u++){
		if(Xp-Math.abs(varX) > tablPosNouriture[1][u]){//varX prends la coordoné du X le plus proche de ceului qu'on lui a doner 
			varX= tablPosNouriture[1][u] ;
			nomX = u ;}
		if(Yp-Math.abs(varY) > tablPosNouriture[1][u]){//varY prends la coordoné du Y le plus proche de ceului qu'on lui a doner 
			varY= tablPosNouriture[1][u] ;
			nomY = u ;}	
		}
	//a la fin de la boucle on regarde lequel des deux est le plus pret :
	comparaison = varX-varY ;
	//si varX est plus proche 
	if (comparaison>0){
		System.out.println("nouriture la plus proche");

		//on renvoi les coordonées finalles de nomX
		System.out.println(tablPosNouriture[1][nomX]);
		System.out.println(tablPosNouriture[2][nomX]);
		 Xproche = tablPosNouriture[1][nomX];
		 Yproche = tablPosNouriture[2][nomX];
	}
	if (comparaison<=0){
		System.out.println("nouriture la plus proche");

		//on renvoi les coordonées finalles de nomX
		System.out.println(tablPosNouriture[1][nomY]);
		System.out.println(tablPosNouriture[2][nomY]);
		 Xproche = tablPosNouriture[1][nomY];
		 Yproche = tablPosNouriture[2][nomY];
	}
	
return new int[] {Xproche, Yproche};
// pour récup ca 
//  int result[] = Scaner();
//  System.out.println(Xproche[0] + Yproche[1]);
		}
	

mais il y a une problème dans l'autre classe maintenant :   

package personages;

import java.awt.Image;
import java.util.Objects;

import javax.swing.ImageIcon;

import objets.Objets;

public class Poisson extends Objets implements Runnable{

	private int PAUSE = 8 ;
	private Image imgPoisson;
	private ImageIcon icoPoisson;
	
	
	public Poisson(int xi, int yi) {
		super(xi, yi);
	    
		this.icoPoisson = new ImageIcon(getClass().getResource("/images/Poisson.png"));
		this.imgPoisson = this.icoPoisson.getImage();
		
		
	Thread chronoPoiss = new Thread(this);
	chronoPoiss.start();
	
	
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	
		
	}

	public Image imgPoisson() {return imgPoisson;}
	
	
	
	
	
	
	int varibletabl;
		
	
	private void scan(){
	int Nom ;
	int X ;
	int Y;



/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////la maniere que j utilise d'habitude ne marche pas 
///////////////////éclipse dit : "the méthode Scaner  is undefinied for the type Poisson :
	

int result[] = Scaner(2,5);
	
	
	
	
	
	
	
	
	
}}

en gros les gens si vous voulez 

renvoyer un tableau avec un getter : 

public int getTableau(int PosL, int PosC) { // avec L ligne et C colone 
		return Tableau[PosL][PosC];
	}

et pour avoir le tableau dans une autre classe :

LaclasseDeBase coucou = new LaclasseDeBase();
	int recherche= coucou.getTablPosNouriture(L,C); // a la place du L et du C metre les lignes et colone  

voila ce que j'en ai appris 

Ok c’était juste quelques " bouts de code" j'ai du mal m'exprimer j'en suis désolé.Mais c'est pas grave tu peux supprimer le post on m'a donner un solution sur un autre forum entre temps ... merci quand même !

en tous cas la couleur rend trop bien