Salut !

C'est drôle, j'étais dans une situation similaire à la tienne il y a 5 ou 6 ans

 

Comme l'a dit Path, il faut y aller pas à pas et je répète sa question:  Es-ce que tu as déjà utilisé Arduino ? Es-ce que tu as déjà programmé ?

 

Le concours se termine quand ? Es-ce que le concours est ta seule motivation ?

Ton histoire de glacière m'a fait penser à un projet que j'ai vu la semaine dernière: https://www.hackster...e-cooler-7ca8bc

Par contre il utilise le GPS, donc ça ne fonctionne pas en intérieur... mais il y a peut-etre des idées à garder de côté

Merci pour vos réponses

 

 

En nano computer ya aussi quelques cartes chez Olimex; du genre celle ci https://www.olimex.c...source-hardware (yen a d'autres sur le site) en version SoC complexe, et il en a une tripotée avec des cortex Mx qui sont certes moins puissantes bien sur mais peuvent être très intéressant pour de IOT.

Malheureusement, comparé à la CHIP, elle est plus chère et moins performante...

 

 

Si le format nano n'est pas complétement obligatoire ya aussi la pine64 qui semble prometteur...

J'ai failli dire "C'est préférable" sans regarder ce que c'était. Mais après avoir visité leur site, je pense qu'il a sa place dans cette liste (même si il est un peu plus grand comme tu l'as dis) Je vais l'ajouter:)

 

 

Après pour le choix, si la puissanc est le premier critère l'omega n'est pas dans le coup, par contre si tu veux faire un dispositif sans fil et très compact, l'omega est bien mieux que le pi 0. Concernant le Pi 0 d'ailleurs sauf si ça a changé la disponibilité (à l'achat) est vraiment faible.

Concernant CHIP je connais pas mais les specs a priori c'est la carte la plus puissante (en Cortex A8 soit ARMv7, contrairement au pi 0 en ARMv6 normalement) en revanche pour le Pi0 tout l'ecosystème est bien avancé, avec des drivers pour tout (a voir sur du cortex A8 si tout est "ouvert" comme sur le SoC Broadcom du Pi0)

 

C'est exactement pour ça que j'ai posé la question ici. Je savais que les 3 cartes avaient des dispo très faible (novembre 2016 pour l'omega et octobre 2016 pour la CHIP, ce qui ne me gêne pas trop n'ayant pas de projet en nécessitant pour le moment, mais après novembre ça commence à faire plutôt tard).

Pour le moment, la CHIP possède une documentation assez détaillée (quoi que quelques passages manquent) mais pas comparable à celle des raspberry.

 

 

Et encore mieux:

http://www.lattepanda.com/

Là tu as une arduino sur la carte

 

Super cette carte , elle ne rentre pas dans mon budget comme première carte d'apprentissage ( c'est pour ça que je cherchais des cartes à moins de 20€) mais je me garde la page de coté pour plus tard.

 

Salut,

 

J'utilise la Raspberry Pi version A+ et pi zero pour mes projets robotique.

La nouvelle version de Raspberry Pi A+ possède 512MB ram.

Tu utilise l'une comme télécommande et l'autre sur le robot ou les 2 sur le robot ?

 

@Oracid : Pour moi le rôle d'une tablette en IoT, robotique, domotique, etc est celui de client. Et dans ce rôle une tablette ou smartphone est super (on peut aussi se servir des fonctionnalités comme tu l'as dit: écran tactile, 2 caméras, la batterie..., et j'y ajouterais la reconnaissance vocale, gyro/accelero et GSM pour les smartphones) mais je ne suis pas sûr de lui trouver une utilité en tant que contrôleur.

Suite à vos messages je pensais me diriger vers la Pi zero mais j'en ai trouvé que sur adafuit et payer 26$ de frais de ports pour un produit à 5$ ne m'intéresse pas...

 

J'ai hésité ensuite entre la C.H.I.P. et la NanoPi mais cette dernière a encore des frais de ports énormes (20$ pour un produit à 13$), peut-être que c'est aussi l'habitude de commander en Asie qui me fait dire ça.

 

