La Nacelle MiniKAP

Il a fallu que je me lance dans la construction d'une nacelle miniature pour "voyager"...

Le but recherché ? Une nacelle compacte qui peut rentrer dans une valise entre les t-shirts, les pulls et le pantalons. En réfléchissant, il est apparu qu'il fallait que je me débarrasse aussi de la radio-commande. Elle prend trop de place. Donc ce sera une nacelle compacte autokap... Et les recherches sur le net ont commencé pour trouver des réponses techniques au cahier des charges.

Premier aspect : la structure. Par hasard, en fouinant sur le web, je suis tombé sur EasyRobotics, une entreprise de fabrication / conception d'articles de robotique. Plus précisément, ce qui m'a décidé, c'est la brique Easy. J'y ai vu une solution simple, bien pensée et modulaire pour une architecture compacte de nacelle. J'ai contatcé l'entreprise et été accueilli par le "patron" Nicolas Daddato, très à l'écoute des contrintes que je me suis fixé. Bilan, j'ai pris 2 briques Easy, une fourche longue, un axe de rotation court et de la visserie (merci M. Daddato, surtout pour la passe câble).

A partir de ces éléments, une structure à surgi :

projetminikap2

La partie structure étant réglé, il restait la partie électronique...

Pour l'autokap, il existe des solutions prêt-à-l'emploi, comme le Tucit-X (plus commercialisé) et l'Aurico. Mais je préfère bidouiller... Aussi, au hasard des discussion sur le forum de photo aérienne sous cerf-volant, quelqu'un a évoqué l'Arduino. Je ne suis pas un caïd de la programmation mais le langage utilisé semble assez simple... Du coup j'ai opté pour un Ardiuno nano V3.

arduino nano v3.

arduino-nano-v-3

Puis je me suis lancé dans la programmation, à partir de morceaux de code de Deltakap, Vertigo et Fxix du forum, plus quelques inspirations piochées de ci de là comme l'amortissement du mouvement du servo Tilt choppé là et là.

Bilan, j'ai abouti à ce code qui reste encore perfectible (et qui a été amélioré) :

#include <Servo.h>

// (¯`·.¸¸.-Paramètres Nacelle à étalonner au préalable-.¸¸.·´¯)

// Paramètres PAN
#define PAN_IDLE 1500 //signal d'arret du servo PAN
#define SPEED 10 // incrémentation du signal pour que PAN tourne à vitesse choisie
#define CYCLE 7750 // durée de rotation PAN pour 360° à la vitesse fixée
#define PAN_PIN 2 // pin PAN

//Paramètres TILT
#define TILT_PIN 3 // pin TILT
#define TILT_HORIZON 2020 // signal pour que l'apn regarde l'horizon
#define TILT_BAS 1100 // signal pour que l'apn regarde en bas

//(¯`·.¸¸.-Paramètres Prise de Vue-.¸¸.·´¯)

#define FORMAT 2 // format du capteur 1=4/3 2=3/2
#define FOCALE 35 // focale équivalent 24/36 en mm
#define APN_PIN 13 //pin de l'APN (pour moi fonctionne CHDK)
#define TILT_ZERO 10 // angle initial approximatif TILT par rapport à l'horizontale

// Fonction d'amortissement pour le TILT
#define SMOOTHSTEP(x) ((x) * (x) * (3 - 2 * (x))) //SMOOTHSTEP expression.

// (¯`·.¸¸.-Variables valables pour tout le programme-.¸¸.·´¯)
int CHAMP_HORIZ; // angle de champ horizontal
int CHAMP_VERTI; // angle de champ vertical
int supperpo = 20; //pourcentage de supperposition de 2 photos voisines

int CRAN_PAN; // nombre de crans du PAN pour une rotation 360°
int BASE; // angle d'inclinaison initiale du TILT
int CRAN_TILT; // nombres d'inclinaisons du TILT
int ANGLE_TILT; // angle du mouvement d'inclinaison du TILT

