Bonjour, j'espère que cette video pourra t'aider (en particulier à partir de 10'43) : https://www.youtube....h?v=T5N1xO9EU8U

Salut les makers j'espère que vous passez de bonnes fêtes !

Dans le cadre d'un projet perso que je viens de ressortir du placard (j'espère le finir en 2021 !), je suis à la recherche d'une solution pour l'alimentation de l'ensemble du projet. Voici un petit topo :

- Il est question d'un petit robot mobile (autour des 2kg = estimation très grossière car tout est sur papier !)

- Motorisation 2xNema 17 + un petit moteur DC

- Je sais que les batteries LiPo ont la côte ces derniers temps mais j'aimerais éviter cette solution (du moins pour l'instant), car elles sont réputées dangereuses mais surtout car je ne souhaite pas être embêté par la surveillance de leur état de charge (je ne suis pas des plus assidus...).

Que me conseilleriez-vous ? Quand j'aurai assez de contenu et que je serai vraiment lancé (bientôt j'espère), je vous présenterai en quoi consiste mon premier véritable projet perso  !

Merci d'avance.

Bonjour les makers !

Dans le cadre d'un projet professionnel je suis amené en ce moment à travailler sur une board  STM32F429i -DISC1, c'est une carte accessible (environ 30€) qui a beaucoup d'avantages et qui permet de développer des interfaces graphiques de qualité grâce notamment à l'outil Touchgfx.

Malheureusement la documentation à son sujet reste assez restreinte (produit non connu chez les amateurs), c'est pourquoi je me demande si certains d'entre vous serez intéressées d'en apprendre un peu plus sur cette petite bête. Maintenant que j'ai un peu de recul dessus je pourrais faire un petit tutoriel sur son utilisation même si je ne suis pas encore un spécialiste. Ce serait un tutoriel écrit dans un premier temps et si j'ai le temps pourquoi pas une série de vidéos un jour.

N'hésitez pas à faire part de votre intérêt pour le sujet  et à bientôt j'espère !    

PS: Je fais cette démarche car je trouve dommage que ce produit ne soit pas plus connu des makers, ça demande un peu plus de connaissance que l'arduino mais ça reste abordable même pour des "non-cracks" de la programmation comme moi (ça se programme en C/C++).

Bonjour les makers !

J'ai enfin commencer à rédiger le tutoriel que je vous ai proposé il y a maintenant près de 3 mois, mieux vaut tard que jamais !

Je vous laisse le lien de celui-ci même si pour l'instant je ne suis qu'à la présentation du tuto : https://www.robot-ma...stm32-cube-ide/

Je vais essayer d'avancer un peu dessus dans les prochains jours mais en attendant vous pouvez dors et déjà effectuer quelques recherches autour du premier logiciel abordé dans le tuto : TouchGFX et sur les cartes de développment stm32 Nucleo de manière générale

Je pense vraiment de plus en plus à intégrer des vidéos dans ce tuto pour que ce soit plus complet au niveau de l'utilisation des logiciels mais je ne sais pas vers quelle solution logicielle me tourner pour les réaliser. Connaissez-vous une solution simple et gratuite pour cela ?

 

Genre Bandicam ?

Oui, on m'a parlé d'OBS aussi, je cherche le plus simple a utiliser ^^

Je ne comprends pas ce que tu dis. De quel logiciel parles-tu ?

Je recherche un logicielle capable d'enregistrer/filmer mon écran d'ordinateur pendant que reproduis une des étapes du tutoriel

En tout cas, un grand merci pour ton tutorial. Plus haut, tu parles d'une carte à 30€, as-tu un lien ?

Voici un lien Farnell de la carte que j'utilise personnellement, elle disponible chez de nombreux distributeurs : https://fr.farnell.c...GFR-GEN-SKU-MDC

Depuis le début, tu parles d'interface graphique, mais je ne comprends pas trop l'objectif de cet interface. Serait ce, par exemple, de visualiser la valeur d'un capteur sur le petit écran ?

L'interface graphique sera "bidirectionnelle" : des consignes pourront être envoyées depuis celle-ci mais elle pourra également recevoir des données de la partie hardware. Cela se traduit pas dans une sens par la commande de la LED par le bouton à bascule de l'interface et de l'autre sens par la commande de l'affichage d'une image depuis un bouton poussoir présent physiquement sur la carte de développement. Donc pour répondre à ta question, oui avec cette structure il sera possible de venir interroger un capteur quelconque et d'afficher les données qu'il renvoie directement sur l'écran de la carte de développement.