Donc je pense prendre une C.H.I.P. (si je ne trouve pas de pi zero à un prix+fdp plus raisonnable) avec une coque ça revient à 17$ frais de ports inclus. De plus j'ai trouvé un petit wiki qui permet de débuter correctement et leur forum est plutôt actif.

 

Merci pour vos réponses, je vais garder ce topic de coté pour d'éventuels futurs projets

Intéressant, merci pour le partage

Salut !

 

Aujourd'hui je suis tombé sur la campagne kickstarter d'Onion : Onion Omega2.

 

Ce genre de carte m'intéressent beaucoup et en faisant des recherches sur ce qui se fessait dans ce domaine je suis tombé sur différentes cartes : la Raspberry Pi Zéro et la C.H.I.P. de Next thing co. en particulier. Je souhaite en utiliser dans des projets tels qu'une PirateBox, contrôler une Arduino via USB/Bluetooth/Autres, et autres montages me permettant d'apprendre à utiliser ces cartes et leurs langages de programmation dans l'optique de créer des objets connectés.

 

Au vu du prix de ces cartes, je me demandais laquelle acheter en premier donc voici ce que j'ai retenu des différentes cartes classé en deux catégories selon le prix (en dessous et au dessus de 20€ carte + strict minimum hors frais de ports) :

 

Sous 20€:

 

Onion Omega2 Plus :

 

RAM: 128 Mb

CPU: 580 Mhz

Espace disque : 32Mb

Port(s) USB : Nécessite un dock non inclus (+10$)

Port(s) MicroSD : 1

WIFI: Sur la carte (802.11 b/g/n)

Bluetooth: Extension (Dongle BLE 4.0)

Sortie Vidéo : Commande par terminal ou interface web, Affichage OLED par extension

Prix de la carte : 9$