int m = 0; // une variable pour SMOOTHSTEP
int n = 0; // une autre variable pour SOOMTHSTEP
float N = 100.0; // nombre de segments de la courbe d'amortissement
float X; // Valeur amortie finale
float v; // Variable modifiée par la fonction SMOOTHSTEP
float old_angle = 2020.0; // Position de départ
float new_angle; // Position d'arrivée

//(¯`·.¸¸.-Déclaration des Servos-.¸¸.·´¯)
Servo pan_servo; // le servo PAN
Servo tilt_servo; //le servo TILT

//(¯`·.¸¸.-Routine de Rotation crantée du PAN-.¸¸.·´¯)
void rotation_pan(int nb){ //la rotation 360° est découpée en crans
for (int i = 0 ; i < nb ; i ++){ //boucle pour réaliser i crans pour 360°
if (nb != 1){ //TEST pour éviter une rotation complète 360° avec un cran au nadir
pan_servo.writeMicroseconds(PAN_IDLE + SPEED); //mise en rotation du PAN
delay (CYCLE / nb); //durée de rotation qui dépend du nombre de cran et de la durée totale d'un 360°
pan_servo.writeMicroseconds(PAN_IDLE); //arret du PAN
delay (200); //petite temporisation à régler
clic(); //prise du cliché
}
else { // SI la nacelle est au nadir
delay(500); // temporisation à régler
clic(); // cliché !
pan_servo.writeMicroseconds(PAN_IDLE + SPEED); // rotation d'un quart de tour
delay (CYCLE / 4);
pan_servo.writeMicroseconds(PAN_IDLE);
delay (200); // second cliché à 90° du premier
clic();
}
}
}

//(¯`·.¸¸.-Déclenchement direct de l'APN par CHDK-.¸¸.·´¯)
// Cette routine doit changer si on utilise un gentled ou autre...
void clic(){
digitalWrite(APN_PIN, HIGH); // pin APN ON
delay(400); // durée 400ms (a régler)
digitalWrite(APN_PIN, LOW); // pin APN OFF
delay(500); // delai après photo 500ms (a régler)
}

//(¯`·.¸¸.-Routine d'inclinaison du TILT-.¸¸.·´¯)

void tilt_angle(float angle){ // La fonction permet une inclinaison de tout angle
angle = map(angle, 0, 90, TILT_HORIZON, TILT_BAS); // Conversion de l'angle (degré) en signal pour le servo TILT
new_angle = angle; // Définition du point d'arrivée pour SMOOTHSTEP
for (m = 0; m < N; m++) // Fonction de déplacement amorti du servo
{
v = m / N;
v = SMOOTHSTEP(v);
X = (new_angle * v) + (old_angle * (1 - v));
tilt_servo.writeMicroseconds(X);
delay(20); // temporisation indispensable à régler éventuellement sinon le servo devient "fou"
m++;
}
old_angle = angle; // Le nouvel devient l'ancien pour la prochaine inclinaison
}

//(¯`·.¸¸.-LE SETUP-.¸¸.·´¯)
void setup() {
pan_servo.attach(PAN_PIN); // Affectation du servo PAN à son pin
tilt_servo.attach(TILT_PIN); // Affectation du servo TILT à son pin
pinMode(APN_PIN, OUTPUT); // Affectation de l'APN à son et définition du mode de fonctionnement du pin
// TEST du format du capteur de l'APN pour le calcul des angles des champ
if (FORMAT == 1){ // si c'est un 4/3
CHAMP_HORIZ = int(57.3 * 36 / FOCALE); // calcul approché du champ horizontal en fonction de la focale
CHAMP_VERTI = int(57.3 * 36 * 3 / (FOCALE * 4)); // calcul approché du champ vertical en fonction de la focale
}
else { // sinon c'est un 3/2 (genre 24/36)
CHAMP_HORIZ = int(57.3 * 36 / FOCALE); // calcul champ horizontal
CHAMP_VERTI = int(57.3 * 36 * 2 / (FOCALE * 3)); // calcul champ vertical
}
CRAN_PAN = int(360 / (CHAMP_HORIZ - (supperpo * CHAMP_HORIZ / 100))) + 1; // calcul (à l'entier supérieur) du nombre de crans du PAN à l'horizontale
CRAN_TILT = int((90 - TILT_ZERO) / (CHAMP_VERTI - (supperpo * CHAMP_VERTI / 100))) + 1; // calcul (à l'entier supérieur du nombre d'inclinaisons TILT hors nadir
ANGLE_TILT= int((90 - TILT_ZERO) / CRAN_TILT); // calcul de l'angle d'inclinaison
BASE = 90 - (CRAN_TILT * ANGLE_TILT); // calcul de l'angle initial exact(proche de celui défini)
}

