Jekert

Salut,

Es-ce que tu as déjà essayer d'afficher simplement du texte ?

J'avais écris ce programme pour un futur tuto (j'utilise cette bibliothèque: https://bitbucket.or...ystal_1.3.4.zip )

//Bibliothèques :
 #include "Wire.h"
 #include "LiquidCrystal_I2C.h"
//Ecran LCD :
 LiquidCrystal_I2C lcd(0x3F, 2, 1 , 0, 4, 5, 6, 7, 3, POSITIVE); //Seul le premier paramètre, l'adresse I2C de l'écran, est à modifier

void setup()
{
 //Initialisation :
 lcd.begin(16,2); //16 caractères par ligne sur 2 lignes
 lcd.backlight(); //Allume le rétro-éclairage, lcd.noBacklight() permet de l'éteindre
 lcd.print("Hello"); //Ecrit Hello
 lcd.setCursor(0,1); //Se place sur au premier caractère de la seconde ligne
 lcd.print("Robot-maker"); //Ecrit Robot-maker
}

void loop() {}

Salut !
J'ai commencé à faire des recherches pour construire/acheter une seconde imprimante 3D (moins encombrante que la Tarantula pour pouvoir l'avoir dans mon studio) dont voici les caractéristiques souhaitées :

• <130€ de matériel hors pièces imprimées en 3D
• Utiliser moins de 500g de filament pour la construction/amélioration (ce qui fait un budget tout compris de ~140€)
• Encombrement minimum
• Volume d'impression minimum: un cube de 12x12x12cm
• Imprimer du PLA

C'est qu'après avoir écris l'ensemble de ce message que j'ai remarqué que la Kodama Obsidian répondait à mes critères (imprimante à $99, plus $50 de livraison (TVA comprises) ce qui fait $149 soit ~130€). Il y a donc deux possibilités:

-Soit acheter une Obsidian:

Avantages: Plug & print (donc pas besoin de passer des heures de montages+configuration), compacte

Inconvénients: Risques liés à une campagne de financement(composants indisponibles, delais de plusieurs mois (initialement prévu en décembre-janvier), produit non commercialisé au final ou avec un coût supplémentaire), difficile à réparer soit-même en cas de problèmes, connexion en USB uniquement

-Soit construire une imprimante moi-même à partir de design pré-existant:

Avantages: Pouvoir choisir l'ensemble des caractéristiques/composants, facile à réparer/modifier,

Inconvénients: ne pas être certain d'arriver à la terminée (c'est ça mon gros frein pour le moment)

Que pensez vous de l'Obsidian ?

Es-ce trop difficile de construire soit-même (sans kit) son imprimante (je pensai partir sur une delta) ?

Quelques pistes si je construis mon imprimante :

Oui je trouve qu'ils fonctionnent bien, je viens d'imprimer le pont de 5cm qui sert à tester les fan duct et le résultat est plutôt satisfaisant

J'ai apporté une petite modification sur mon imprimante avec ce nouveau support pour les 2 ventilos et le capteur capacitif LJC18A3-HZ/BX 1-10mm (NPN 6-36V 300mA) pour l'auto bed leveling:

https://www.thingive...m/thing:2425395

Et j'ai arrêter d'utiliser des batons de colle qui laissent des résidus de colle sous la pièces et sur le lit pour les remplacer par de la laque avec laquelle je n'ai eu aucun problème pour le moment

Manque plus qu'une petite modification du firmware et c'est reparti !

Le bac est terminé !

J'en profite pour faire un petit récap de ce projet

Entre temps le robot a été renommé Wally.

Voici le résultat final :

Le robot est constitué d'un chassis en LEGO propulsé par 4 servo LEGO et pilotés par une Arduino avec un shield EVShield, les capteurs de distance (HCSR04) et d'inclinaison (MPU6050) sont connectés à une autre Arduino. Les deux communiquent avec 2 entrées/sorties digitales.

Sur le châssis on a mis un amortisseur de vibration fait à partir de freins de vélo et de 2 planches en bois.

Le stabilisateur est composé de 3 moteurs brushless montés sur des pièces imprimées en 3D. Ces moteurs sont commandés par une carte SimpleBcg 32bit qui communique avec l'application pour téléphone.

Une petite vidéo des différents tests :

L'orientation n'était pas encore totalement au point et malheureusement nous n'avons pas de vidéo embarquée, les fils d'un des moteurs se sont arrachés des bobines lors d'un déplacement (d'où les élastiques sur la photo). Mais le résultat est quand même satisfaisant

Quelques photos:

La gimbal:

Les cartes Arduino:

L'algorigramme du système de déplacement:

J'ai publié le programme sur le dépôt GitHub, normalement c'est la dernière version qui fonctionnait.

Quelques sites et logiciels utilisés :

