Keuronde

Le mode pas à pas (Mode 3)
 
Avis personnel : je n'aime pas les moteurs pas à pas. Cherchez pas, c'est comme ça...
 
Les servomoteurs Feetech offrent un mode "pas à pas". Ce mode se construit par dessus le mode 0 (enfin c'est comme ça que je le conçois). Les correcteurs en vitesse et en position sont utilisés.
 
Le mode pas à pas s'active ainsi :

sms_sts.writeByte(SERVO_ID, SMS_STS_MODE, 3);

Pour commander un mouvement, vous utilisez la même fonction qu'en mode 0 (mode servo) sauf que la consigne de position à une signification légèrement différente. En effet, plus qu'un mode pas à pas, il faut le voir un mode de déplacement relatif à la position actuelle.
 
Pour demande un déplacement d'un nombre de pas égal à pas_servo, à la vitesse vitesse, vous utiliserez cette fonction :

sms_sts.WritePosEx(SERVO_ID, pas_servo, vitesse);

La première surprise que vous risquez de rencontrer, c'est que les butées logicielles sont actives dans ce mode. Je n'ai pas essayé de voir ce qui se passait si leur valeur dépassait 4096. Bref, pour les désactiver, mettez la butée min et la butée max à 0 :

sms_sts.writeByte(SERVO_ID, 0x09, 0); // Butée min à 0
sms_sts.writeByte(SERVO_ID, 0x0A, 0); // Butée min à 0
sms_sts.writeByte(SERVO_ID, 0x0B, 0); // Buté max à 0, désactivation de la butée
sms_sts.writeByte(SERVO_ID, 0x0C, 0); // Buté max à 0, désactivation de la butée

La lecture de la position actuelle pourrait vous surprendre, en effet, le registre ne contient plus la position actuelle mais le nombre de pas codeur à parcourir pour finir le mouvement. Vous lire donc 0 tant que vous ne demandez pas de mouvement. Vous observerez un sut à la demande du mouvement qui réduit au fur et à mesure que le servomoteur se rapproche de sa position.
 
Voici un exemple avec une demande de déplacement de 2000 pas toutes les 2 secondes

 
Contrairement au mode servo, en mode pas à pas, comme la position revient systématiquement à zéro, vous n'avez pas de phénomène de rebouclage (enfin pas ici).
 
La limite se situe au niveau de la consigne qui doit tenir sur 16 bits (bit de signe inclus). Donc la commande maximale que vous pouvez envoyer pour un mouvement est de 32767 pas (soit 8 tours). Évidement, si vous demandez plus, vous observerez le phénomène de rebouclage.

 

Le mode basse résolution vous permet de faire passer cette limite à 21 tours, mais les cas où ceci est utile ne doivent pas être nombreux...

La commande que vous envoyée sera ajoutée à celle en cours. Donc si vous envoyez de nouvelles consignes avant que le mouvement soit terminé, vous risquez un dépassement, mais c'est vraiment un effet de bord qui ne devrait pas arriver sur une utilisation correcte du servomoteur :

Les différents modes

Moteur à courant continue (Mode 2)

Dans ce mode, vous définissez une tension à envoyer au moteur. Et le moteur tourne.
C'est une boucle ouverte simple. Le retour du codeur n'est pas utilisé par le servomoteur.

L'intérêt dans un projet me parait assez faible, vu les autres modes disponibles.

L'initialisation se fait ainsi :

sms_sts.writeByte(SERVO_ID, SMS_STS_MODE, 2); // SMS_STS_MODE vaut 0x21

La commande doit être comprise entre 1000 et -1000.

• Les bit 0 à 9 contiennent la valeur de la vitesse
• Le bit 10 son signe (0 anti-horaire, 1 horaire)

Voici le code pour l'utiliser :

// Construction de la commande
commande_moteur_tmp = commande_moteur;
neg = 0;
if(commande_moteur_tmp < 0){
  neg = 1;
  commande_moteur_tmp = -commande_moteur_tmp;
}

// Envoi de la commande
sms_sts.writeWord(SERVO_ID, 0x2C, commande_moteur_tmp | neg << 10);

Note: J'ai des soucis dès que la consigne dépasse les 500. Mais je ne vais pas creuser plus...

Moteur asservi en vitesse (Mode 1)

Dans ce mode, vous indiquez une consigne de vitesse (un nombre de pas par seconde) que le moteur doit atteindre. Le servomoteur dispose d'un correcteur PI que vous pouvez ajuster en fonction de votre application.

L'initialisation se fait ainsi :

sms_sts.writeByte(SERVO_ID, SMS_STS_MODE, 1); // SMS_STS_MODE vaut 0x21

ou

sms_sts.WheelMode(SERVO_ID);

L'envoi de la consigne se fait en écrivant les registres 0x2E et 0X2F.
Les 15 premiers bits contiennent la valeur absolue, le 16e le signe.

Soit vous utilisez votre fonction :

vitesse_tmp = vitesse;
neg = 0;
if(vitesse_tmp < 0){
  vitesse_tmp = -vitesse_tmp;
  neg = 1;
}
sms_sts.writeWord(SERVO_ID, 0x2E, vitesse_tmp | neg << 15);

 
Soit vous utilisez la fonction de la bibliothèque

sms_sts.WheelMode(SERVO_ID);

C'est, comme la fonction de la bibliothèque l'indique, le mode idéal pour piloter des roues. C'est aussi un mode intéressant pour travailler le réglage d'un asservissement.

Sur l'image ci-dessous, vous voyez la consigne et la vitesse réelle, ainsi que la commande moteur. Sur deux cycles, j'ai freiné - légèrement - le servomoteur. Vous observé que la commande monte en flèche et que la vitesse se stabilise tout près de la consigne malgré la perturbation.




Servo mode (0)

Nous nous rapprochons beaucoup du servomoteur classique avec une consigne de position.

Simple tour

Le principe est relativement simple, vous envoyer une position, et le servomoteur y va.

Avec la configuration par défaut, en faisant varier la consigne de position de -512 à 5120, nous observons des butées logicielles à 0 et à 4093. Notons aussi que la position renvoyée peut reboucler à 0 comme indiqué sur le graphique. Nous avons globalement le fonctionnement d'un servomoteur classique, sauf que nous avons le retour de position et que nous pouvons régler également la vitesse.



Multi-tour

Ces servomoteurs n'ont pas de butées mécaniques, et nous avons vu qu'ils pouvaient réaliser plusieurs tours.
En mettant à 0 la butée minimale (2 octets ) et la butée maximale (2 octets), nous pouvons activons le mode multi-tours. Ce mode sera particulièrement utile à tous ceux qui veulent entraîner des courroies, des vis à billes ou des mécanismes avec démultiplication. Ce mode présente deux inconvénients :

• Au bout d'un certain nombre de tour, le compteur reboucle. Sur le modèle que j'ai, je peux faire 8 tours dans chaque direction à partir du zéro. Si je dépasse cette limite, le servomoteur part en sens inverse et réalise les 16 tours.
• Si le servomoteur est dé-alimenté, il perd le nombre de tour qu'il a effectué et se réinitialise dans la plage du premier tour.

Par défaut, le servomoteur renvoie une position qui est toujours comprise dans le premier tour, entre 0 et 4096. Il y a un bit du registre Phase à modifier pour obtenir la position entre -8 et +8 tours. Mais activer ce bit ne réglera pas les deux inconvénients précédents.

Basse résolution

Il y a un paramètre qui permet de ne compter qu'un pas sur 2 ou un pas sur 3. Ceci dégrade la précision du codeur mais permet de multiplier par 3 (au max) la plage sur laquelle le servomoteur peut être contrôlé en position. Ceci n'a d'intérêt qu'en multi-tour. J'ai noté un comportement bizarre des butées logicielles et un écart x2 ou x3 entre la consigne et la position réelle.

Pour activer le mode basse résolution :

sms_sts.writeByte(SERVO_ID, 0x1E, 3);

Passer à 1 le bit 4 du registre "Phase" règle les comportements bizarre (au moins l'écart entre la consigne et la position réelle).
Attention, la valeur par défaut pourrait changer en fonction des modèles et version des servomoteurs.
 

sms_sts.writeByte(SERVO_ID, 0x12, 0x7C);    // Registre de "Phase", valeur par défaut 108 (0x6C)

Un schéma pour comprendre comment tout ça s’emboîte !

 

 

Un mot sur la bibliothèque Feetech

Le fabriquant fournis une bibliothèque qui permet d'accéder facilement aux fonctions des bases. Robot-Maker fourni une évolution de la bibliothèque un peu plus claire. Voici en vrac les points qui ont pu m'interroger ou qui mérite une précision...

La fonction Feedback

La fonction Feedback récupère les données d'état (accélération, vitesse, valeur PWM, Tension, température, erreur, indicateur de mouvement et courant consommé)  d'un servomoteur en une seule transaction de communication. par la suite, appeler les fonctions de lecture d'état (ReadSpeed, ReadPos, etc...) iront consulter ce tampon si l'identifiant passé en paramètre vaut -1. C'est ce qui est fait dans le code d'exemple, mais sans explications.

Les fonctions readByte et writeByte

Les fonctions readByte et writeByte permettent de lire et modifier les registres et vous permettent d'accéder à l'ensemble des fonctionnalités des servomoteurs. Les fonctions readWord et writeWord permettent d'écrire des valeurs de 16 bits sur deux registres consécutifs, en ne donnant que l'adresse du premier.

Avec ces fonctions vous pouvez recréer toute la bibliothèque et créer les fonctions qui vous manquent.

Les adresses des registres

Le fichier .h fourni quelques adresses de registre mais pas tous, loin de là. c'est dommage.

Le multi-tour

Le moyen d'activer le multi-tour n'est pas indiqué dans la bibliothèque. Les limitations du multi-tour ne sont détaillées nulle part, c'est dommage.

Si vous êtes arrivé jusqu'ici, vous avez :
- installé l'IDE
- installé la bibliothèque
- réalisé le câblage

Nous allons pouvoir nous pencher sur le fonctionnement détaillé de ces servomoteurs Feetech.

Ce qui suit est valable pour un type de servomoteur - ceux à potentiomètre.

Le protocole

Penchons nous un peu sur le protocole de communication.
Le protocole de communication est défini par Feetech, la documentation n'est pas simple, ni à trouver, ni à lire...
Pour la trouver, le lien direct est ici : https://www.feetechr...

Quand à la lire, voici les grandes lignes. Il y a deux types de trame, les instructions et les réponses. Une instructions est structurée ainsi :

• Entête : 2 octets (0xFF 0xFF)
• L'identifiant du servomoteur : 1 octet (1 à 255)
• La taille du message : 1 octect
• L'instruction (voir plus bas) : 1 octet
• Les paramètres de l'instruction : 1 ou plusieurs octets
• La somme de contrôle : 1 octet

La réponse du servomoteur est structurée ainsi :

• Entête : 2 octets (0xFF 0xFF)
• L'identifiant du servomoteur : 1 octet (1 à 255)
• La taille du message : 1 octet
• Le status du servomoteur : 1 octet (0 si OK)
• Les valeurs de la réponse : 1 ou plusieurs octets
• La somme de contrôle : 1 octet

Les instructions sont peu nombreuses :

• 0x01 : Ping
• 0x02 : Lire registre
• 0x03 : Écrire registre
• 0x04 : Écriture tamporisé
• 0x05 : Execute les instructions tamporisés
• 0x06 : Écriture synchronisée (pour envoyer la même instruction à plusieurs servomoteurs - aux identifiants consécutifs)
• 0x07 : Réinitialisation des paramètres d'usine

Voici la base du protocole. La bibliothèque est suffisamment bien faîte pour que nous n'ayons pas à rentrer dans les subtilités du protocole de communication. Pour comprendre la logique de fonctionnement des servomoteur Feetech, nous n'avons besoin de connaître que trois instructions : ping (que nous avons déjà utilisée sans le savoir), lire registre et écrire registre.

La tables des registres

C'est donc dans la fonction des registres que réside tous les secrets du servomoteur Feetech.

Feetech met encore une fois à disposition sur son site la documentation (https://www.feetechr...-agreement.html).
Mais encore une fois, c'est pas simple à trouver, et en chinois. Le document qui nous intéresse s'appelle "Servo Protocole Memory Table" (https://www.feetechr...)

La mémoire est découpée en 4 parties :

• EPROM en lecture seule. Elle contient quelques informations liés à la fabrication du servomoteur (Version logicielle et matérielle)
• EPROM en lecture-écriture. Elle contient des paramètres que ne devraient être modifiés que rarement (tel que l'identifiant du servomoteur ou la vitesse du protocole de communication). Cette mémoire est protégée, vous devrez modifier une valeur dans la partie suivante pour pouvoir la modifier.
• SRAM en lecture-écriture. Elle contient les valeurs qui seront modifiée couramment pendant l'utilisation normale du servomoteur (Position cible, vitesse)
• SRAM en lecture seule. Elle contient l'état actuel du servomoteur (position, vitesse, tension, température, erreur, courant)

EPROM en lecture seule

Adresse - Fonction

0x00 - Version logicielle (majeur)
0x01 - Version logicielle (mineur)
0x02 - Réserve
0x03 - Version matérielle (majeur)
0x04 - Version matérielle (mineur)

EPROM en lecture et écriture


Adresse - Fonction

0x05 - Identifiant, doit être unique sur le bus. L'identifiant 254 est réservé.
0x06 - Débit du protocole de communication, valeur de 0 à 7, respectivement 1000000, 500000, 250000, 128000, 115200, 76800, 57600 et 38400 bauds. Par défaut, 0 : 1 Mbauds.
0x07 - Délais de retour ou temps entre la réception de la commande et le début de la réponse, par pas de 2 µs. Par défaut : 250 (soit 500 µs).
0x08 - Réponse systématique. 0, ne répond qu'au demande de Ping et aux demandes de lectures. 1 répond à toutes les commandes.
0x09 - Butée minimale de l'angle. (2 octets - de 0 à 4094)
0x0B - Butée maximale de l'angle. (2 octets - de 0 à 4095)
0x0D - Limite de température maximale, 70° par défaut.
0x0E - Tension d'entrée maximale (en 0,1 V)
0x0F - Tension d'entrée minimale (en 0,1 V)
0x10 - Couple maximal, en pour-mille (0,1%), 2 octets de 0 à 1000
0x12 - Phase - la doc dit "fonction spéciale"
0x13 - Activation/désactivation des protections (surcharge, surchauffe, surintensité, plage de tension)
0x14 - Activation/désactivation des protections, visualisation par LED ??? - Comme si une LED pouvait s'allumer en cas d'erreur
0x15 - Coefficient P du correcteur de position
0x16 - Coefficient D du correcteur de position
0x17 - Coefficient I du correcteur de position
0x18 - Force de démarrage minimale (en 0,1% de la force maximale)
0x19 - Saturation du terme intégral du correcteur de position
0x1A - Zone "morte" dans le sens horaire (en nombre de pas codeur)
0x1B - Zone "morte" dans le sens anti-horaire (en nombre de pas codeur)
0x1C - Limite de courant (par pas de 6,5 mA - 2 octets). Valeur de 0 à 500, ce qui correspond à un courant maximal de 3,25 A
0x1E - Résolution angulaire (de 1 à 3) - un moyen d'obtenir du multitour au détriment de la précision angulaire. Attention, lire la doc !
0x1F - Offset de position - le bit 11 indique le signe de l'offset (2 octets)
0x21 - Mode de fonctionnement - 0 : Servomoteur, 1 : Vitesse constante, 2 : Vitesse régulée, 3 : mode pas à pas. Nous reviendrons plus tard sur ces différents modes.
0x22 - Couple de protection - couple fourni après que le servomoteur soit entré en protection à cause d'une surcharge du couple, en 1%.
0x23 - Temps pendant lequel la protection de couple reste active après s'être déclenchée - en 10 ms.
0x24 - Couple déclenchant la protection - en 1%
0x25 - Coefficient P du correcteur de vitesse
0x26 - Temps pendant lequel la protection contre les sur-intensités reste active en 10 ms.
0x27 - Coefficient I du correcteur de vitesse

SRAM en lecture et écriture

Adresse - Fonction

0x28 - Active ou désactive le couple (la commande) du servomoteur
0x29 - Consigne d'accélération, en 100 pas/s²
0x2A - Consigne de position, de -32766 à 32766, en pas
0x2C - Commande moteur (PWM de -1000 à 1000)
0x2E - Consigne de vitesse,  de -32766 à 32766, en pas/s
0x30 - Limite de couple. Valeur initialisée à celle indiquée au registre 0x10 au démarrage du servo. peut être ajustée ici.
0x31 à 0x36 - registres réservés (ne pas toucher)
0x37 - Protection de l'EPROM. à mettre à 0 pour modifier l'EPROM, à remettre à 1 juste après pour la re-protéger.

SRAM en lecture seule

Adresse - Fonction

0x38 - Position actuelle (2 octets)
0x3A - Vitesse actuelle (2 octets)
0x3C - Charge actuelle (2 octets)
0x3E - Tension actuelle
0x3F - Température actuelle
0x40 - État "écriture tamporisée"
0x41 - État du servo. 0 pas d'erreur, sinon voir la doc.
0x42 - Indicateur de mouvement. 1 : en mouvement, 0 : à l'arrêt
0x43 & 0x44 - Registres réservés (ne pas toucher)
0x45 - Courant consommé

 

Avec ceci vous une bonne idée des capacités des servomoteurs. Si une bonne bibliothèque doit vous donnez les fonctions adéquates, savoir comment marche le servomoteur est important pour bien l'utiliser. Et parfois, la bibliothèque est un peu "jeune" ...

 

Avec les deux fonctions ci-dessous, vous devriez pouvoir lister les registres de votre servomoteur :

int lire_registre(int servo_id, int registre_adresse){
  return sms_sts.readByte(servo_id, registre_adresse);
}

void lire_tous_les_registres(int servo_id){
  char message[200]="";
  for (int i=0; i<0x46; i++){
    sprintf(message, "registre 0x%x: %d\n", i, lire_registre(servo_id, i));
    Serial.print(message);
  }
}

Le prochain épisode sera consacré aux différents modes du servomoteur.

Alors, pourquoi "encore" une présentation ? Parce que EVRIS en a déjà faite une première ici. Qu'il y a un article de Marilux sur comment s'interfacer avec les Feetech.
 
Et que malgré ça, j'ai transpiré un peu pour me servir des Feetech. J'ai donc deux possibilités, vous présenter rapidement ce qui m'a posé soucis et ma solution ou repartir de zéro et faire une présentation en profondeur des Feetech. J'opte pour la seconde solution. Attendez-vous alors a certaines re-dites par rapport aux articles cités plus haut.
 
Note: Tous les essais réalisés lors de la rédaction de ces posts on été fait avec un Feetech STS3032, un TTLinker et un Raspberry Pi Pico.
 
Introduction

Les servomoteurs de modélisme

Les servomoteurs de modélisme sont des actionneurs assez intéressants car ils sont simples et sont commandés en position. Contrairement à un moteur à courant continu, où le moteur tourne dès que vous appliquez une tension, un servomoteur de modélisme va "attendre", en plus de l'alimentation, une consigne de position. C'est le servomoteur, qui en fonction de sa position et de la consigne envoyée, va commander son moteur pour atteindre la position demandée.

Pour les mettre en œuvre, le schéma est assez simple. Sur les trois broches, deux servent à l'alimentation et la troisième est directement reliée au signal du microcontrôleur. Contrairement à un moteur à courant continu, vous n'avez pas besoin de pont en H pour les piloter. Tout est intégré dans le servomoteur.

Les servomoteurs de modélisme présentent quelques limitations :
- Leur course est généralement limitée à 180°
- Il faut une broche de microcontrôleur par servomoteur. C'est peut-être un détail, mais ça peut empêcher de réutiliser une carte électronique d'une année sur l'autre.
- Difficile de piloter finement la vitesse du servomoteur
- Et surtout, le servomoteur ne renvoie pas d'information sur son état

Les servomoteurs Feetech

Les servomoteurs Feetech reprennent la base du servomoteur de modélisme, en comblant une grande partie de ses défauts.
- Leur course est réglable, et illimitée dans certains mode d'utilisation
- Ils sont chaînables, sur un port vous pouvez brancher tous vos servomoteurs
- Leur vitesse et leur accélération sont paramétrables
- Ils renvoient des informations détaillées sur leur état, position, vitesse, effort...
 
Ces servomoteurs existent en 2 gammes. L'une communique avec un protocole RS485, ce qui est certainement un inconvénient pour un petit projet. En effet, vous aurez besoin d'une carte d'adaptation car vous ne trouver pas (ou très difficilement) de microcontrôleurs qui intègrent le protocole RS485. L'avantage est que ce protocole, utilisant un signal différentiel, est résistant aux perturbations.
 
L'autre gamme utilise un signal TLL, en half duplex. Cela signifie que l'émission et la réception des données se fait sur la même broche. Si pour ce protocole, une grosse bidouille logicielle semble possible, le plus simple sera d'utiliser une carte de conversion.
 
Le fabriquant vend une carte de conversion UART <-> RS485 ou UART <-> TTL Half Duplex pour simplifier l'intégration de servomoteur de vos projets que vous trouverez chez Robot Maker. Nous utiliserons celle-ci :
https://www.robot-ma...er-mini-69.html

mais vous pouvez utiliser celle-là si vous souhaitez utiliser un ordinateur pour communiquer avec vos servomoteur : https://www.robot-ma...-urt-1-460.html
 
 
Première étape - S'installer

Câblage

Vous devez connecter sur la carte d'adaptation :

• L'alimentation de puissance (5V)
• L'alimentation logique (3,3V)
• Les signaux UART (RX/TX) sans les croiser

Installation de l'IDE

On va supposer que vous avez un IDE d'installé, que ce soit celui d'Arduino, VSCode + PlatformIO, ou autre.

Récupération de la bibliothèque

Robot Maker fourni une bibliothèque servomoteurs feetech qui offre les principales fonctions. Nous en aurons besoin dès le début car la bibliothèque permet de construire les trames.

Adaptation de la liaison série

Même avec Arduino, la configuration de la liaison série peut demander un peu de travail. En général, Serial.begin() démarre le port série qui communique avec votre ordinateur en USB. Serial1.begin() va ouvrir un autre port série de votre microcontrôleur. Savoir lequel est parfois compliqué :

• Pour les cartes officielles, la documentation est ici : https://docs.arduino...ication/serial/
• Sur un ESP32, vous devez également préciser les broches à utiliser : Serial1.begin(1000000, SERIAL_8N1, RX, TX); RX et TX étant les numéros des broches. Ce sont parfois des constantes définies par le fichier décrivant votre carte.
• Sur un RP2040 (Raspberry Pi Pico), PlatformIO ne laisse pas le choix, TX sera la broche 0, RX la broche 1.

Dans tous les cas, vous devez donnez le baudrate, qui est de 1000000 pour communiquer avec les Feetechs

Ping du servomoteur

Voici un programme qui teste la présence d'un servomoteur qui aurait l'adresse 1 (notez que c'est l'adresse par défaut).
Si ça marche, vous être prêt à passer à la suite !

#include <Arduino.h>

#include "SCServo.h"
SMS_STS sms_sts;


void setup() {
  // Configure la led en sortie
  pinMode(LED_BUILTIN, OUTPUT);


  // On ouvre 2 liaisons séries, 1 pour communiquer avec le PC, 1 pour les Feetech
  Serial.begin(115200);
  Serial1.begin(1000000);
  sms_sts.pSerial = &Serial1;
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
  test_ping();
  digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
  test_ping();
}

void test_ping()
{
  int ID = sms_sts.Ping(1);
  if(ID!=-1){
    Serial.print("Servo ID:");
    Serial.println(ID); 
    delay(100);
  }else{
    Serial.print("Ping servo ID error!\n");
    delay(2000);
  }
}

Alors, ce n'est que l'intro, dans les épisodes à venir, nous pourrions avoir :

• Le détail du protocole
• Les différents mode de gestions des Feetech (Servo, roue, multitours)

N'hésitez pas à faire part de vos remarques, critiques, propositions d'amélioration ici !

Bonjour à tous !

 

Je suis nouveau sur le forum, mais j'ai déjà quelques réalisation roboticiennes à mon actifs. Ce sont quasiment toutes des robots pour la coupe de France de Robotique.

Je participe à cette compétition avec l'équipe Poivron Robotique dont je suis l'un des deux membres permanents.

Pour donner une idée de mon âge, je dirais que ma première participation à la coupe de France de Robotique était en 2005.

 

Compétences

 

J'aime bien la programmation sur microcontrôleur, en C, après des expériences avec les PIC18F2550 / 4550, j'ai découvert le RP2040 de la fondation Raspberry Pi. C'est une bête que j'affectionne particulièrement. Sa fréquence élevée, le double cœur, les PIOs en font vraiment un bel outil. J'en suis encore plus convaincu depuis que j'ai testé les ESP32 dans un environnement Arduino ...

 

Je conçois mes cartes électroniques avec Kicad (et ça, c'est un bel outil aussi !), ce qui est électronique numérique ne me pose pas de soucis, mais je ne me frotte qu'avec prudence au reste (dès que le transistor n'est pas saturé).

 

Coté mécanique, j'ai les robots en bois. Je perce à la scie à colonne, je découpe des baguettes (8 - 10 mm) et depuis peu, je découpe à la scie à chantourner. Mais ça s'arrête là. Avant de construire, j'aime bien faire une modélisation en 3D avec FreeCad, que j'aime bien mais qui n'est pas encore au niveau de la référence du marché.

 

Philosophie

 

Je n'aime pas les empilements de technologie sans fin, d'où mon affection pour les microcontrôleurs.

Afin de partager ma passion, j'ai fondé - pas tout seul - un club robotique dans ma ville où nous animons des ateliers hebdomadaires (ou presque).

Je pense aussi que le vrai web est important et qu'il est nécessaire d'avoir du contenu en dehors de Facebook, X, Discord, et consorts... D'où ma venue ici

 

Ces jours-ci, je tâche de terminer un robot pour fin mai 2025 pour la coupe de France de Robotique. Je travaille notamment avec des servomoteurs Freetech.

 

À bientôt !