//(¯`·.¸¸.-LA BOUCLE-.¸¸.·´¯)
void loop() {
for (int i = 0 ; i < (CRAN_TILT + 1); i ++){ // boucle d'inclinaison descendante du TILT nb de crans + 1 (nadir)
const float pi = 3.14; // définition de pi car non présent dans l'arduino
int j = BASE + ANGLE_TILT * i ; // j angle de TILT à appliquer
float a = pi * (j) / 180; // conversion de l'angle de tilt en radian
float b = cos(a); // calcul du cosinus de l'angle de TILT (cos utilise les radians)
int c = int(b * CRAN_PAN + 1); // c'est le nombre de crans du PAN en fonction de l'angle du TILT
tilt_angle(j); // déplacement du TILT

rotation_pan(c); // Appel à la boucle de rotation PAN pour un tour 360°
delay (1000); // temporisation à régler
}
for (int i = 1 ; i < CRAN_TILT; i ++){ //boucle d'inclinaison ascendante du TILT
const float pi = 3.14;
int j = BASE + ANGLE_TILT * (CRAN_TILT - i) ;
float a = pi * (j) / 180;
float b = cos(a);
int c = int(b * CRAN_PAN + 1);
tilt_angle(j);
rotation_pan(c);
delay (1000);
}
}

J'ai voulu cette fois-ci, faciliter son utilisation à n'importe quel appareil sur n'importe quelle nacelle ou presque (PAN modifié 360° et TILT non modifié).