- Google Drive : Partage et collaboration

- Freedcamp : organisation des tâches

- GitHub : Partage du code

- Dia : Algorigrammes

Encore merci à Oracid pour les chenilles n'hésite pas à me le dire si tu en a besoin, je n'ai pas prévu d'en réutiliser à court terme.

Approuvé ! ça devrait marcher maintenant

Ça y est ! Moi aussi

Pour mes 18 ans je me suis offert une Tevo Tarantula (option Large Bed) que j'ai reçu cette semaine (commandée le 29 mars sur Aliexpress, envoyée le 11 avril par UPS, reçue le 18 avril).

Donc comme Oliver17, le plateau est 200*280mm mais je n'ai pas pris l'option extrudeur métal ou autobed leveling (car je voulais imprimer sur une plaque en verre qui n'est pas détectée) et acheté des rondelles (M3, M4, M5), T-Nuts, des ferrules et des "wire connectors" pour compléter le kit.

Le montage m'a pris une après-midi+soirée et la correction des erreurs commises la matinée du lendemain...

Mais le colis est bien emballé est tout est très bien classé à l'intérieur :

Les problèmes/difficultés rencontrés dans l'ordre chronologique :

- Montage de l'extrudeur

- Alignement de la tige filetée de l'axe Z

- Remplacement de 2 endstops défectueux

- Les roulements de l'axe Z cognent les boulons qui soutiennent la carte mère (j'ai donc déporté la carte, ça fait bordélique mais c'est temporaire)

J'ai pour le moment fait deux essais avec Cura 2.1.2 comme Slicer:

C'est pas encore ça pour le moment, je ne me suis pas attardé sur les réglages souhaitant passer à Marlin. Mais j'ai espoir quand je vois ce qu'à publié un certain Jari Tulilahti sur le groupe Facebook (couches de 0.1mm) :

Prochaines étapes :

- Changement de firmware --> Marlin

- Ajout de 2 layer fan (Dual Blower model) + Renfort Axe Z + (Autobed level avec un microswitch)

- Créer une enceinte ("enclosure") pour l'imprimante avec des tables IKEA Lack

- ....

Coté communauté il y a de quoi faire :

- les vidéos de ArcadEd, Ruiraptoret certaines de D-Tech

- le groupe Facebook

- le site officiel et celui de la communauté

A bientôt !

A mon avis, il aura plus de volume de travail mais vu que la sphère sera surélevée, la "surface atteignable" (voir image avec les plans) sur la table sera réduite. donc tout dépends de ce que tu veux lui faire faire

Salut,

Je me permets de te répondre en attendant que quelqu'un de plus expérimenté vienne donner son avis

En fait, ça dépend de ce que tu entends par intelligence artificielle.

Je me suis intéressé un petit peu intéressé à ce sujet l'année dernière et en particulier à l'utilisation de l'algorithme Q-Learning qui est un algorithme d'apprentissage par renforcement (qui s'améliore par l'erreur et l'essai), j'avais trouvé quelques ressources que j'ai placé dans le sujet(mais je ne suis pas allé jusqu'au bout). Voici ce que j’essayai de faire :

Et quelques exemples supplémentaires :

Et je crois que Bobox utilise une Arduino et un algorithme génétique pour son Crabeel.

Si tu pensais plutôt à quelque chose comme JARVIS dans les MARVEL, certains ont essayé de le reproduire avec des Raspberry  ou PC:

- http://jasperproject.github.io/

-

Sinon je pense qu'en général l'Arduino n'est pas utilisée comme cerveau mais plutôt un micro-ordinateur (comme les Raspberry Pis) ou un PC/Serveur connecté à une Arduino qui gère la partie capteur + moteurs.

Si tu souhaite en savoir plus sur la programmation de différentes intelligences artificielles, je te recommande la chaine de Siraj Raval ou encore cette playlistde vidéos.

Oui, ça m'intéresse, merci !

D'ailleurs, as-tu rencontré des problèmes avec l'utilisation de 2 moteurs sur une même chenille ? (juste pour savoir au cas où 2 moteurs au total ne suffiraient pas)

J'ai un petit peu avancé sur le capteur de distance (un module à ultrasons HC-SR04), après avoir eu des problèmes avec mon "filtre" (le module s’arrêter pendant l'exécution du programme), j'ai finalement utilisé deux fonctions incluses dans la bibliothèque NewPing (ping_median et convert_cm):

#include <NewPing.h>

//Capteur à ultrasons :
#define TRIG 13   // Pin de déclenchement de la mesure
#define ECHO 12   // Pin de retour de la mesure
#define MAXD 30   // Distance maximale de détection en cm
#define DISTANCE_SECU 25 //Distance maximale en cm à laquelle le robot s'arrete d'un objet
NewPing sonar(TRIG, ECHO, MAXD); //Déclaration du capteur à ultrasons

