Dans ce tutoriel, vous apprendrez à contrôler un moteur pas à pas avec le driver micro-pas TB6600 et un Arduino. Ce driver est facile à utiliser et peut piloter de gros moteurs pas à pas comme un 3 A NEMA 23.
J’ai inclus un schéma de câblage et 3 exemples de code. Dans le premier exemple, je vous montrerai comment utiliser ce driver de moteur pas à pas sans bibliothèque Arduino.
Cet exemple permet de faire tourner le moteur en continu. Dans le deuxième exemple, nous verrons comment contrôler la vitesse, le nombre de tours et le sens de rotation du moteur pas à pas.
Enfin, nous examinerons la AccelStepper bibliothèque. Cette bibliothèque est assez simple à utiliser et vous permet d’ajouter accélération et décélération au mouvement du moteur pas à pas.
Après chaque exemple, j’explique en détail le fonctionnement du code, vous ne devriez donc avoir aucun problème à le modifier selon vos besoins.
Fournitures
Composants matériels
| TB6600 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24/36 V) | × 1 | Amazon | |
| Jumper wires | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Outils
| Wire stripper | Amazon | ||
| Small screwdriver | Amazon | ||
| Self-adjusting crimping pliers (recommandé)* | Amazon | ||
| Wire ferrules assortment (recommandé)* | Amazon |
*Hackaday a écrit un excellent article sur les avantages d’utiliser des embouts de câble (aussi appelés manchons de terminaison).
Logiciels
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
À propos du driver
Le TB6600 driver micro-pas est basé sur le circuit intégré Toshiba TB6600HG et peut être utilisé pour piloter des moteurs pas à pas bipolaires à deux phases.
Avec un courant maximal continu de 3,5 A, le driver TB6600 peut contrôler des moteurs pas à pas assez puissants comme un NEMA 23. Assurez-vous de ne pas connecter de moteurs dont le courant nominal dépasse 3,5 A au driver.
Le driver intègre plusieurs fonctions de sécurité telles que la protection contre les surintensités, la coupure en cas de sous-tension et la protection contre la surchauffe.
Vous trouverez plus de spécifications dans le tableau ci-dessous. Notez que les spécifications exactes et les dimensions peuvent légèrement varier selon les fabricants. Consultez toujours la fiche technique de votre driver avant de le brancher.
Spécifications du TB6600
| Tension d’alimentation | 9 – 42 V |
| Courant de sortie max | 4,5 A par phase, 5,0 A en pointe1 |
| Résolution micro-pas | plein, 1/2, 1/4, 1/8 et 1/162 |
| Protection | Coupure basse tension, protection contre la surchauffe et les surintensités |
| Dimensions | 96 x 72 x 28/36 mm |
| Espacement des trous | 88, ⌀ 5 mm |
| Coût | Check price |
1 Ce sont les spécifications du circuit intégré TB6600HG, le driver lui-même a une limite de courant maximale de 3,5 A et 4,0 A en pointe.
2 Voir le commentaire sur les drivers TB6600 contrefaits ou améliorés ci-dessous.
Pour plus d’informations, vous pouvez consulter la fiche technique et le manuel ci-dessous :
Drivers TB6600 contrefaits ou « améliorés »
J’ai récemment démonté un driver TB6600 que j’avais commandé et découvert qu’il n’utilisait pas réellement un circuit TB6600HG. À la place, il utilisait un circuit beaucoup plus petit TB67S109AFTG, également fabriqué par Toshiba. Les performances et spécifications de ces puces sont similaires, mais le TB6600HG offre un courant de pointe plus élevé (jusqu’à 5 A) et c’est une puce beaucoup plus grande avec un meilleur refroidissement global.
Il existe un moyen très simple de vérifier si votre driver utilise un circuit TB6600HG ou TB67S109AFTG, le TB6600HG ne supporte que jusqu’à 1/16 micro-pas (voir fiche technique), tandis que le TB67S109AFTG va jusqu’à 1/32. La principale raison pour laquelle les fabricants ont changé de puce est probablement le prix. Vous trouverez ci-dessous des liens vers les puces sur LCSC.com qui montre que le TB67S109AFTG est environ 1,50 $ moins cher.
TB6600HG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB6600HG_TB6600HG_C66042.html
TB67S109AFTG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB67S109AFTG_TB67S109AFTG_C92125.html
Vous pouvez acheter des drivers TB6600 authentiques sur Amazon, comme celui-ci 4-axis driver board mais la plupart utilisent la puce TB67S109AFTG. Vous pouvez reconnaître un TB6600HG aux broches qui dépassent du PCB et il ne supporte que jusqu’à 1/16 micro-pas.
Jim de embeddedtronicsblog a testé les drivers TB67S109AFTG et a constaté que les moteurs pas à pas tournaient plus doucement qu’avec les drivers TB6600. Alors, faut-il choisir un TB6600 authentique ou la « mise à jour » ? Je dirais que cela dépend si vous avez vraiment besoin d’un courant élevé ou si vous préférez un micro-pas jusqu’à 1/32.
Vous trouverez la fiche technique du TB67S109AFTG ci-dessous.
Alternatives
Notez que le TB6600 est un driver analogique. Ces dernières années, des drivers numériques comme le DM556 ou le DM542 sont devenus beaucoup plus abordables. Les drivers numériques offrent généralement de meilleures performances et un fonctionnement plus silencieux. Ils peuvent être câblés et contrôlés de la même manière que le TB6600, ce qui permet une mise à niveau facile de votre système plus tard.
J’ai utilisé les drivers DM556 pour ma fraiseuse CNC DIY et ils fonctionnent très bien depuis plusieurs années.
TB6600 vs TB6560
En cherchant un driver TB6600, vous tomberez probablement aussi sur le driver légèrement moins cher TB6560 TB6560. Ce driver peut être contrôlé avec le même code et câblage, mais il présente quelques différences clés.
| TB6560 | TB6600 | |
|---|---|---|
| Tension d’alimentation | 10 – 35 VDC, 24 VDC recommandé | 9 – 42 VDC, 36 VDC recommandé |
| Courant de sortie max | 3 A par phase, 3,5 A en pointe | 3,5 A par phase, 4 A en pointe |
| # Réglages de courant | 14 | 8 |
| Résolution micro-pas | plein, 1/2, 1/8 et 1/16 | plein, 1/2, 1/4, 1/8, 1/16 et 1/32* |
| Fréquence d’horloge | 15 kHz | 200 kHz |
| Coût | Check price | Check price |
*Drivers utilisant la puce TB67S109AFTG.
Les principales différences sont donc la tension maximale plus élevée, le courant maximal plus important et le micro-pas jusqu’à 1/32. Le TB6600 dispose aussi d’un meilleur dissipateur thermique et d’un design global plus soigné. Si vous souhaitez piloter des moteurs plus puissants ou avoir une résolution plus fine, je recommande le TB6600.
Câblage – Connexion du TB6600 au moteur pas à pas et à l’Arduino
Brancher le driver TB6600 à un Arduino et un moteur pas à pas est assez simple. Le schéma de câblage ci-dessous montre les connexions nécessaires.
Dans ce tutoriel, nous connecterons le driver en configuration cathode commune. Cela signifie que nous relions toutes les parties négatives des signaux de commande à la masse.
Les connexions sont aussi indiquées dans le tableau ci-dessous :
Connexions TB6600
| TB6600 | Connexion |
|---|---|
| VCC | 9 – 42 VDC |
| GND | Masse alimentation |
| ENA- | Non connecté |
| ENA+ | Non connecté |
| DIR- | Masse Arduino |
| DIR+ | Broche 2 Arduino |
| PUL- | Masse Arduino |
| PUL+ | Broche 3 Arduino |
| A-, A+ | Bobine 1 moteur pas à pas |
| B-, B+ | Bobine 2 moteur pas à pas |
Notez que nous avons laissé les broches d’activation (ENA- et ENA+) déconnectées. Cela signifie que la broche d’activation est toujours à LOW et que le driver est toujours activé.
Comment déterminer le câblage correct du moteur pas à pas ?
Si vous ne trouvez pas la fiche technique de votre moteur pas à pas, il peut être difficile de savoir quel fil correspond à quoi. J’utilise l’astuce suivante pour identifier les moteurs bipolaires à 4 fils :
Il suffit d’identifier les deux paires de fils reliées aux deux bobines du moteur. Les fils d’une bobine se connectent à A- et A+, l’autre paire à B- et B+, la polarité n’a pas d’importance.
Pour trouver les deux fils d’une même bobine, procédez ainsi moteur déconnecté :
- Essayez de faire tourner l’axe du moteur à la main et notez la résistance.
- Choisissez une paire de fils au hasard et touchez les extrémités dénudées ensemble.
- Ensuite, en maintenant les extrémités en contact, essayez de faire tourner l’axe à nouveau.
Si vous ressentez une forte résistance, vous avez trouvé une paire de fils d’une même bobine. Si l’axe tourne librement, essayez une autre paire. Connectez ensuite les deux bobines aux broches indiquées dans le schéma ci-dessus.
Si ce n’est toujours pas clair, laissez un commentaire ci-dessous, plus d’infos sont aussi disponibles sur le RepRap.org wiki
Réglages micro-pas TB6600
Les moteurs pas à pas ont généralement un pas de 1,8° ou 200 pas par révolution, ce qui correspond aux pas complets. Un driver micro-pas comme le TB6600 permet d’obtenir des résolutions plus fines en autorisant des positions intermédiaires. Cela se fait en alimentant les bobines avec des niveaux de courant intermédiaires.
Par exemple, en mode demi-pas, un moteur de 200 pas par révolution aura 400 micro-pas par révolution.
Vous pouvez modifier les réglages micro-pas du TB6600 en activant ou désactivant les interrupteurs DIP sur le driver. Consultez le tableau ci-dessous pour les détails. Assurez-vous que le driver n’est pas sous tension lors du réglage des DIP !
Veuillez noter que ces réglages concernent les drivers 1/32 micro-pas avec la puce TB67S109AFTG. Presque tous les TB6600 vendus aujourd’hui utilisent cette puce. Vous trouverez généralement un tableau des réglages micro-pas et courant sur le boîtier du driver.
Tableau micro-pas
| S1 | S2 | S3 | Résolution micro-pas |
|---|---|---|---|
| ON | ON | ON | NC |
| ON | ON | OFF | Pas complet |
| ON | OFF | ON | Demi-pas |
| OFF | ON | ON | Demi-pas |
| ON | OFF | OFF | Quart de pas |
| OFF | ON | OFF | Huitième de pas |
| OFF | OFF | ON | Seizième de pas |
| OFF | OFF | OFF | Trente-deuxième de pas |
En général, un réglage micro-pas plus petit donne un fonctionnement plus fluide et silencieux. Cependant, cela limite la vitesse maximale que vous pouvez atteindre en contrôlant le driver avec un Arduino.
Réglages de courant TB6600
Vous pouvez ajuster le courant envoyé au moteur en fonctionnement en configurant les interrupteurs DIP S4, S5 et S6. Je recommande de commencer avec un courant de 1 A. Si votre moteur saute des pas ou cale, vous pouvez toujours augmenter le courant plus tard.
Tableau des courants
| Courant (A) | Courant de pointe | S4 | S5 | S6 |
|---|---|---|---|---|
| 0,5 | 0,7 | ON | ON | ON |
| 1,0 | 1,2 | ON | OFF | ON |
| 1,5 | 1,7 | ON | ON | OFF |
| 2,0 | 2,2 | ON | OFF | OFF |
| 2,5 | 2,7 | OFF | ON | ON |
| 2,8 | 2,9 | OFF | OFF | ON |
| 3,0 | 3,2 | OFF | ON | OFF |
| 3,5 | 4,0 | OFF | OFF | OFF |
Exemple de code basique TB6600 avec Arduino
Avec le sketch suivant, vous pouvez tester le fonctionnement du driver moteur pas à pas. Il fait simplement tourner le moteur à une vitesse fixe.
Vous pouvez téléverser le code sur votre Arduino avec l’IDE Arduino. Pour cet exemple, aucune bibliothèque n’est nécessaire.
Dans l’exemple suivant, nous verrons comment contrôler la vitesse, le nombre de tours et le sens de rotation du moteur.
Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: continuous rotation.
More info: https://www.makerguides.com */
// Define stepper motor connections:
#define dirPin 2
#define stepPin 3
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Comme vous le voyez, le code est très court et simple. Il ne faut pas grand-chose pour faire tourner un moteur pas à pas !
Explication du code
Le sketch commence par définir les broches step (PUL+) et direction (DIR+). Je les ai connectées aux broches 3 et 2 de l’Arduino.
L’instruction #define sert à nommer une constante. Le compilateur remplacera toutes les références à cette constante par la valeur définie lors de la compilation. Ainsi, partout où vous mentionnez dirPin, le compilateur le remplacera par la valeur 2 lors de la compilation.
// Define stepper motor connections: #define dirPin 2 #define stepPin 3
Dans la setup() partie du code, toutes les broches de contrôle du moteur sont déclarées en sortie digitale avec la fonction pinMode(pin, mode). Je définis aussi le sens de rotation du moteur en mettant la broche direction à HIGH avec la fonction digitalWrite(pin, value).
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
Dans la loop() partie du code, on fait exécuter un pas au driver en envoyant une impulsion sur la broche step. Comme le code dans la boucle est répété en continu, le moteur pas à pas commence à tourner à vitesse fixe.
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Dans l’exemple suivant, vous verrez comment modifier la vitesse du moteur.
2. Exemple de code pour contrôler rotation, vitesse et direction
Le sketch suivant contrôle la vitesse, le nombre de tours et le sens de rotation du moteur pas à pas.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: number of revolutions, speed and direction.
More info: https://www.makerguides.com */
// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 1600
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for (int i=0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 1 revolution quickly:
for (int i=0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
delay(1000);
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 5 revolutions fast:
for (int i=0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 5 revolutions fast:
for (int i=0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
}
Fonctionnement du code
En plus de définir les connexions du moteur pas à pas, j’ai aussi défini une constante stepsPerRevolution . Comme j’ai réglé le driver en mode 1/8 micro-pas, je l’ai mise à 1600 pas par révolution (pour un moteur standard de 200 pas par révolution). Modifiez cette valeur si votre configuration est différente.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 1600
La setup() partie est identique à avant, sauf que nous ne définissons pas encore le sens de rotation.
Dans la loop() partie du code, on fait tourner le moteur lentement d’un tour dans le sens horaire (CW) puis rapidement d’un tour dans le sens antihoraire (CCW). Ensuite, on fait tourner le moteur 5 tours dans chaque sens à grande vitesse. Comment contrôler la vitesse, le sens de rotation et le nombre de tours ?
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for(int i=0; i < stepsPerRevolution; i++)
{
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
Contrôler le sens de rotation
Pour contrôler le sens de rotation du moteur, on met la broche DIR (direction) à HIGH ou LOW avec la fonction digitalWrite(). Selon le câblage du moteur, mettre DIR à HIGH fera tourner le moteur dans un sens ou dans l’autre.
Contrôler le nombre de pas ou de tours
Dans ce sketch, la variable for loops contrôle le nombre de pas que le moteur effectuera. Le code dans la boucle for exécute 1 (micro)pas du moteur. Comme la boucle est répétée 1600 fois (stepsPerRevolution), cela fait 1 tour. Dans les deux dernières boucles, le code est exécuté 8000 fois, soit 8000 (micro)pas ou 5 tours.
Notez que vous pouvez modifier le second terme de la boucle for pour le nombre de pas souhaité. for(int i=0; i<800; i++) donnerait 800 pas ou un demi-tour.
Contrôler la vitesse
La vitesse du moteur est déterminée par la fréquence des impulsions envoyées à la broche STEP. Plus la fréquence est élevée, plus le moteur tourne vite. Vous pouvez modifier la fréquence en changeant delayMicroseconds() dans le code. Plus le délai est court, plus la fréquence est élevée, plus le moteur tourne vite.
Installation de la bibliothèque AccelStepper
La bibliothèque AccelStepper écrite par Mike McCauley est une excellente bibliothèque pour vos projets. Elle supporte l’accélération et la décélération, et offre beaucoup d’autres fonctions utiles.
Vous pouvez télécharger la dernière version de cette bibliothèque ici :
Vous pouvez installer la bibliothèque en allant dans Sketch > Include Library > Add .ZIP Library… dans l’IDE Arduino.
Une autre option est d’aller dans Tools > Manage Libraries… ou de taper Ctrl + Maj + I sous Windows. Le gestionnaire de bibliothèques s’ouvre et met à jour la liste des bibliothèques installées.
Vous pouvez chercher ‘accelstepper’ et choisir la bibliothèque de Mike McCauley. Sélectionnez la dernière version puis cliquez sur Installer.
3. Exemple de code AccelStepper
Avec ce sketch, vous pouvez ajouter accélération et décélération aux mouvements du moteur pas à pas, sans codage compliqué. Dans cet exemple, le moteur va aller et venir à une vitesse de 1000 pas par seconde avec une accélération de 500 pas par seconde².
Notez que j’utilise toujours le driver en mode 1/8 micro-pas. Si vous utilisez un autre réglage, ajustez la vitesse et l’accélération.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver,
AccelStepper library and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
// Include the AccelStepper library:
#include "AccelStepper.h"
// Define stepper motor connections and motor interface type.
// Motor interface type must be set to 1 when using a driver:
#define dirPin 2
#define stepPin 3
#define motorInterfaceType 1
// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
void loop() {
// Set the target position:
stepper.moveTo(8000);
// Run to target position with set speed and acceleration/deceleration:
stepper.runToPosition();
delay(1000);
// Move back to zero:
stepper.moveTo(0);
stepper.runToPosition();
delay(1000);
}
Explication du code
La première étape est d’inclure la bibliothèque avec #include <AccelStepper.h>.
// Include the AccelStepper library: #include "AccelStepper.h"
L’étape suivante est de définir les connexions TB6600 vers Arduino et le type d’interface moteur. Le type d’interface doit être 1 pour un driver step et direction. Vous pouvez trouver les autres types d’interface here.
// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver: #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1
Ensuite, créez une instance de la classe AccelStepper avec le type d’interface et les connexions appropriées.
Dans ce cas, j’ai appelé le moteur ‘stepper’ mais vous pouvez utiliser d’autres noms comme ‘z_motor’ ou ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. Le nom donné au moteur sera utilisé pour définir la vitesse, la position et l’accélération de ce moteur. Vous pouvez créer plusieurs instances de la classe AccelStepper avec des noms et broches différents. Cela permet de contrôler facilement 2 moteurs pas à pas ou plus en même temps.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
Dans setup(), en plus de la vitesse maximale, il faut définir l’accélération/décélération avec les fonctions setMaxSpeed() et setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
Dans la boucle, on fait tourner le moteur d’un nombre de pas prédéfini. La fonction stepper.moveTo() sert à définir la position cible (en pas). La fonction stepper.runToPostion() déplace le moteur (avec accélération/décélération) vers la position cible et bloque jusqu’à l’atteindre. Comme cette fonction bloque, ne l’utilisez pas si vous devez contrôler d’autres choses en même temps.
// Set the target position: stepper.moveTo(8000); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Si vous souhaitez voir plus d’exemples pour la bibliothèque AccelStepper, consultez mon tutoriel sur How to control a stepper motor with A4988 driver and Arduino.
Conclusion
Dans cet article, je vous ai montré comment contrôler un moteur pas à pas avec le driver TB6600 et un Arduino. J’espère que vous l’avez trouvé utile et instructif.
Si vous souhaitez en savoir plus sur d’autres drivers de moteurs pas à pas, les articles ci-dessous pourraient vous intéresser :
- TB6560 Stepper Motor Driver with Arduino Tutorial
- How to control a stepper motor with A4988 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- Control a Stepper Motor with an IR Remote
Nous avons aussi un article sur How To Use the TB6600 Stepper Motor Driver with ESP32 si vous voulez travailler avec un microcontrôleur ESP32 à la place.
Si vous avez des questions, n’hésitez pas à laisser un commentaire ci-dessous.