Il faut pour cela donner les paramètres de la nacelle :
- durée de rotation 360° du PAN
- signaux du TILT pour qu'il soit à l'horizontale puis à la vericale
(Je pense qu'on peut automatiser ce test avec un programme arduino et afficher le résultat dans le monitor, mais je ne sais pas comment...)

Ensuite il faut définir les paramètres de prise de vue.
- le type de format de capteur 4/3 ou 3/2
- la focale en équivalent 24mm/36mm
- une approximation de l'inclinaison initiale

Tout le reste est calculé... On peut ajuster quelques réglages, mais ce n'est pas obligatoire.

Je pense que je finirai par faire un autre programme de congfiguration / calibration afin que ça soit facile à utiliser par quiconque veut se lancer dans l'utilisation de l'arduino en autokap.

De même, je compte faire un programme d'autokap burst... pour le fun.

Voici maintenant le résultat final obtenu :

1- La modification du servo TowerPro MG 946R :

Il faut meuler le taquet qui bloque la rotation au delà de 270°. Puis j'ai choisi de remplacer le potentiomètre d'asservissement par un équivalent multitour qui sera plus précis à utiliser pour régler le neutre. Enfin, j'ai enlevé la partie plastique dans le pignon supérieur en métal afin de dégager le trou taraudé pour passer l'axe de rotation du PAN.

2-La conception de l'axe de rotation PAN :

J'ai meulé le plus long écrou fileté en 3mm que j'ai pu trouver (j'aurais pu aussi utiliser de la tige filetée 3mm avec une extrémité écrasée). Puis je l'ai glissé / vissé dans l'orifice taraudé. En fin se parcours, ça se vérouille tout seul sans effort. Ainsi l'axe est solidaire du pignon de sortie. On pourrait craindre pour la solidité de l'ensemble du servo, mais j'ai apporté une solution...

3- La structure de la nacelle :

Première étape, éviter la rupture du servo de PAN. J'ai choisi le TowerPro MG 946R car il a des pignons en métal et que le pignon de sortie est maintenu par 2 roulements à billes. Si je le laisse tel quel fixé sur une brique Easy, il rsque de se casser au niveau du plastique supérieur. Donc il a fallu renforcé cette partie par une plaque alu percée en 13mm environ. Ce diamètre, même en cas de rupture du plastique, ne laisserait pas passer le pignon de sortie, et donc pas de surprise à ce niveau.

Pour le reste, j'ai fait confiance à la brique Easy et à la visserie adaptée... à laquelle j'ai ajouté du frein filet par ci et par là.

La seule pièce que j'ai fabriqué (et ça se voit), est le support de l'APN et de l'électronique en alu. Ajouté à cela, la vis de fixation "qui va bien". Rien de bien compliqué en somme.

Une subtilité : l'utilisation du passe câble. Généreusement, M. Daddato en avait ajouté un à ma commande. Cela m'a permis de faire un système articulé pour le câble USB de déclenchement (d'où l'utilisation d'un écrou Nyl-stop).

4- La partie électronique :

Ici, c'est un peu plus subtil (quoique). Plutôt que de souder directement sur la carte arduino, au risque de devoir désouder au gré des évolutions et réparations, j'ai préféré me faire une plaque support (avec un reste de plaque d'essai). Les connecteurs pour l'arduino, ne sont pas des connecteurs tulipe, ils sont plus profonds et assez faciles à trouver sur la Bay. J'avais pris un lot mâle femelle, comme cela, les connecteurs femelles sont pour l'arduino et les mâles pour les servos ou autres... Le plan ensuite est simpliste. Pour finir, j'ai mis un peu de colle à chaud pour fixer les câbles et sur la face inférieure pour avoir une surface propice pour de l'adhésif double-face (d'extérieur). Quelques colliers auto-serrants et le tour est joué. Je compte quand même ajouter un jour une plaque de protection... On ne sait jamais.

5 - La suspension Picavet (car c'est la plus compacte) :

C'est une partie qui me plait beaucoup et qui a nécessité un peu de réflection. Je voulais une nacelle pliable, mais facile à utiliser. Donc j'ai fait une croix Picavet compacte un peu différente que celle qu'on trouve sur le Net conçue par Brookes par exemple. La vis au centre, incrustée dans l'une des barres est la "sécurité". Si la croix se démonte par le haut, elle reste solidaire de l'axe central. Oui mais... on pourrait penser que cela puisse se dévisser. Ben non, la fixation du pallonier plastique interdit toute rotation intenpestive, et donc tout dévissage de cette vis. Le point faible reste quand même la tige filetée de 3mm, qui si elle se rompait... mais je ne préfère pas y penser. Puis la seconde barre s'emboîte à 90° (environ) dans la première et est maintenue par un écrou à oreilles. C'est une solution que j'utilise sur ma grosse nacelle sans soucis.

Et voici le résultat final : 610 g environ au total

BILAN au bout de plus de trois ans d'utilisation : je ne me sers que de cette nacelle avec monté dessus un Ricoh GX200, et une LiPo 2000mAh en 2S. Je suis parti au Pérou avec, que du bonheur et je n'ai jamais eu à recharger ma LiPo en 12 jours.

Je mets ci-dessous le code Arduino que j'utilise avec le déclanchement du GX200 par sa prise miniUSB. J'ai testé aussi cette nacelle avec un Samsung NX100 et le principe de déclanchement avec mon réflex Eos 550D.

#include <Servo.h>

// (¯`·.¸¸.-Paramètres Nacelle à étalonner au préalable-.¸¸.·´¯)

// Paramètres PAN
#define PAN_IDLE 1500 //signal d'arret du servo PAN
#define SPEED 10 // incrémentation du signal pour que PAN tourne à vitesse choisie
#define CYCLE 5300 // durée de rotation PAN pour 360° à la vitesse fixée
#define PAN_PIN 3 // pin PAN

//Paramètres TILT
#define TILT_PIN 4 // pin TILT
#define TILT_HORIZON 2020 // signal pour que l'apn regarde l'horizon
#define TILT_BAS 1100 // signal pour que l'apn regarde en bas

//(¯`·.¸¸.-Paramètres Prise de Vue-.¸¸.·´¯)

#define FORMAT 2 // format du capteur 1=4/3 2=3/2
#define CADRAGE 1 // 1=paysage 2=portrait
#define FOCALE 35
// focale équivalent 24/36 en mm
#define APN_PIN 13 //pin de l'APN (Canon CHDK ou Ricoh)

// pour Samsung NX ou Canon EOS
#define Focus_PIN 6 //pin Mise au point
#define Shoot_PIN 5 //pin Clic Samsung
int tempo_focus = 600; // durée laissée à la mise au point, ici 400 ms à régler
int tempo_shoot = 300; // durée pour le contact du shoot, ici 200ms à régler

#define TILT_ZERO 10 // angle initial approximatif TILT par rapport à l'horizontale
#define APNCHOIX 2 // 1=Canon 2=Ricoh (valable que sur le pin 13)

// nb de crans de tilt
#define PIN_MODE 6 // Pin mode du Tilt (simple ou double)
int Tilt_Mode; // mode de Tilt (simple ou double)

// Fonction d'amortissement pour le TILT
#define SMOOTHSTEP(x) ((x) * (x) * (3 - 2 * (x))) //SMOOTHSTEP expression.

// (¯`·.¸¸.-Variables valables pour tout le programme-.¸¸.·´¯)
int CHAMP_HORIZ; // angle de champ horizontal
int CHAMP_VERTI; // angle de champ vertical
int supperpo = 32; //pourcentage de supperposition de 2 photos voisines

int CRAN_PAN; // nombre de crans du PAN pour une rotation 360°
int BASE; // angle d'inclinaison initiale du TILT
int CRAN_TILT; // nombres d'inclinaisons du TILT
int ANGLE_TILT; // angle du mouvement d'inclinaison du TILT

int m = 0; // une variable pour SMOOTHSTEP
int n = 0; // une autre variable pour SOOMTHSTEP
float N = 100.0; // nombre de segments de la courbe d'amortissement
float X; // Valeur amortie finale
float v; // Variable modifiée par la fonction SMOOTHSTEP
float old_angle = 2020.0; // Position de départ
float new_angle; // Position d'arrivée

//(¯`·.¸¸.-Déclaration des Servos-.¸¸.·´¯)
Servo pan_servo; // le servo PAN
Servo tilt_servo; //le servo TILT

//(¯`·.¸¸.-Routine de Rotation crantée du PAN-.¸¸.·´¯)
void rotation_pan(int nb){ //la rotation 360° est découpée en crans
for (int i = 0 ; i < nb ; i ++){ //boucle pour réaliser i crans pour 360°
if (nb != 1){ //TEST pour éviter une rotation complète 360° avec un cran au nadir
pan_servo.writeMicroseconds(PAN_IDLE + SPEED); //mise en rotation du PAN
delay (CYCLE / nb); //durée de rotation qui dépend du nombre de cran et de la durée totale d'un 360°
pan_servo.writeMicroseconds(PAN_IDLE); //arret du PAN
delay (500); //petite temporisation à régler
clic(); //prise du cliché
}
else { // SI la nacelle est au nadir
delay(500); // temporisation à régler
clic(); // cliché !
pan_servo.writeMicroseconds(PAN_IDLE + SPEED); // rotation d'un quart de tour
delay (CYCLE / 4);
pan_servo.writeMicroseconds(PAN_IDLE);
delay (500); // second cliché à 90° du premier
clic();
}
}
}

//(¯`·.¸¸.-Déclenchement direct de l'APN par CHDK-.¸¸.·´¯)
// Cette routine doit changer si on utilise un gentled ou autre...
void cliccanon(){
digitalWrite(APN_PIN, HIGH); // pin APN ON
delay(400); // durée 400ms (a régler)
digitalWrite(APN_PIN, LOW); // pin APN OFF
}

//(¯`·.¸¸.-Déclenchement direct de l'APN Ricoh par USB-.¸¸.·´¯)
// Cette routine doit changer si on utilise un gentled ou autre...
void clicricoh(){
digitalWrite(APN_PIN, HIGH); // pin APN ON
delay(30); // durée 30ms (half-press et focus)
digitalWrite(APN_PIcodeN, LOW); // pin APN OFF
delay(200); // pause
digitalWrite(APN_PIN, HIGH); // pin APN ON
delay(150); // durée 150ms (full-press)
digitalWrite(APN_PIN, LOW); // pin APN OFF
delay(100); // delai après photo 2s (a régler)
digitalWrite(APN_PIN, HIGH); // pin APN ON
delay(30); // durée 30ms (release)
digitalWrite(APN_PIN, LOW); // pin APN OFF
delay(30); // durée 30ms
digitalWrite(APN_PIN, HIGH); // pin APN ON
delay(30); // durée 30ms
digitalWrite(APN_PIN, LOW); // pin APN OFF
}

//(¯`·.¸¸.- Déclenchement direct de l'APN Samsung NX -.¸¸.·´¯)
//(¯`·.¸¸.-Valable aussi pour déclencher un Canon EOS-.¸¸.·´¯)
// Cette routine doit changer si on utilise un gentled ou autre...
void clicsamsung(){
digitalWrite(Focus_PIN, HIGH);
delay(tempo_focus);
digitalWrite(Shoot_PIN, HIGH);
delay(tempo_shoot);
digitalWrite(Focus_PIN, LOW);
digitalWrite(Shoot_PIN, LOW);
}

//(¯`·.¸¸.-Déclenchement direct de l'APN.¸¸.·´¯)
void clic(){
delay(1000);
if (APNCHOIX == 1) {
cliccanon();
}
if (APNCHOIX == 2) {
clicricoh();
}
clicsamsung();
int t = tempo_focus + tempo_shoot;
delay(2000 - t); // delai après photo 2s (a régler)
}

//(¯`·.¸¸.-Routine d'inclinaison du TILT-.¸¸.·´¯)

void tilt_angle(float angle){ // La fonction permet une inclinaison de tout angle
angle = map(angle, 0, 90, TILT_HORIZON, TILT_BAS); // Conversion de l'angle (degré) en signal pour le servo TILT
new_angle = angle; // Définition du point d'arrivée pour SMOOTHSTEP
for (m = 0; m < N; m++) // Fonction de déplacement amorti du servo
{
v = m / N;
v = SMOOTHSTEP(v);
X = (new_angle * v) + (old_angle * (1 - v));
tilt_servo.writeMicroseconds(X);
delay(20); // temporisation indispensable à régler éventuellement sinon le servo devient "fou"
m++;
}
old_angle = angle; // Le nouvel devient l'ancien pour la prochaine inclinaison
}

//(¯`·.¸¸.-LE SETUP-.¸¸.·´¯)
void setup() {
pan_servo.attach(PAN_PIN); // Affectation du servo PAN à son pin
tilt_servo.attach(TILT_PIN); // Affectation du servo TILT à son pin
pinMode(APN_PIN, OUTPUT); // Affectation de l'APN à son et définition du mode de fonctionnement du pin
pinMode(PIN_MODE, INPUT); // Affectation du switch de mode du Tilt
pinMode(Focus_PIN, OUTPUT); // Affectation de la mise au point Samsung NX ou Canon EOS
pinMode(Shoot_PIN, OUTPUT); // Affectation du clic NX ou EOS
if (CADRAGE == 1) { // si le cadrage est paysage // TEST du format du capteur de l'APN pour le calcul des angles des champ
if (FORMAT == 1){ // si c'est un 4/3
CHAMP_HORIZ = int(57.3 * 36 / FOCALE); // calcul approché du champ horizontal en fonction de la focale
CHAMP_VERTI = int(57.3 * 36 * 3 / (FOCALE * 4)); // calcul approché du champ vertical en fonction de la focale
}
else { // sinon c'est un 3/2 (genre 24/36)
CHAMP_HORIZ = int(57.3 * 36 / FOCALE); // calcul champ horizontal
CHAMP_VERTI = int(57.3 * 36 * 2 / (FOCALE * 3)); // calcul champ vertical
}
}
else { // si le cadrage est portrait
if (FORMAT == 1){ // si c'est un 4/3
CHAMP_VERTI = int(57.3 * 36 / FOCALE); // calcul approché du champ horizontal en fonction de la focale
CHAMP_HORIZ = int(57.3 * 36 * 3 / (FOCALE * 4)); // calcul approché du champ vertical en fonction de la focale
}
else { // sinon c'est un 3/2 (genre 24/36)
CHAMP_VERTI = int(57.3 * 36 / FOCALE); // calcul champ horizontal
CHAMP_HORIZ = int(57.3 * 36 * 2 / (FOCALE * 3)); // calcul champ vertical
}
}

CRAN_PAN = int(360 / (CHAMP_HORIZ - (supperpo * CHAMP_HORIZ / 100))) + 1; // calcul (à l'entier supérieur) du nombre de crans du PAN à l'horizontale
CRAN_TILT = int((90 - TILT_ZERO) / (CHAMP_VERTI - (supperpo * CHAMP_VERTI / 100))) + 1; // calcul (à l'entier supérieur du nombre d'inclinaisons TILT hors nadir
Tilt_Mode = digitalRead(PIN_MODE);
if (Tilt_Mode = HIGH) CRAN_TILT = CRAN_TILT * 2;
ANGLE_TILT= int((90 - TILT_ZERO) / CRAN_TILT); // calcul de l'angle d'inclinaison
BASE = 90 - (CRAN_TILT * ANGLE_TILT); // calcul de l'angle initial exact(proche de celui défini)
}

//(¯`·.¸¸.-LA BOUCLE-.¸¸.·´¯)
void loop() {
for (int i = 0 ; i < (CRAN_TILT + 1); i ++){ // boucle d'inclinaison descendante du TILT nb de crans + 1 (nadir)
const float pi = 3.14; // définition de pi car non présent dans l'arduino
int j = BASE + ANGLE_TILT * i ; // j angle de TILT à appliquer
float a = pi * (j) / 180; // conversion de l'angle de tilt en radian
float b = cos(a); // calcul du cosinus de l'angle de TILT (cos utilise les radians)
int c = int(b * CRAN_PAN + 1); // c'est le nombre de crans du PAN en fonction de l'angle du TILT
tilt_angle(j); // déplacement du TILT

rotation_pan(c); // Appel à la boucle de rotation PAN pour un tour 360°
delay (1000); // temporisation à régler
}
for (int i = 1 ; i < CRAN_TILT; i ++){ //boucle d'inclinaison ascendante du TILT
const float pi = 3.14;
int j = BASE + ANGLE_TILT * (CRAN_TILT - i) ;
float a = pi * (j) / 180;
float b = cos(a);
int c = int(b * CRAN_PAN + 1);
tilt_angle(j);
rotation_pan(c);
delay (1000);
}
}

Pour ce qui est du mode de branchement entre un Arduino et un réflex Eos ou un Sammsung NX, on verra dans un autre article...

Creative Commons License
MiniKAP by Jean-Christophe Labrouche est mis à disposition selon les termes de la licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Partage des Conditions Initiales à l'Identique 2.0 France.