Aller au contenu


bvking

Inscrit(e) (le) 29 janv. 2019
Déconnecté Dernière activité déc. 20 2021 11:49
-----

Sujets que j'ai initiés

Fixe une roue denté autour d'un axe moteur. Sur un nema 17

19 décembre 2021 - 06:41

Bonjour,

 

J'ai reçu une roue dentée dont le diamètre du trou intérieure mesure 3 mm.

Le site chinois s'est trompé dans les cotes, le trou devait faire 5 mm

Elle fait partie du kit pour mettre un réducteur sur un nema 17

Je dois la fixer à la sortie de mon moteur qui mesure 5 mm avec une partie qui est plate.

J'ai vu une solution pour fixer cette roue dentée sur mon axe qui m'a l'air bien compliqué.

 

https://www.webastro...-dessuie-glace/

 

En regardant la roue de profil, est ce que si je faisais un trou de 4 mm sur une moitié, puis sur l'autre moitié un autre trou de 5 mm et qu'avec le foret de 4 mm, je fasse une espece de cone pour avoir une cone allant de 4 à 5 mm, je pourrais forcer la roue denté à se fixer sur l'arbre moteur, en la martelant delicatement et en mettant de la colle à metal avant?

 

Aussi comment integer une zone plate au trou de la roue dentée qui coïnciderait avec la zone plate de l'arbre moteur? une lime à metal suffirait? 

 

 

Merci. Je suis assez pressé de trouver un solution pour voir si je peux faire tourner un truc moyen lourd à la vitesse que je veux, ensuite je dois aller dans une sorte de fab lab suivre vos conseils! 

 

Au final, je vendrai mes nema 17 et acheter directement ceux avec le réducteur.

 

 

 

 

 


Couplage moteur pas à pas NEMA 17. Quel bon réducteur choisir ?

03 décembre 2021 - 12:48

Bonjour,

 
J'ai fixé un poids de 15 g sur une barre en aluminium de 40 cm. Cette barre est fixée perpendiculairement à l'axe de mon moteur pas à pas Nema 17 et mon poids tourne très bien, avec de belles accelerations et à grande vitesse.
 
Le mien est le septième en partant du haut.
 
Couple de maintien (N.cm Min)

40

Couple de détente (N.cm Max)

2.2

J'aimerais rajouter un réducteur pour faire tourner une masse de 80 g ou, 120 g si possible, grâce à un réducteur, sans que mon NEMA17 décroche et en gardant son accélération (2.5 tours-2) et sa vitesse (2.5 tours.) Les deux derniers les paramètres étant gérés par un Teensy (Arduino avec une horloge beaucoup plus rapide), il ne devrait pas y avoir de problème pour multiplier par 5, si j'ai une réduction de 5:1.

Mon nema 17 fait 200 pas/tour, je gère mon moteur en 6400 pas/tour (soit 32*200 pour avoir moins de vibrations et plus de couplage). Mais peu importe.

Pensez-vous que ces réducteurs (voir en bas) sont facilement montables et feront l'affaire ? Quelle réduction choisir, pour passer d'une masse de 15g à 80 ou 120 grammes  ?

L'axe moteur de mon nema 17 est de 5 mm, j'aimerais pouvoir coupler un réducteur qui a aussi son axe moteur de 5 mm. Ou alors il faut que je trouve un moyen de réduire l'axe moteur du réducteur si besoin, mais je sais pas ce qui existe.

Merci pour votre attention et vos réponses !

 

https://fr.aliexpress.com/item/1005001652781953.html?src=google&src=google&memo1=freelisting&albch=apprmkt&albagn=182499396&albcp=1735154771&albag=73623194291&albad=338294380753&aff_short_key=irey5Th&isdl=y&aff_platform=true&albslr=%7B%7D&gclid=Cj0KCQiA-qGNBhD3ARIsAO_o7yn_kb7rFM47y_VJf1u-7r71EBpTwIctdKPNa6MzDJEeAkfFy8atkZAaAl4FEALw_wcB

 

https://fr.aliexpres...cB&gclsrc=aw.ds

 

J'ai vu sur ce site quelqu'un qui a fabriqué un réducteur avec une imprimante 3D. Vend il son systeme?

 

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


MatLab : programme de simulation neuronal

21 décembre 2020 - 09:01

Hello les garçons et les filles.

 

Je cherche simplement à faire tourner le programme d'un chercheur sur MatLab. Quand j'essaie y a des bugs, mais je pense simplement que j'utilise mal le logiciel.

C'est pour voir des ondes cérébrales comme on voit dans la pièce jointe.

 

Voila lien le pour accéder à tous les données de programmes et fonctions pour Matlab

Cortical Oscillator Network Simulations for MATLAB

 

Je n'ose pas demander au chercheur comment faire pour utiliser son propre programme dans MatLab,

car j'aurai des questions bien plus consistantes à lui demander à l'avenir.

 

Merci pour votre bienveilance.