#define LED 11

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  
  //Mesure et conversion :
  int timeD = millis();
  int med = sonar.ping_median(7); //On effectue 7 mesures, retire les valeurs hors de portée et retourne le temps median en us.
  int dist = sonar.convert_cm(med); // Converti le temps en distance en cm
  
  //Affichage :
  Serial.print("Distance: ");
  Serial.print(dist); Serial.print(" | Temps de mesure: ");
  Serial.println(millis() - timeD); //Affiche le temps de mesure
  
  //Réactions :
  if (dist <= DISTANCE_SECU && dist > 0)
  {
    digitalWrite(LED, HIGH); //Allume la led si un objet se trouve à moins de 25 cm du capteur
  }
  else
  {
    digitalWrite(LED, LOW);
  }
}

Le temps de mesure est d'environ 172ms (ce qui est bien mieux que mes 600ms avec le programme précédent quand ça fonctionnait...) et la mesure est précise à environ 1 à 2 cm près sans obtenir de valeurs improbables.

Puis je l'ai combiné au programme pour contrôler 1 Moteur pour vérifier qu'il était possible d'arrêter le robot avec une distance mesurée par le capteur :

// Bibliothèques :
#include <Wire.h>
#include <EVShield.h>
#include <NewPing.h>

EVShield evshield(0x34, 0x36); //Adresses i²c des deux 

//Capteur à ultrasons :
#define TRIG 13   // Pin de déclenchement de la mesure
#define ECHO 12   // Pin de retour de la mesure
#define MAXD 30   // Distance maximale de détection en cm
#define DISTANCE_SECU 25 //Distance en cm à laquelle le robot s'arrete d'un objet
NewPing sonar(TRIG, ECHO, MAXD); //Déclaration du capteur à ultrasons

void setup() {
  Serial.begin(9600);
  
  evshield.init( SH_HardwareI2C ); //Initialisation de l'EV Shield

  evshield.bank_a.motorReset();
  evshield.bank_b.motorReset();

  Serial.println("Appuyez sur le bouton GO pour commencer");
  evshield.waitForButtonPress(BTN_GO); //Attente de commande utilisateur

  evshield.ledSetRGB(200,100,100);
}

void loop() {
  
  //Mesure et conversion :
  int timeD = millis();
  int med = sonar.ping_median(7); //On effectue 7 mesures, retire les valeurs hors de portée et retourne le temps median en us.
  int dist = sonar.convert_cm(med); // Converti le temps en distance en cm
  
  //Affichage :
  Serial.print("Distance: ");
  Serial.print(dist); Serial.print(" | Temps de mesure: ");
  Serial.println(millis() - timeD); //Affiche le temps de mesure
  
  //Réactions :
  if (dist <= DISTANCE_SECU && dist > 0)
  {
   evshield.bank_a.motorStop(SH_Motor_Both, SH_Next_Action_Float);
  }
  else
  {
   evshield.bank_a.motorRunUnlimited(SH_Motor_1, SH_Direction_Forward, 100); 
  }
}

Je vais maintenant passer au capteur d'inclinaison du robot. Suite au prochain épisode

Salut à tous !

Je viens perturber la monarchie d'Oracid sur cette catégorie   avec la présentation de notre (nous sommes un groupe de 5) projet de terminale SI.

Donc l'objet de ce projet est de créer un robot stabilisateur de caméra pour la prise de vue au sol. On a donc séparer le projet en deux parties, le système de déplacement et celui de stabilisation.

Mon rôle dans ce projet est de choisir l'alimentation, programmer le système de déplacement et étudier les signaux de sortie des capteurs. Mais si vous avez des questions ou autres sur les autres parties du projet n'hésitez pas.

Pour la base mécanique du système de déplacement nous avons choisi d'utiliser des LEGO combiné à un EVShield (un Shield Arduino) pour le contrôle des 4 moteurs et des différents capteurs (de distance et d'inclinaison). La documentation du shield est disponible ici.

Nous avons jusqu'en avril pour finir nos tâches mais voici un aperçu du système de déplacement (qui nécessite encore quelques modifications) :

Après avoir choisi une batterie lipo, je suis passé à la programmation des éléments du robot à commencer par les moteurs :

Test d'un moteur sur la Bank A port M1 :

// Bibliothèques :
#include <Wire.h>
#include <EVShield.h>

EVShield evshield(0x34, 0x36); //Adresses i²c des deux cotés du shield.

void setup()
{
  Serial.begin(9600); //Communication Série pour debugging

  evshield.init( SH_HardwareI2C ); //Initialisation de l'EV Shield

  evshield.bank_a.motorReset();
  evshield.bank_b.motorReset();

  Serial.println("Appuyez sur le bouton GO pour commencer");
  evshield.waitForButtonPress(BTN_GO); //Attente de commande utilisateur

  evshield.ledSetRGB(200,100,100);
}

