[Harware] Bras robotique

Présentation du "Braccio", un bras robotique qui me fait de l’œil depuis quelques temps.

Braccio :

Equipé de 6 servomoteurs, il pourra être orienté dans toutes les positions/directions pour attraper/déposer des petits objets.

Cette base est livrée avec un bloc d'alimentation secteur 5 V / 5A ainsi qu'une platine shield au format arduino destinée à être pilotée par un bus TWI ou I2C™.

La platine shield est directement compatibles avec les bases Uno, Uno SMD, Uno WiFi, Due, Mega 2560, Ethernet, Leonardo, Leonardo ETH, Yun et Tian.

De part sa conception, il est possible d'assembler le bras robotique selon différentes possibilités. 

Pour ce qui est des caractéristiques du bras :

- Weight: 792 g

- Maximum operating distance range: 80 cm

- Maximum Height: 52 cm

- Base Width: 14 cm

- Gripper Width: 90 mm

- Cable length: 40 cm

- Load Capacity: Maximum weight at 32 cm operating distance: 150 g

  Maximum weight at the minimal Braccio configuration: 400g

La motorisation se base sur des servomoteurs :

- Control Signal: PWM Analog

- Torque: @ 4.8V: 169.5 oz-in (12.2 kg-cm)

@ 6.0V: 201.4 oz-in (14.5 kg-cm)

- Weight: 2.19 oz (62.0 g)

- Dimentions: 1.65×0.81×1.56 in (42.0×20.5×39.5 mm)

- Speed: @ 4.8V: 0.20 sec/60°

@ 6.0V: 0.18 sec/60°

- Rotation Support: Dual Bearings

- Gear Material: Metal

- Rotation Range: 180°

- Connector Type: J (aka Futaba) 

Vidéo d'assemblage :

Source

[Arduino] Communication série (V2.0)

Aujourd'hui je complique un peu les choses. Je me sers de mon ancien programme sur la communication série pour transmettre des valeurs entières (int).

Le plus réside dans le fait que je ne veux pas lire juste une seule données mais, plusieurs (je commence par deux). Dans l'idée, la première valeur contiendra l'information pour allumer une LED. Quant à la seconde valeur, elle pilotera un servomoteur.

J'en profite pour utiliser un tableau à 2 dimensions pour stocker ces 2 valeurs entières.

Exemple de code :

#include<servo.h>    //déclaration de la librairie pour utiliser le servomoteur

//Déclaration variables-paramètres

const int LED = 13;     //contiendra la pin où est attaché la LED
int index_val = 0;    //contient l'index du tableau d'entier
int val[2];    //contient le tableau de valeurs
Servo servo_1;    //déclaration du servomoteur

void setup()

{
    pinMode(LED, OUTPUT);     //initialise la pin (13) LED en sortie
    servo_1.attach(9);     //on connecte le signal de commande à la pin 9 (PWM)

    Serial.begin(9600);     //initialise la communication série à 9600bauds

}

void loop()

{

    index_val = 0;     //mise à jour de la valeur

 

    while(Serial.available() == 0)     //on attend des données

    {

         val[index_val] = Serial.parseInt();     //on convertit la chaîne en entier et l'affecte à "val[0]"

         index_val++;         //on incrémente l'index

         if(Serial.available() != 0)         //si des données sont encore présentes

        {

             val[index_val] = Serial.parseInt();     //on convertit la chaîne en entier et l'affecte à "val[1]"

             index_val++;     //on incrémente l'index (pas nécessaire)

        }

     //Tests

     if(val[0] == 10)

          digitalWrite(LED, HIGH);     //si la valeur vaut 10, on allume la LED

     else

          digitalWrite(LED, LOW);     //si la valeur est différente de 10, on éteint la LED

     servo_1.write(val[1]);     //déplace le servomoteur de la valeur indiquée

     //Affichage des valeurs sur le terminal

      Serial.println(val[0]);

      Serial.println(val[1]);

    }

     //fin du programme

}

[Arduino] Communication série et "Entier"

Aujourd'hui un tutoriel rapide sur l'envoie d'une variable de type "entier" sur le port série de l'Arduino.

En effet, il est facile de trouver sur internet des explications sur l'envoie de texte (Char) mais, dès que l'on parle d'une valeur entière, on tombe vite sur un os.

Sans plus attendre, le code ; rien de bien compliqué.

Exemple de code :

//Déclaration variables

const int LED = 13;
int val = 0;
void setup()

{
    pinMode(LED, OUTPUT);     //configure la pin 13 en sortie 

    Serial.begin(9600);     //initialise la communication série à 9600bauds

}

void loop()

{

    while(Serial.available() == 0)     //on boucle autant à l'infini

    {

        val = Serial.parseInt();     //on lit les données et les cast en "integer"
        Serial.println(val );     //affiche la valeur sur le moniteur
        if(val == 10)
             digitalWrite(LED, HIGH);     //si la valeur vaut 10, on allume la LED
        else
             digitalWrite(LED, LOW);     //si la valeur vaut 10, on éteint la LED

    }

    //fin du programme

}

[Tuto] Modélisation d'un bras robotisé

Un bras robotisé, ou plus couramment bras manipulateur, va avoir pour fonction de se rapprocher du bras humain ; cela dans le but de réaliser la même fonction pour une tâche donnée.

Dans cette optique, le bras manipulateur est conçu autour d'axes qui sont interconnectés via des articulations. On dénombre 2 grandes articulations : la glissière (translation unique suivant un axe) et la pivot (rotation unique suivant une axe).

Pour rappel : un objet dans l'espace est soumis à 6 "contraintes" ; 3 translations [Tx, Ty, Tz] et 3 rotations [Rx, Ry, Rz]. On dit qu'il possède 6 degrés de libertés (ddl).

Il existe des grandes familles de robots manipulateurs :
- Cartésien
- Scara
- Articulaire
- Parallèle
Chacune de ces familles présentent des spécificités propres. En fonction du besoin, le choix d'une technologie primera sur les autres.

Robot Scara détaillé

Approche de la modélisation :

Lorsque l'on désire travailler sur un robot manipulateur, la première étape consiste à décomposer le système physique dans une suite d'articulations et d'axes. Il est important de clairement identifier les axes de rotation des articulations et les longueurs des axes.
Cette étape est cruciale pour réaliser la modélisation (abordée, plus en détails, une prochaine fois).

Décomposition d'un robot manipulateur

[Arduino] Communication série

Le principe est simple, faire l'envoie d'une chaîne de caractère depuis un terminal vers notre carte Arduino.
Pour ce faire, deux instructions seront nécessaires :

• available() : permet de savoir si des données sont disponibles sur le bus, renvoie "-1" si vide
• read() : récupère le premier caractère disponible

On comprend aisément que la lecture des données se fera suivant une "FIFO" (First In First Out). Il faudra donc réaliser plusieurs lecture avant d'avoir notre information au complet.

Exemple de code :

//Déclaration variables

char char_lu = 0;     //contiendra le caractère lu
int nbre_char = 0;    //contient le nombre de caractère dans le buffer
void setup()

{

    Serial.begin(115200);     //initialise la communication série à 155200bauds

}

void loop()

{

    nbre_char = Serial.available();     //on relit le nombre de caractères disponbiles

 

    while(cardispo > 0)     //on boucle autant de fois que nécessaire pour tout lire

    {

        char_lu = Serial.read();     //on lit le caractère présent
        Serial.print(char_lu );     //le caractère est renvoyé sur le port série
        nbre_char = Serial.available();     //on relit le nombre de caractères disponbiles

    }

    //fin du programme

}