Avantages : Carte de base comprenant un slot microSD et le module wifi (avec possibilité d'ajouter une antenne)

Inconvénient : Nécessite extension et dock propriétaires coutant 15$ chacun (ce qui rend l'ensemble bien plus chère)

GPIO: 15 (dont 1 I²C, 1 I²S, 2 PWM, 2 UART, 1 SPI) Brochage à retrouver ici (susceptible d'être modifié)

Exemple de projets: (A ajouter, encore en pré-production)

 

 

Raspberry Pi Zéro :

 

RAM: 512 Mo

CPU: 1000 Mhz

Espace disque : Carte MicroSD

Port(s) USB : 1 micro USB OTG (On The Go) femelle

Port(s) MicroSD : 1

Wifi: Possible avec dongle supplémentaire

Bluetooth: Non inclus

Sortie Vidéo : Mini HDMI

Prix de la carte : 5$

GPIO: 40

Avantages : MiniHDMI inclus, connecteur caméra, communauté active

Inconvénients : Peu de modules compris sur la carte

Idéal pour : Traitement vidéo,

Exemple de projets:

 

C.H.I.P. by Next Thing co. :

 

RAM: 512 Mo

CPU: 1 Ghz

GPU: Mali 400

Espace disque : 4Gb

Port(s) USB : 1 microUSB et un type A femelles

Port(s) MicroSD : 0

Wifi : B/G/N

Bluetooth: 4.0

Sortie Vidéo : Connexion composite incluse et module supplémentaire pour VGA et HDMI

Prix de la carte : 9$

GPIO: http://docs.getchip.com/chip.html#pin-headers

Avantages : Beaucoup de possibilités sans modules supplémentaires, open source hardware

Inconvénients : Pas de ports microSD,

Exemple de projets: - https://chip.hackster.io/

- http://www.raspibo.org/wiki/index.php/ChiPirate-BOX:_the_chipest_and_cheapest_Pirate-BOX_ever

 

Olimex iMX233-OLinuXino-MICRO :

 

RAM: 64 Mo

CPU: iMX233 ARM926J processor at 454Mhz

Espace disque : Carte microSD

Port(s) USB : 1  type A femelles

Port(s) MicroSD : 0

Wifi : Non

Bluetooth: Non

Sortie Vidéo : Sortie video TV PAL/NTSC

Prix de la carte : 19€

GPIO: 2*30 pins

Avantages :

Inconvénients : Pas de wifi/bluetooth inclus

Exemple de projets:

 

Famille Pine A64 :

RAM: 512 Mo / 1Go / 2Go

CPU: 64bit Quad Core ARM A53 1.2GHz CPU

GPU: Dual Core Mali 400-MP2 GPU

Espace disque : Carte microSD (jusqu'à 256Gb)

Port(s) USB : 2 USB 2.0

Port(s) MicroSD : 1

Wifi : 800.11  B/G/N

Bluetooth: 4.0

Sortie Vidéo : HDMI (jusqu'à 4K)

Prix de la carte : 15 / 19 / 29$

GPIO: Pi+ Euler I/O Expansion Slots

Avantages :

Inconvénients :

Exemple de projets:

 

Famille NanoPi :

Entre 13 et 32$

 

Au dessus 20€ :

 

Familles iMX233 :

De 19 à 45€ selon la carte.

 

LattePanda :

RAM: 2 ou 4 Gb

CPU: intel quad-core 1.8Ghz

GPU: Intel HD Graphics, 12 EUs @200-500 Mhz

Espace disque : 32 ou 64 Gb

Port(s) USB : 1 USB 3.0 et 2 USB 2.0

Port(s) MicroSD : 1

Wifi : Oui

Bluetooth: 4.0

Sortie Vidéo : HDMI et MIPI-DSI

Prix de la carte : 79 ou 139$

GPIO: 6pins Cherry Tail processeur, 20 pins Arduino Leonardo et 6 connecteur plug and play capteur.

Avantages : En plus des caractéristiques citées: Port Ethernet, sortie Audio jack, touch connector

Inconvénients : le prix pour les petites bourses, et une forte consommation de courant (5V, 2A)

Exemple de projets:

 

Raspberry Pi 3 Model B :

RAM: 1Gb

CPU: 1.2GHz 64-bit quad-core ARMv8 CPU

Espace disque : Carte microSD

Port(s) USB : 4

Port(s) MicroSD : 1

Wifi : 802.11n Wireless LAN

Bluetooth: 4.1 et BLE

Sortie Vidéo : HDMI

Prix de la carte : 45€

GPIO: 40

Avantages :  Port Ethernet, jack and composite video, CSI, DSI et VideoCore IV 3D graphics core

Inconvénients : Carte assez grande

Exemple de projets:

 

Intel Compute Stick :

RAM: 2Gb

CPU: Intel Atom Z3735F (Quad-Core 1.33 GHz - Cache 2 Mo)

GPU:  Intel HD Graphics

Espace disque : 32 Gb

Port(s) USB : 1 USB 3.0 et 2 USB 2.0

Port(s) MicroSD : 1

Wifi : Oui

Bluetooth: 4.0

Sortie Vidéo : HDMI

Prix de la carte : 159€

GPIO: 0

Avantages : Connectivité, RAM

Inconvénients : Pas de GPIO, plus cher, alimentation par HDMI ?

Exemple de projets:

 

Famille des Odroid (XU4, C1+, C2):

 

 

Famille Nvidia Jetson :

 

Asus Tinker Board

 

 

 

RAM : 2GB Dual Channel DDR3

CPU : Rockchip Quad-Core RK3288 processor

GPU : Integrated Graphics Processor ARM® Mali™-T764 GPU (The ARM® Quad-Core Mali GPU supports max. resolution of 4K@30hz (up-scaled from 1080P) with H.264/H.265 hardware decoder (update coming soon).)

Port(s) USB : 4 x USB 2.0

Port(s) MicroSD : 1 x  Micro SD(TF) card slot

Wifi : 802.11 b/g/n, Bluetooth V4.0 + EDR

Lan : RTL GB LAN

Audio : RTL ALC4040 CODEC

Bluetooth : -

Sortie Vidéo : HDMI et MIPI-DSI 

GPIO : 

1 x 40-pin header :

- up to 28 x GPIO pins
- up to 2 x SPI bus
- up to 2 x I2C bus
- up to 4 x UART
- up to 2 x PWM
- up to 1 x PCM/I2S
- 2 x 5V power pins
- 2 x 3.3V power pins
- 8 x ground pins
1 x 2-pin contact pin :
- 1 x PWM
- 1 x S/PDIF
1 x 15-pin MIPI DSI
1 x 15-pin MIPI CSI

 

Poids : 55 gr

Consommation : 5v/2A

Avantages : -

Inconvénients : Le 24 Janvier 2017 ; La Tinker Board se présente donc comme une version musclée du Raspberry Pi et pourrait éventuellement être transformée en lecteur multimédia low-cost. Mais pour réussir, Asus aura besoin du soutien d’une communauté – qui est à l’origine du succès du Raspberry Pi – et surtout d’un véritable OS dédié. C’est pour l’instant le point faible de la carte : elle n’est actuellement compatible qu’avec des distributions Linux (Debian, par exemple) et Android. Asus attend désormais que des développeurs amateurs s’emparent de sa carte et lui confère un véritable potentiel.

Fabricant : https://www.asus.com...r/TINKER-BOARD/

Prix : 53,10 euros ~

Exemple de projets : - 

 

http://www.journaldugeek.com/2017/01/24/tinker-board-asus-devoile-un-concurrent-muscle-du-raspberry-pi/

 

 

Pour le moment j'hésite entre la Omega2 et la CHIP malgré le fait que l'Omega nécessite des extensions et soit moins puissante, elle me parait plus simple à utiliser pour quelqu'un n'ayant fait que de l'Arduino pour l'instant.

 

Et vous, que pensez vous de ces cartes ? Connaissez-vous en d'autres du même type pour un prix comparable ?

 

PS: Je viendrais compléter les infos ci-dessus au fur et à mesure de mes recherches mais n'hésitez pas à ajouter des informations ci-dessous

J'ai reçu la C.H.I.P. aujourd'hui (enfin) !

J'essayerais de vous faire un retour une fois prise en main

Encore merci pour vos réponses

 

Pour le raspberry 0, tu peux quand même lui rajouter du wifi grâce a un dongle wifi et grâce a un câble dans ce style(http://www.cablemati...CFUwYGwodTuELFw).

Il y a aussi des cables micro usb -> ethernet, ...

 

Avec ce petit module et une vielle télé on peut aussi faire ça :

Ajouté, je l'avais oublié, mais pour des petits projets, le câble risque de prendre beaucoup de place dans un boitier

Sympa la vidéo

 

 

Dans ce style de carte il y a aussi l'arduino mini (pour 4 € chez miniinthebox), que tu pourrais mettre en esclave avec un raspberry ...

Pour les esclaves j'ai déjà des Arduinos Nano qui sont suffisamment petite et puissante pour faire le job.

 

ppffffuu va falloir que je me trouve un autre ordi pour faire tourner fusion :'(

Pas forcément, j'ai trouvé la configuration requise pour Fusion 360, et elle n'est pas si élevée que ça pour un logiciel de modélisation (comparé à Solidworks qui demande 8Go de RAM...).

 

 

Fusion, c'est un outil très complexe que l'on peut comparer à Blender, je pense, et malheureusement pas gratuit.

Si tu cherches plus simple et du même éditeur, il y a ThinkerCAD comme indiqué sur ton lien (d'ailleurs je ne vois pas vraiment la différence avec 123D design, à part le fait qu'il se lance dans le navigateur).

Et si j'ai bien compris ce qui est dit sur leur site, seules les entreprises gagnant plus $100 000 par an ont besoin de payer une licence Fusion 360 :

J'ai déjà écrit une page à propos de l'appareillage de 2 modules HC05 mais je ne l'ai pas encore publiée, donc je te retranscris ici les actions que j'avais fais pour le maitre (il me parait logique que la télécommande soit en mode esclave) :
Première étape essaie de trouver l'adresse avec le téléphone (si il n'apparait pas dans le menu bluetooth, tu peux utiliser l'appli Arduino BlueControl qui affiche les adresses avec les noms).
 
Téléverse ce programme sur une arduino et connecte le module BT comme décrit dans le programme. Et quand tu remets le tout sous tension reste appuyer sur le bouton du module, une fois relâché il devrait clignoter lentement (période de 2secondes environ)
 

#include <SoftwareSerial.h>

SoftwareSerial HC05(10, 11); // TXmodule->10, RXmodule (après pont diviseur de tension ou non)-> 11
                             // Key -> VCC
void setup()
{
  //Liaison série :
  Serial.begin(9600);
  Serial.println("Pret a recevoir vos commandes");
  HC05.begin(38400);  // Vitesse par défaut en mode AT du module bluetooth
}

void loop()
{
  // Communication HC05 -> Moniteur Série
  if (HC05.available())
    {
      Serial.write(HC05.read());
    }

  // Communication Moniteur Série -> HC05
  if(Serial.available())
  {
      HC05.write(Serial.read());
  }
}

Puis ouvre l'interface Série et choisi ce paramètre :

 

Si quand tu envoie AT dans l'interface Série et qu'il te renvoie OK, c'est que tu peux modifier les paramètres.

Et ensuite j'ai entré les commandes suivantes (sans les commentaires ^^) :

• AT+RMAAD //Pour vider la liste des appareils appairé.
• AT+ROLE=1 //Role = maitre
• AT+NAME=HC05M //Renomme le module (facultatif)
• AT+CMODE=0 //Active connexion auto
• AT+BIND=2016,2,307468 //Adresse à laquelle se connecter (je pense qu'il faut garder le même format)
• AT+UART=38400,0,0 //38400 étant le baudrate choisi (doit être le même que celui de la télécommande)

Et normalement tu devrais pouvoir connecter ton module à la télécommande après l'avoir redémarrer.

Voilà, j'espère que ça pourra t'aider

Salut,

Tu utilises un module HC05 ou tu es passé au HC12 ?

Salut,

Es-ce que tu connais "Grant Thompson - "The King of Random"", il a une chaine youtube en anglais où il a fait une série de vidéos sur comment construire et lancer des micro-fusées. La playlist de vidéo se trouve ici :

https://www.youtube...._u09uQ_DSZZ5CRh

Tu pourrais t'en inspirer pour créer tes propres fusées

Merci pour tes précisions , après quelques tests sur un des servos, les valeurs MIN et MAX que j'ai trouvé sont : 450 et 1000, il faudra que je les vérifies sur plusieurs autres.

//Bibliothèque :
#include <Servo.h> //Ajoute la librairie Servo

//servo1 :
Servo servo1;    //Déclare un nouveau servomoteur nommé servo1
int pos = 0;     //Position initiale du servo
#define PAUSE 20 //Symbolise la pause en ms entre chaque mouvements du servo
#define MIN  450 // Position 0° en microseconde 
#define MAX  1000 // Position 180° en microseconde

void setup() {
  servo1.attach(9, MIN , MAX); //Attache servo1 au pin 9 avec MIN et MAX les extrêmes en microsecondes 
}

void loop() {

  for (pos = 0; pos <= 180; pos++)
  //Rejoins un angle de 180° depuis 0° par pas de 1°
  {
    servo1.write(pos);
    delay(PAUSE);
  }
 delay(1000);
  for (pos = 180; pos >= 0; pos--)
  //Rejoins un angle de 0° depuis 180° par pas de 1°
  {
    servo1.write(pos);
    delay(PAUSE);
  }
 delay(1000);
}

Voici le SG90 de chez Tower Pro.

Prix Robot-maker : 3.60 € 

 

http://www.robot-maker.com/shop/moteurs-et-actionneurs/18-servomoteur-9g.html

 

Spécifications : 

 

Zone morte : -
Maximum pulse largeur : -
Maximum angle : 180°
Moteur : -
Plage de tension: 4.8 - 6.0 V
Vitesse : 4.8 V - 0.12 sec/60°
Couple : 4.8 V - 1.6 kg.cm
Taille : 24x13x29mm (Micro)
Poids : 9gr
Câble : JR 265mm
Roulement : -
Sortie dents : -

 

Avis perso : Salut,

J'ouvre ce fil  pour vous présenter le test du servomoteur 9g SG90, disponible dans la boutique !

Donc deux petites photos pour commencer :

Voici ce qui est prévu pour le test :

• Explications du fonctionnement d'un servomoteur
• Branchement sur l'Arduino Nano + programme de test (inspiré de l'exemple Sweep)

Le programme de test actuel :

//Bibliothèque :
#include <Servo.h> //Ajoute la librairie Servo

//servo1 :
Servo servo1;    //Déclare un nouveau servomoteur nommé servo1
int pos = 0;     //Position initiale du servo
#define PAUSE 20 //Symbolise la pause en ms entre chaque mouvements du servo

void setup() {
  servo1.attach(9); //Attache servo1 au pin 9
}

void loop() {

  for (pos = 0; pos <= 180; pos++)
  //Rejoins un angle de 180° depuis 0° par pas de 1°
  {
    servo1.write(pos);
    delay(PAUSE);
  }
 
  for (pos = 180; pos >= 0; pos--)
  //Rejoins un angle de 0° depuis 180° par pas de 1°
  {
    servo1.write(pos);
    delay(PAUSE);
  }
 
}

A bientôt !

Celui que j'ai testé oui :

Salut,

De rien, c'est avec plaisir

 

Les caractéristiques des servomoteurs sont indiquées sur la fiche produit disponible sur le Shop, ainsi que sur cette datasheet(en anglais) :

 Datasheet SG90.pdf   137,91 Ko   794 téléchargement(s)

Désolé, je n'ai pas testé ceci. J'essayerais de le faire dès que j'ai à nouveau accès aux instruments de mesures

D'après les tests que j'avais pu faire, un servomoteur consomme aux alentours de 70mA sans charges, ainsi qu'un maximum d'environ 250mA lorsqu'il est contraint. Je n'ai pas essayé d'aller plus loin afin de ne pas l'endommager mais pour le test je pense partir sur une intensité max 30% supérieur à celle mesurée (cas le plus défavorable + marge de sécurité) c'est-à-dire aux alentours 325mA. (si vous trouvez la marge trop ou pas assez élevée, n'hésitez pas à me le faire remarquer)
Une petite vidéo du test (pas très conventionnel, désolé):

Surtout pour un engin de cette taille, je me rendais pas compte avant de chercher sur le site de la NASA(données du MSL): 3m de long, 2.7m de large, 2.1m de haut, le tout pour 900kg.

ça je sais que la doc officielle Arduino le fera très bien. Maintenant si dans le kit moins cher je sais que j'ai une doc travaillée à l'intérieur ou au moins des tutos clairs dédiés à ce kit tous accessible au même endroit (que je n'ai pas à fouiller dans les différentes catégories pour m'y retrouver) pourquoi pas la copie...

 

Au pire pourquoi ne pas dédier un forum à ce produit si il est présenté en boutique avec les questions de ceux qui ne l'auront pas encore acheté et les expériences de ceux qui l'auront déjà acheté... à voir...

C'est une bonne idée de créer une sorte de doc/aide pour chaque kit, ça permettrait aux personnes qui l'achète de savoir quoi faire (ou non) avec.

 

Je me permets d'ajouter quelques composants à la liste qui peuvent être utiles :

- L293D pour le contrôle des moteurs CC (je ne sais pas si vous les incluez avec les drivers moteurs CC)

- Modules de communication sans-fil Bluetooth (HC06 par exemple) ou wifi (ESP8266 par ex)

- Peu être peu utilisé, mais un FTDI

J'aime bien l'idée mais je ne partirai pas sur un banc de test comme celui que tu montre mais plutôt sur une carte électronique qui servirai de châssis à un robot du même type que Roby (2 roues motrices et une roue folle). Ça permettrais de commencer à gérer des leds implantées et au fur et à mesure on ajoute les composants jusqu'à finir avec un robot roulant complet (suiveur de ligne, éviteur d'obstacle ou autres...).

Salut,

J'ai fait un petit programme pour tester rapidement les MIN et MAX de chaque servo avec le driver. Il vous suffit d'entrer une donnée de cette forme dans l'interface Série : 2085380 (2->Numéro du servo a tester (entre 0 et 15), 085 -> le min, 380->le max).

J'ai ajouté une longueur d'onde de "repos" qui permet de ne pas forcer sur le servo si l'ordre est en dehors de ses limites physiques, elle est de 300 mais n'importe quel nombre entre 150 et 350 aurait fait l'affaire sur ces servomoteurs.

//Bibliothèques :
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

//Driver :
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

//Servo :
uint8_t servo = 0;
int mini = 0;
int maxi = 0;
#define PAUSE 2000
#define REPOS 300

//Serial :
int ava;      //Variable pour vérifier qu'une donnée est disponible
String mail; //Variable qui contient le message
String num;  //Contient le numéro du servo
String mi;   //Le min
String ma;   //Le max

void setup() {
  Serial.begin(9600);
  pwm.begin();

  pwm.setPWMFreq(50); //Fréquence utilisée par les servos analogiques

  yield();
}

void loop() {
  ava = Serial.available();
  if (ava > 0)
  {
    //Lecture des données reçues :
    mail = Serial.readString();

    //Séparation des données :
    num = mail.substring(0,1);
    mi = mail.substring(1,4);
    ma = mail.substring(4,7);

    //Affichage sur l'interface Série :
    Serial.print(num); Serial.print(" ");
    Serial.print(mi); Serial.print(" ");
    Serial.println(ma);

    //Conversion en int :
    servo = num.toInt();
    mini = mi.toInt();
    maxi = ma.toInt();

    for(uint8_t i = 0; i < 1; i++)
    {
      pwm.setPWM(servo,0,mini);
      delay(PAUSE);
      pwm.setPWM(servo,0,maxi);
      delay(PAUSE);
      pwm.setPWM(servo,0,mini);
      delay(PAUSE);
      pwm.setPWM(servo,0,maxi);
      delay(PAUSE);
      pwm.setPWM(servo,0,REPOS);
    }

    delay(2000);
    }
}

Salut,
J'ai commencé à toucher au driver 16 servos compris dans le kit pour robot quadrupède, donc voici le fil dédié au test de celui-ci.
 

 
Donc le driver ressemble à ceci, il permet à une carte Arduino de contrôler jusqu'à 16 servomoteurs avec 2 broches de la carte. De plus on peut mettre plusieurs drivers en série (62 au maximum) et ainsi contrôler jusqu'à 992 servos avec seulement 2 sorties !
 
J'ai fait un petit montage afin de tester son fonctionnement ainsi que celui de la bibliothèque Adafruit_PWMServoDriver.h :

 
Avec ce programme-ci, qui est une adaptation pour le driver du programme d'exemple de la bibliothèque Servo.h (je trouve qu'il est plus compréhensible que celui fourni avec la bibliothèque d'Adafruit) :

//Bibliothèques :
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

//Driver :
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

//Servos :
#define SERVOMIN 105 //Longueur minimum d'impulsion
#define SERVOMAX 460 //Longueur maximum d'impulsion
#define NBSERVO 0    //Nombre de servos-1
#define PAUSE 10
uint8_t servonum = 0;
int pos = 0;


void setup() 
{
  pwm.begin();

  pwm.setPWMFreq(50); //Fréquence utilisée par les servos analogiques

  yield();
}

void loop() 
{
   for (pos = SERVOMIN; pos <= SERVOMAX; pos++)
  //Rejoins un angle de 180° depuis 0° par pas de 1°
  {
    pwm.setPWM(servonum,0,pos);
    delay(PAUSE);
  }
  delay(2000);
  for (pos = SERVOMAX; pos >= SERVOMIN; pos--)
  //Rejoins un angle de 0° depuis 180° par pas de 1°
  {
    pwm.setPWM(servonum,0,pos);
    delay(PAUSE);
  }
  delay(2000);
  servonum++;
  if (servonum > NBSERVO) servonum = 0; 
}

Et voici une petite vidéo du programme en fonctionnement avec un servo (je la referais sûrement à cause de la mise au point) :

 
A bientôt !

J'ai un petit peu modifié le programme pour qu'il puisse gérer plus facilement plusieurs servos :

//Bibliothèques :
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

//Driver :
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

//Servos :
uint8_t servomin[] = {105,100}; //Liste des longueurs minimums d'impulsions
int servomax[] = {460,450};     //Liste des longueurs maximums d'impulsions
#define NBSERVO 1               //Nombre de servos - 1
#define PAUSE 5
uint8_t i = 0;
int pos = 0;


void setup()
{
  pwm.begin();

  pwm.setPWMFreq(50); //Fréquence utilisée par les servos analogiques

  yield();
}


void loop()
{
   for (pos = servomin[i]; pos <= servomax[i]; pos++)
  //Rejoins un angle de 180° depuis 0° par pas de 1°
  {
    pwm.setPWM(i,0,pos);
    delay(PAUSE);
  }
  delay(1000);
  for (pos = servomax[i]; pos >= servomin[i]; pos--)
  //Rejoins un angle de 0° depuis 180° par pas de 1°
  {
    pwm.setPWM(i,0,pos);
    delay(PAUSE);
  }
  delay(1000);
  i++;
  if (i > NBSERVO) i = 0;
}

Et la vidéo de ce programme avec 2 servos :

https://youtu.be/iSDU6_reOYU

 
J'ai aussi fait un autre programme qui permet de les faire tourner de 180° en même temps :

//Bibliothèques :
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

//Driver :
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

//Servos :
uint8_t servomin[] = {105,100}; //Liste des longueurs minimums d'impulsions
int servomax[] = {460,450}; //Liste des longueurs maximums d'impulsions
int x = 0;
int pos = 0;
uint8_t i = 0;
#define NBSERVO 2    //Nombre de servos
#define PAUSE 5
#define INTER 2000

void setup() 
{
  pwm.begin();

  pwm.setPWMFreq(50); //Fréquence utilisée par les servos analogiques

  yield();
}

void loop() 
{
  for (pos = 0; pos <= 180; pos++)
  //Rejoins un angle de 180° depuis 0° par pas de 1°
  {
    servo();
  }
delay(INTER);

  for (pos = 180; pos >= 0; pos--)
  //Rejoins un angle de 0° depuis 180° par pas de 1°
  {
    servo();
  }
delay(INTER);
}

void servo() {
  for (i = 0; i< NBSERVO; i++)
  {
    x = map(pos,0, 180, servomin[i], servomax[i]);
    pwm.setPWM(i,0,x);  
    delay(PAUSE);
  }
}

Dont voici le résultat avec 2 servomoteurs :

@mthibs, comme l'a dit Path, ce pin semble servir pour connecter plusieurs drivers entre eux. Tu peux retrouver un schéma ici.

 

@Telson, Merci , j'avais fait une vidéo avec une "charge" pour 4 servos mais on dirait que j'avais oublié de la poster ici...

 

 

J'utilisais encore le bornier à vis pour ce test mais depuis j'alimente les servos du robot à partir d'un des emplacements pour servo.

Je n'ai pas fait de tests avec 16 servos mais tu peux regarder les vidéos du quadrupède  qui utilise 12 servos avec ce driver.