void loop()
{
  evshield.bank_a.motorRunUnlimited(SH_Motor_1, SH_Direction_Forward, 100); //Remplacer Forward par Reverse pour modifier le sens de rotation

  delay(1000);
  
  evshield.bank_a.motorStop(SH_Motor_Both, SH_Next_Action_Brake);

 Serial.println("Appuyez sur le bouton GO pour commencer");
 evshield.waitForButtonPress(BTN_GO); //Attente de commande utilisateur
}

Test avec 4 moteurs :

// Bibliothèques :
#include <Wire.h>
#include <EVShield.h>

EVShield evshield(0x34, 0x36); //Adresses i²c des deux cotés du shield.



void setup()
{
  Serial.begin(9600); //Communication Série pour debugging

  evshield.init( SH_HardwareI2C ); //Initialisation de l'EV Shield

  evshield.bank_a.motorReset();
  evshield.bank_b.motorReset();

  Serial.println("Appuyez sur le bouton GO pour commencer");
  evshield.waitForButtonPress(BTN_GO); //Attente de commande utilisateur

  evshield.ledSetRGB(200,100,100);
}

void loop()
{
 evshield.bank_a.motorRunUnlimited(SH_Motor_Both, SH_Direction_Reverse, 100); //Démarre les moteurs à 100%
 evshield.bank_b.motorRunUnlimited(SH_Motor_Both, SH_Direction_Forward, 100); //Démarre les moteurs à 100%

 delay(1000);

 evshield.bank_a.motorStop(SH_Motor_Both, SH_Next_Action_Float);
 evshield.bank_b.motorStop(SH_Motor_Both, SH_Next_Action_Float);

 Serial.println("Appuyez sur le bouton GO pour commencer");
 evshield.waitForButtonPress(BTN_GO); //Attente de commande utilisateur
}

L'ensemble des programmes que je posterai sur ce fil seront aussi disponible ici.

Au programme des prochaines séances : mise en place du capteur de distance et d'inclinaison.

Voilà tout pour le moment, j'essayerai de mettre à jour régulièrement ce fil

PS: J'ai hésité à placer ce sujet dans LEGO vu que tout les programmes seront en Arduino, mais je pense que ça peut tout de même donner une idée de ce que l'on peut faire avec l'EVShield

Hello les Makers !

Mike118 vous tease depuis plusieurs jours à propos du premier chapitre de l'ouvrage dédié à Arduino que nous avons écrit avec Jan, et c'est à moi que reviens le plaisir de vous annoncer la publication officielle de celui-ci !

Pour qui ?

Cet ouvrage a été écrit afin de permettre à une personne n'ayant jamais utilisé de cartes programmables de créer ses premiers programmes facilement donc que vous soyez totalement novice, curieux ou que vous souhaitez revoir les bases, ce premier chapitre est fait pour vous

Comment ?

Le principe que nous essayerons de respecter tout au long de l'ouvrage est d'apprendre par l'essai de programmes commentés et expliqués aux fils des pages ainsi qu'à l'aide d'exemples permettant de mélanger et utiliser ce que nous avons vu au cours du chapitre.

Donc l'ouvrage est disponible dès maintenant ici, parmi ceux déjà publiés par Nulentout.

Nous attendons avec impatience vos premiers retours donc n'hésitez pas à réagir ici ou dans les commentaires des pages de l'ouvrage !

Salut,

Dernier composant (électronique) du kit pour robot quadrupède, voici le fil du convertisseur 5V !

Donc celui contenu dans le kit ressemble à ceci :

Pour cette partie du test, je me suis fait un petit "banc d'essais" DIY ^^ pour contraindre tout les servos de la même manière...

... avec des élastiques et des trombones...

Jusqu'à 2 servomoteurs, le différence entre l'alimentation par Arduino et par le convertisseur est presque invisible :

Alimentation des servos par l'Arduino :

Alimentation des servos par le convertisseur 5V :

Mais à partir de 4 servomoteurs, elles sont nettement visibles :

Alimentation des servos par l'Arduino :

Alimentation des servos par le convertisseur 5V :

(Je verrais pour les mettre cote à cote dans une même vidéo si besoin plus tard)

Les élastiques n'exercent pas une force phénoménale sur les servos (<1kg je pense, je n'ai pas pu la mesurée pour l'instant). Mais le fait qu'un servo puisse consommer jusqu'à 250mA justifie que l'arduino n'arrive pas à alimenter les 4 servos du second test.

J'utilise une ancienne alim de PC pour alimenter le convertisseur câblé comme ceci :

Voilà tout pour le moment,

A bientôt !