Communication unilatérale Teensy - Arduino. Lire données (lettre+chiffre)

22 novembre 2020 - 02:47

Bonjour,

Je suis très pressé et j'ai un problème avec un por tUSB non reconnu par mon MacBOOK. Bien que le driver ait fonctionné.. Bref j'ai  une carte Teensy et une Arduino Due et je voudrais lire sur la RX1 de l'Arduino Due, les données que j'envoie sur le TX1 de la Teensy.

Voici le genre de données

Code: [Select]

A 151
B 60
C 0
D 150
E 150
F 150
G 149
H 149
I 149
J 148
K -934
L 19174
M 39283
N 59393
O 79503
P 99615
Q 119726
R 139839
S 159952
T 180066
U 79
V 77
W 18
X 40
Y 128
Z 121
a 112
b 102
c 97
d 7
e 0
f 0
g -100


Y ' a t'il un code simple pour lire ces données dans l'Arduino Due ? 

Je peux mettre des virgules entre chaque groupe de données si ça peut aider.

Par exemple c 97,d 7,e 0

Merci beaucoup


Communication Teensy & Processing. Différence avec l'Arduino Due

26 octobre 2020 - 09:36

Bonsoir, 

J'essaie d'adapter mon programme fait pour l'Arduino Due pour le faire fonctionner sur la teensy 3.6.

Mais quand j'utilise la Teensy, Processing saccade alors qu'il fonctionnait parfaitement avec l'Arduino Due.

Avec la Due, le port dans Processing apparait comme ça

[1] "/dev/cu.usbmodem14201"

Avec la Teensy, le port dans Processing apparait comme ça

[1] "/dev/cu.usbmodem72864401"

 

Dans le setup du logiciel Teensyduino, j'ai réglé la vitesse du port série sur 250000 car j'envoie à 250000 bauds aussi depuis Processing.

 

Mon animation saccade mais toutefois, la LED "buit-in" de la Teensy fonctionne comme prévue quand je démarre Processing.

 

J'ai donc mal programmé un truc quelque part. Je mets mon programme en bas. 

Aussi, je dois branché un module sur une liaison RX/TX de la Teensy et écrire sur cet autre port d'autres informations , comment  pourrais-je trouver un exemple simple pour m'en servir? Merci

 

Merci pleinement.

A bien+

 

#include "TeensyStep.h"

 
 
Stepper motor_1(1, 2);   //DIR pin = 1 , STEP pin =  2, 
Stepper motor_2(3, 4);    
Stepper motor_3(5, 6);   
Stepper motor_4(7, 8);    
Stepper motor_5(9, 10);   
Stepper motor_6(11, 12);   
 
StepControl controller;

int positionX, positionX1, positionX2, positionX3,positionX4,positionX5, positionX6, positionX7, positionX8, positionX9; 
 
//   Receive with start- and end-markers combined with parsing

const byte numChars = 200;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

      // variables to hold the parsed data
char messageFromPC[numChars] = {0}; //or {5} doesn't change anything

int integerFromPC0 = 0;
int integerFromPC1 = 0;
int integerFromPC2 = 0;
int integerFromPC3 = 0;
int integerFromPC4 = 0;
int integerFromPC5 = 0;
int integerFromPC6 = 0;
int integerFromPC7 = 0;
int integerFromPC8 = 0;
int integerFromPC9 = 0;

int PC0= 0;
int PC1= 0;
int PC2= 0;
int PC3= 0;
int PC4= 0;
int PC5= 0;
int PC6= 0;
int PC7= 0;
int PC8= 0;
int PC9= 0;

int PCTer0= 0;
int PCTer1= 0;
int PCTer2= 0;
int PCTer3= 0;
int PCTer4= 0;
int PCTer5= 0;
int PCTer6= 0;
int PCTer7= 0;
int PCTer8= 0;
int PCTer9= 0;

int LoworderTrigger =0;
int orderTrigger = 0;
int orderCohesion  = 0;


float floatFromPC = 0.0; // no flat are used for the moment

boolean newData = false;

//============
const int ledPin =  LED_BUILTIN;// the number of the LED pin