Merci Mike pour ton aide, finalement en mettant des résistances de Pull-up sur le Enable et le step le problème semble résolu, je me méfierai d'avantage de ces tutos qui sont réalisés dans des mondes parfaits    !

Je ne suis vraiment pas adepte des imprimantes à gros volumes car elles ont de serieux problèmes de fiabilité, si tu pars sur une solution comme la raise pro 3 plus (30x30x60 de mémoire) avec quelques assemblages tu arrives vite sur des volumes très conséquents. Je suis de l'avis de Sandro, lancer un impression de plusieurs jours est déjà risquée alors j'ose même pas imaginer sur plusieurs semaines avec une machine DIY.

Pour la question du plateau, pour avoir un planéité correcte et un tarif raisonnable je ne vois que le verre, pour améliorer l'accroche du peux essayer de trouver un revêtement style PEI à poser sur ton verre, chez Modix ils en vendent au format 660x660 (mm).

Bonjour les makers !

Alors voilà je travaille sur un projet avec des moteurs pas à pas type Nema17 que je commande via une carte arduino Uno et un driver A4988.

J'ai suivi ce tutoriel : https://www.makergui...duino-tutorial/ pour m'initier au pilotage de ce moteur avec le A4988 mais j'ai un mouvement parasite du moteur pendant la phase d'initialisation du programme est ce que quelqu'un à une idée de ce que ça peut-être ?

Merci d'avance pour votre aide !

Romaric.

Je n'ai travaillé que sur des imprimantes cartésiennes jusqu'à aujourd'hui, je pense qu'elles ont l'avantage d'être robustes et leur maintenance me paraît plus simple. Pour les types Delta en discutant avec certaines personnes j'ai cru comprendre que leur précision était meilleure que celle des imprimantes cartésiennes mais que leur mécanique était plus fragile (ce ne sont que des impressions que j'ai pu ressentir lors des différents échanges que j'ai pu avoir avec des utilisateurs de Delta, j'attends de voir si quelqu'un confirme ou non mes propos).

Je possède une Ender 3 et je ne suis vraiment pas déçu du rapport qualité prix et je confirme qu'on peut réaliser des pièces qui s'adaptent plutôt bien sur du Lego (il faut juste prendre le temps de trouver les bonnes côtes et les bons paramètres commme toujours avec l'impression 3D !)

Pour illustrer mon problème et le rendre un plus compréhensible j'ai pris le temps de filmer le phénomène observé ( à 15 sec dans la vidéo) :

https://www.youtube....eature=youtu.be

@Mike : mon programme fonctionne donc j'estime que le driver est bien connecté surtout que ça fait au moins 5 fois que je fais le montage pour trouver d'où peut venir le problème.

Je pense utiliser un transistor afin de bloquer le pin Enable du driver au niveau haut "au repos", je reviens vers vous pour vous indiquer si cette solution fonctionne ou non.
 

/*Programme de pilotage d'un moteur pap via arduino, 2 switchs et un driver A4998*/

/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
// Décalaration des variables
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
// PINS du moteur 1
#define enablePin1 8 // Activation du driver (0=> activé)
#define dirPin1 4 // sens de rotation du moteur (0=> sens horaire)
#define stepPin1 5 // commande de rotation

// PINS des boutons poussoirs
#define BP1 2 // bouton fin de course
#define BP2 3 // bouton poussoir jaune => haut


// Variables générales
#define stepsPerRevolution 400 // nombre de pas du moteur (ici un JK42HM48-1684 => copie NEMA17)
bool fin = false;
bool sens;
bool mvt = false;

/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
// Fonctions secondaires ou interruptions
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void fin_de_course () {
    // fin de course détecter on arrête le moteur
    fin = true;
}

void haut () {
    // appui sur le bouton poussoir de déplacement vers le haut, on arrête la rotation du moteur en relachant le bouton
    sens = true;
    mvt = !mvt;
}


/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
// Initialisation
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void setup() {
  // Déclaration des pins en tant que sortie:
  pinMode(enablePin1, OUTPUT);
  pinMode(stepPin1, OUTPUT);
  pinMode(dirPin1, OUTPUT);
  // Initialisation de l'état des différents pins
  digitalWrite(enablePin1, HIGH); // Drivers non-activé
  // Déclaration de la fonction d'interruption du capteur de fin de course
  attachInterrupt(0, fin_de_course, RISING);
  attachInterrupt(1, haut, CHANGE);
}


/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
// Programme principal : on pilote le moteur grâce aux différents boutons poussoirs
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void loop() {
    if (mvt == true && fin == false){
        digitalWrite(enablePin1,LOW);
        digitalWrite(dirPin1,sens);
        // On avance d'un pas (! attention au réglage de MS1,MS2 et MS3 !)
        digitalWrite(stepPin1, HIGH);
        delayMicroseconds(1000);
        digitalWrite(stepPin1, LOW);
        delayMicroseconds(1000);
    }
    else {
      digitalWrite(enablePin1,HIGH);
    } 
} 

Avec ce code je commande la mise en rotation du moteur par une pression sur un bouton poussoir, le moteur est à l'arrêt si le bouton poussoir n'est pas pressé ou si le capteur de fin de course est activé.

Non le mouvement et de l'ordre d'un huitième de tour (sur un 400 pas ça en fait 50 !), j'ai essayé de garder au niveau haut la broche Enable (de manière hardware) du driver lors de l'initialisation mais ça n'a rien changé et c'est ça qui m'intrigue le plus 

Edit : Quand je force de manière hardware le pin enable au niveau haut, il n'y a plus de mouvement parasite. Par contre même avec un code "vide" si je gère le pin enable de manière soft j'ai toujours ce mouvement initial non souhaité --' voici les quelques lignes utilisées :

#define dirPin 4
#define stepPin 5
#define stepsPerRevolution 400

void setup() {
  digitalWrite(8,HIGH);
  // Declare pins as output:
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
 
}

Je trouve ça étrange, le mouvement est au alentours des 60° avec ce programme "vide".

Ta question par rapport à la 2D c'est pour la course de l'axe  Z ou autre chose ? c'est vrai que les 71 mm sont un peu juste quand même 

Pour l’histoire du caisson pas de soucis on arrivera à bricoler un truc vu les dimensions de la machine.

J'ai déjà eu une petite expérience d'usinage d'alu je sais que ça coûte en temps et en argent, j'ai évoqué l'aluminium car pour le plastique on est équipé en imprimante 3D de toute sorte et je voulais mettre en avant le matériau le plus dur avec lequel on travaillera (d'autres matériaux plus tendres seront sûrement utilisés).

Pour l'aspiration et l'arrosage avec la 3D la fabrication d'adaptateurs me parait réalisable (on en voit un peu partout sur ce genre de machine).

On peut monter un peu en terme de budget, mais je ne crois pas qu'il existe des produits entre les machines hobbyistes à 2500 € et les pros à des dizaines de K€.

J'ai vu des machines BZT et High-Z moins connues du grand public car les tarifs sont plus conséquent, je ne sais pas si tu connais ? Je me demande juste si ça vaut vraiment le coup de passer sur des machines plus performantes mais avec d'autres contraintes (on perd le côté open-source notamment) pour l'utilisation que l'on projette d'en faire, c'est un vrai dilemme  . 

Un exemple d'utilisation de la High-Z sur de l'alu : https://www.youtube..../Fräsmaschinen

Pour trouver de l'occasion à part leboncoin est ce que tu connais des sites spécialisés ? j’imagine que c'est au petit bonheur la chance ^^

Bonjour amis usineurs ! Nous avons finalement opté pour une BZT (PFE 1000 PX)  , si je reviens vers vous c'est qu'en tant que parfaits novices en la matière nous aimerions nous faire la main sur différentes matières (PMMA, Dibond et bois pour commencer) afin de trouver les paramètres de coupes idéals. On a bien quelques modèles de fraises sous le coude mais comme on envisage clairement de les malmener avec notre ignorance d'apprentis usineurs, j'aimerais acheter quelques fraises supplémentaires avant de commencer les essais pour être sûr de pouvoir aller au bout des essais. Et c'est là que vous intervenez ! Avez-vous des petits tuyaux pour l'achat de fraise ? j'ai déjà perdu pas mal de temps sur les forums spécialisé où personne est d'accord sur où acheter ses outils d'usinage.