void setup()
{
    // set the digital pin as output:
  pinMode(ledPin, OUTPUT);
  Serial.begin (250000); // receive datas from Processing with the "Programming Port"
    
  //  SerialUSB.begin (250000); // print datas to send it into the other serial port of the Arduino Due, the "Native Usb Port" 

  //====Test if datas are printed into both serial of the Arduino Due
  /*  
      SerialUSB.print ("A "); SerialUSB.println (-4);     
      SerialUSB.print ("B "); SerialUSB.println (-3);        
      SerialUSB.print ("C "); SerialUSB.println (-2);  
      SerialUSB.print ("D "); SerialUSB.println (-1);
      SerialUSB.print ("E "); SerialUSB.println (-10);

      Serial.print ("A "); Serial.println (4);     
      Serial.print ("B "); Serial.println (3);        
      Serial.print ("C "); Serial.println (2);  
      Serial.print ("D "); Serial.println (1);
      Serial.print ("E "); Serial.println (10);
  */
  //====Initialise Pin Motor
  
  // setup the motors 
  
   motor_1
    .setMaxSpeed(3200)       // steps/s
    .setAcceleration(1600); // steps/s^2 
  
  motor_2
    .setMaxSpeed (3200)       // steps/s
    .setAcceleration(2000); // steps/s^2 
  motor_3
    //.setPullInSpeed(300)      // steps/s     currently deactivated...
    .setMaxSpeed( 3200)       // steps/s
    .setAcceleration(2400)   // steps/s^2     
    .setStepPinPolarity(LOW); // driver expects active low pulses
   motor_4
    //.setPullInSpeed(300)      // steps/s     currently deactivated...
    .setMaxSpeed( 3200)       // steps/s
    .setAcceleration(2800);   // steps/s^2   
   motor_5
    //.setPullInSpeed(300)      // steps/s     currently deactivated...
    .setMaxSpeed( 3200)       // steps/s
    .setAcceleration(3200);   // steps/s^2       
    
  }  
 

void loop() 

{
    recvWithStartEndMarkers();  // receive 33 datas from Processing 30 times/sec. 
   
    if (newData == true) {
        strcpy(tempChars, receivedChars);
            // this temporary copy is necessary to protect the original data
            //   because strtok() used in parseData() replaces the commas with \0
          digitalWrite(ledPin, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(100 );               // wait for a second
  digitalWrite(ledPin, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second            
        parseData(); //  split the 33 data into its parts  
        showPosition(); // These datas are used to control positions of 10 motors. Print them on the native port
        showPhazisScaled(); // Print datas on the native port
        showTrigBangWithRevolution(); // Print datas on the native port
       
        newData = false;
    }

  /*  
  constexpr int spr = 16*200;  // 3200 steps per revolution
  
  // lets shake    
  for(int i = 0; i < 5; i++)
  {
     motor_1.setTargetRel(spr/4); // 1/4 revolution
      motor_4.setTargetRel(spr/4); // 1/4 revolution
    controller.move(motor_1, motor_4 );  

    motor_1.setTargetRel(-spr/4);
     motor_5.setTargetRel(-spr/4);
    controller.move(motor_1, motor_5);  
  }
  delay(500);
  
  // move motor_1 to absolute position (10 revolutions from zero)
  // move motor_2 half a revolution forward  
  // both motors will arrive their target positions at the same time
   motor_2.setTargetAbs(10*spr);
   motor_2.setTargetRel(spr/2);
  controller.move(motor_1, motor_2);

  // now move motor_2 together with motor_3
   motor_1.setTargetRel(300);
   motor_2.setTargetRel(-800);
  controller.move(motor_2, motor_3);

  // move all motors back to their start positions
   motor_1.setTargetAbs(0);
 motor_2.setTargetAbs(0);
   motor_3.setTargetAbs(0);
  controller.move(motor_1, motor_2, motor_3);
 
  delay(1000);
  */
}

void recvWithStartEndMarkers() { // receive 33 datas from Processing 30 times/sec. They are marked like that in Processing <12, -98, 34,... ,-340>  
    static boolean recvInProgress = false;
    static byte ndx = 0;
    char startMarker = '<';
    char endMarker = '>';
    char rc;

    while (Serial.available() > 0 && newData == false) {
        rc = Serial.read();

        if (recvInProgress == true) {
            if (rc != endMarker) {
                receivedChars[ndx] = rc;
                ndx++;
                if (ndx >= numChars) {
                    ndx = numChars - 1;
                }
            }
            else {
                receivedChars[ndx] = '\0'; // terminate the string
                recvInProgress = false;
                ndx = 0;
                newData = true;
            }
        }

        else if (rc == startMarker) {
            recvInProgress = true;
        }
    }
}

//============

void parseData() {      // split the 33 data into its parts

    char * strtokIndx; // this is used by strtok() as an index

    strtokIndx = strtok(tempChars,",");      // get the first part - the string
 
    integerFromPC0 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC1 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC2 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC3 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC4 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC5 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC6 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC7 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC8 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    integerFromPC9 = atoi(strtokIndx);     // convert this part to an integer

    
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC0 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC1 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC2 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC3 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC4 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC5 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC6 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC7 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC8 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC9 = atoi(strtokIndx);     // convert this part to an integer

    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer0 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer1 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer2 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer3 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer4 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer5 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer6 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer7 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer8 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PCTer9 = atoi(strtokIndx);     // convert this part to an integer
    
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    LoworderTrigger = atoi(strtokIndx); // convert this part to an integer

    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    orderTrigger = atoi(strtokIndx); // convert this part to an integer
     
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    orderCohesion  = atoi(strtokIndx); // convert this part to an integer
 
}

//============
 
 
 

A