Je cherche le bon compromis entre le prix, la qualité et aussi rapidité de livraison, l'idée est d'avoir une fraise correcte avec laquelle je puisse réaliser mais essais sans avoir peur de la péter parce qu'elle coûte un bras !

Les fraises à ma disposition proviennent d'un fournisseur allemand sppw, sinon otelo revient assez souvent sur la table. Avez-vous des avis ou tuyaux sur le sujet ? MERCI    

Bonjour les makers ! 

Ma nouvelle mission est de trouver une CNC pour mon entreprise, on est dans l'impression 3D mais l'envie d'avoir une CNC nous démange depuis quelques temps  .  Je vous consulte aujourd'hui pour savoir si certains d'entre vous auraient quelques modèles à nous conseiller, voici quelques informations qui détaillent nos besoins :

1. Nous ne recherchons pas un modèle professionnel, c'est pour faire du prototypage voir de la très petite série, elle ne tournera pas tous les jours (loin de là) !

2. On souhaite pouvoir usiné de aluminium.

3. Surface de travaille supérieure à 600mm de côté.

4. Budget raisonnable pour une CNC type hobbyiste ++

J'ai déjà jeté un coup d’œil sur la très connue shapeoko XXL et l' AUREUS 3X pour laquelle j'ai une préférence, n'hésiter pas à me faire part de vos suggestion !

Je ne balance pas 7v mais plutôt 4.8V dans D2 ( 12V * 32 /(32+48) = 4.8V )

La coupure d'alimentation déclenche la fonction d'interruption loss_power liée à D2, et le condensateur sert à alimenter la carte le temps d'effectuer la routine d'interruption.

Je suis tombé sur un article (enfin j'ai beaucoup cherché après   ) qui je pense peut intéresser du monde au vue de la rareté des articles traitant de sa problématique : la sauvegarde de données sur l'EEPROM d'un arduino au moment où son alimentation est coupée (volontairement ou non). Alors si tu souhaites utiliser judicieusement la mémoire morte de ton Arduino  ce lien peut te permettre d'améliorer ou de concrétiser ton projet 

Je n'ai pas encore eu le temps d'essayer par moi même cette solution mais ça ne devrait pas tarder !

PS : Je ne sais pas où classer se sujet éléc/programmation si quelqu'un a une idée je suis preneur

Oulah la boulette ! merci pour la remarque 

http://riton-duino.blogspot.com/2019/03/arduino-sauvegarde-de-donnees-en-eeprom.html

J'ai testé cette solution dans le cadre d'une application basique est elle fonctionne parfaitement   .

Voici le petit montage que j'ai réalisé pour tester cette solution, j'ai fait en sorte que mon exemple soit encore plus simple que celui de l'article :

Et voici le programme arduino qui va avec : 

#include <EEPROM.h>
#include <rgb_lcd.h>

rgb_lcd ecranRGB;
int addr = 0;
int counter = 0;


void powerLoss()
{
  EEPROM.write(addr, counter);
}


void setup()
{
  attachInterrupt(digitalPinToInterrupt(2), powerLoss, FALLING);
  ecranRGB.begin(16,2, 0x00);
  ecranRGB.clear();
  ecranRGB.print("start");
  delay(1000);
  ecranRGB.clear();
  ecranRGB.print("data = ");
  delay(500);
  counter = EEPROM.read(addr);
  ecranRGB.print(counter);
  delay(1000);
}

void loop()
{
  ecranRGB.clear();
  counter += 1;
  ecranRGB.print(counter);
  delay(1000);
}

Procédure de test :

1. Réaliser le montage et brancher son alimentation 12V

2. Brancher votre carte arduino via USB et téléverser le programme

3. Débrancher l'USB

4. Vérifier que le compteur qui s'affiche sur l'écran fonctionne et couper l'alimentation 12V lorsque vous le souhaitez

5. Rebrancher l'alimentation, le compteur doit reprendre là où il se trouvait avant la coupure d'alimentation

J'espère que ça pourra aider certains d'entre nous, en tout cas pour moi ça change pas mal de choses 

Ça fait un petit moment que je suis ton projet et je voulais te féliciter pour ton travail, c'est juste impressionnant ! Reste déterminé ne lâche rien, je ne pense pas être le seul à vouloir voir ton projet se réaliser .

C'est super inspirant de voir des projets aussi importants se concrétiser !