Tournicayou (Photogrammétrie)

1ère Séance : Sujet Photogrammétrie (Schéma) + Découverte de ARDUINO

• Premières réflexions réalisation sur la de ce support à photogrammétrie.
• Réalisation de plusieurs dessins "idées" (voir photos).
• Première manipulation avec le logiciel ARDUINO, premier codage. Bien difficile....

_{Codage avec Arduino, led clignotant SOS en morse.}

2ème Séance : Retour sur le support (Schémas) + Mise en place des différentes étapes

• Reprise de la structure du support de photogrammétrie --> bras tournant autour du support
• Mise en place des différentes étapes :
  • Moteur + programmation
  • Moule à Tarte
  • Arduino + caméras + affichage ordi à voir ?
  • Soutiens-gorge : support caméra + LED
    • Bonus : écran + angles + focus caméras

3ème Séance : Gratuit Gratuit ecad + Arduino

FREECAD

Apprentissage des fonctions de base du logiciel Freecad. Plusieurs essais infructueux de la conception de la pièce crantée permettant le support du moteur autour de l'objet à photographier.

Vidéos youtube visionnées pour le modèle Freecad : 

• https://www.youtube.com/watch?v=3wPDnRFfgEg
• https://www.youtube.com/@cadgab/playlistshttps://www.youtube.com/@cadgab/playlists

LE COULOMMIERS EST TERMINÉ (18/02) - Côte Mauvaise

Pour créer le coulommiers, qui fait office d'engrenage interne permettant le déplacement du bras, il faut créer deux corps différents sur FreeCad. Les corps sont créés sur le module Part design

• Un cercle de 600 mm de diamètre et 200 mm de haut
• Un engrenage à développer de Dp = 495 mm, M = 2,5 mm, z = 198 et 200 mm de haut

Une fois les deux corps formés, il faut utiliser une booléenne pour former le rouage final grâce au module Part

Attention : Les valeurs inscrites sont les valeurs erronées

ARDUINO

Familiarisation réalisation avec le logiciel Arduino et d'un premier montage :

• Matériels :
  • Arduino Uno + câble USB de liaison Arduino/Ordinateur
  • Câbles de connexion
  • Moteur pas à pas 28 BYJ-48

• Schéma de connexion :

•  Code : 
  • Ce code permet au moteur de réaliser une rotation dans le sens des aiguilles d'une montre, attendre 1 seconde(s), puis de faire une rotation dans le sens contraire des aiguilles d'une montre, puis de nouveau attendre 1 s.

#include <Stepper.h> 

double stepsPerRevolution = 2048;

Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);  // Pin inversion to make the library work

void setup() { 
  myStepper.setSpeed(10);
  Serial.begin(9600); 
  } 

  void loop() {
    // 1 rotation counterclockwise:
    Serial.println("counterclockwise");
    myStepper.step(stepsPerRevolution);
    delay(1000); 

   // 1 rotation clockwise: 
   Serial.println("clockwise");
   myStepper.step(-stepsPerRevolution); 
   delay(1000); 
}

 Une librairie Stepper.h existe.

• • Succès de ce premier montage et code associé. Manipulation du code nous permettant d'obtenir une rotation dans le sens des aiguilles d'une montre avec arrêt de 1 s. (suppression de la première partie de la void loop) 
  • Rapidement essayez de changer de vitesse = ÉCHEC --> comprendre pourquoi à la prochaine séance.

--> Prochaine étape : Réaliser le montage avec ajout d'un potentiomètre permettant de contrôler la vitesse de rotation ainsi que le sens (--> potentiomètre vers la droite= sens des aiguilles d'une montre ; potentiomètre à gauche = sens inverse )

4ème Séance : Gratuit ecad + Arduino

Partie Freecad : 

Modélisation du rouage pour le moteur pas à pas, et reprise de dimension du coulommiers. Pour calculer le nombre de dents de chaque rouage, externe (Moteur) comme interne (Coulommiers) nous avons suivi l'équation suivante :

Dp/M = z

Dp => Le diamètre primitif ; M => Module du rouage ; z => Nombre de dents

Pour que deux engrenages puissent fonctionner ensemble il faut respecter 3 conditions :

• Ils doivent avoir un module égal
• Ils doivent avoir un angle de pression égal (par convention 20°)
• Leur diamètre primitif doit être tangent

Pour le dernier point, la distance entre le centre des rouages ​​Dr = ((z ₁ +z ₂ )*M)/2

Pour le coulommiers :

La modélisation comporte deux corps.

• Un cercle de 300 mm de diamètre et 100 mm de haut
• Un engrenage à développé de Dp = 250 mm, M = 2,5 mm, z = 100 et 100 mm de haut

Pour former le rouage interne, il faut faire la différence des deux corps grâce à la booléenne dans le module  Part . (cf  https://www.youtube.com/watch?v=3wPDnRFfgEg) 

Pour le rouage externe ce dernier doit être fixé sur la "tige" du moteur faisant 19 mm de long. Il faut creuser un cylindre de 5mm de diamètre au centre du rouage avec une corde de 3mm afin de respecter l'aspect de la tige.

La modélisation comporte deux corps.

• Un cylindre de 5mm de diamètre coupé d'une corde de 3mm et faisant 19mm de haut
• Un engrenage externe de Dp = 45 mm, M = 2,5 mm, z = 18 et 19 mm de haut

Impression 3D des pièces pour essais ultérieurs.

ARDUINO

Retour sur le montage réalisation et la du circuit de la semaine dernière = ÉCHEC. Nous n'avons pas trouvé la raison pour laquelle la réussite de la semaine passée n'était plus réalisable. (Changement de moteur, vérification et retour sur les explications du code, changement de code, vérification du fonctionnement de la carte Arduino uno...)

Réalisation d'un autre montage avec le moteur Servo :

• Matériels :
  • Arduino Uno + câble USB de liaison Arduino/Ordinateur
  • Câbles de connexion
  • Microservo à moteur pas à pas SG90

• Schéma de connexion :

•  Code : 
  • Ce code permet au moteur de réaliser une rotation dans le sens des aiguilles d'une montre, attendre 1 seconde(s), puis de faire une rotation dans le sens contraire des aiguilles d'une montre, puis de nouveau attendre 1 s.

Après plusieurs échecs, et des changements de codes, succès de la manipulation. Notre moteur se déplace de l'angle 0 à l'angle 90, puis à celui 180 avant de revenir à 0 et de recommencer sa boucle. Après chaque déplacement celui-ci fait une pause de 1 s. Notre moteur avance degré par degré.

--> Prochaine étape : Modification de notre code pour réaliser un mouvement de 20° en 20° avec 1 s de délai entre chaque déplacement.

Objectif de la séance :  Finaliser le code arduino pour le moteur, tester les pièces 3D, conception du bras

Nous avons commencé la réalisation des plans quant à la partie qui tourne autour du coulommiers. Trois soirées :

• Le support même du moteur, permettant sa fixation par vis.
• La partie centrale, dotée d'une roue permettant au socle tournant d'avancer sur les coulommiers.
• Le support bras, avec des fentes permettant l'insertion du bras photo et des emplacement pour piles et carte arduino.

L'idée est de créer deux pièces s'assemblant comme un puzzle. La première composée du socle moteur et de la partie centrale. L'autre du socle bras.

ARDUINO

Une partie des coulommiers dentés et le rouage du moteur sont désormais imprimés ! Aujourd'hui sur un pu tester le gros moteur de 12 V, qui sera notre moteur final, avec donc le rouage modélisé par Lucas. 

J'ai cramé la batterie brique de 12 V... Surement un problème dans mon montage.

Réalisation d'un autre montage avec le moteur NEMA 17, moteur pas à pas de 12 V :

• Matériels :
  • Arduino Uno + câble USB de liaison Arduino/Ordinateur
  • Câbles de connexion
  • Moteur Shield
  • Moteur NEMA 17 pas à pas

• Schéma de connexion :

•  Code : 
  • Ce code permet au moteur de réaliser une rotation dans le sens des aiguilles d'une montre, attendre 1 seconde(s), puis de faire une rotation dans le sens contraire des aiguilles d'une montre, puis de nouveau attendre 1 s.

#include <AFMotor_R4.h>

const int stepsPerRevolution = 200;   // nombre de pas du moteur

AF_Stepper motor(stepsPerRevolution, 2);

void setup() {
  Serial.begin(9600);
  motor.setSpeed(10);  // vitesse en RPM
}

void loop() {

  // Calcul du nombre de pas pour 20°
  int stepsFor20Degrees = stepsPerRevolution / 18;

  // Rotation sens horaire (aiguilles d'une montre)
  motor.step(stepsFor20Degrees, FORWARD, SINGLE);

  delay(1000);  // arrêt de 1 seconde

}

• • Ce code fonctionne plutôt très bien, il réalise donc une rotation dans le sens des aiguilles d'une montre ; fait 20° puis fait une pause pour la photo.

#include <AFMotor_R4.h>

const int stepsPerRevolution = 200;   // nombre de pas du moteur

AF_Stepper motor(stepsPerRevolution, 2);

void setup() {
  Serial.begin(9600);
  motor.setSpeed(10);  // vitesse en RPM
}

void loop() {

int stepsFor20Degrees = stepsPerRevolution / 18; // 20° ≈ 11 pas

  // Un tour complet = 360° = 18 segments de 20°
  for(int i = 0; i < 18; i++) {
    motor.step(stepsFor20Degrees, FORWARD, SINGLE);  // avance 20°
    delay(2000);  // pause de 2 secondes
  }

  // Pause longue à la fin du tour
  delay(10000);  // pause de 10 secondes
}

Ce 2ème code est très probablement mieux mais manque de fluidité de mouvement : il ne réalise pas forcément tout le temps 20° degré mais parfois moins et de manière saccadé. Il réalise donc 11 pas pour faire les 20° demandées ; pause de 2 secondes ; puis reprends pour faire un tour complet de 20 par 20 ; pause de 10 s.

Ce code rend le moteur extrêmement bruyant en plus du mouvement saccadé.

Partie conception 3D : Le socle moteur

Conception du socle moteur sur Freecad. Les mesures sont encore à vérifier. Le socle est composé d'un assemblage Freecad de deux pièces. La première correspond au support même du moteur, et dispose de 4 trous de fixation permettant par vis et un cinquième plus grand permettant au bras du moteur de passer. (Le moteur est fixé par la surface où se situe le bras). L'autre pièce est un rectangle permettant l'insertion d'une roue à billes, servant au roulement du support moteur sur les coulommiers. Cette pièce possède un trou permettant le passage d'une tige maintenant la roue en place. La conception de cette tige en 3D est réalisée, mais reste à voir pour sa conception (Impression 3D, métal, autre ?)(Au final Pierre a arrangé une vis pour la faire maintenir la roue). Le rectangle possède un creux en forme de puzzle servant à l'insertion du socle du bras, devant encore être modélisé. 

Fichier STL de la pièce décrite : 

Lucas : J'ai limé pendant deux heures le bloc, puis début de la conception des plan pour la pièce arrière.

Partie conception 3D : Création de la pièce arrière

La pièce arrière a pour but de maintenir la machine autour du coulommiers et de servir de contre-poids au moteur. Celle-ci est composée de deux parties principales, formant une pièce unique :

1. La partie la plus importante est le gros boîtier principal. Celui-ci fait ... de large, ... de haut et ... de long. À l'intérieur une grande cavité est laissée pour permettre de tenir les différents composants électriques. L'avant de la pièce possède la pièce de puzzle complémentaire au support moteur, le rond de à un diamètre de 15,5mm. À partir du haut, au bout de ...mm, la face avant recule de 4mm pour que permettre à un roulement à billes de rouler sur le bord du coulommiers. Sur la partie basse, deux roues sont placés sur un arc de cercle fictif de 735mm de diamètre. Cet arc a le même foyer que le coulommiers, les roues ainsi inclinées d'un angle de 6,60° à partir de l'axe central de la pièce servent à la pièce à tourner plus facilement. 
2. La deuxième partie est sur la partie haute de la pièce. Il s'agit d'un socle ayant à l'avant de trous de 8,25mm de rayon permettant l'encoche du bras photographique.

Fichier STL de la pièce décrite : 

ARDUINO

Aujourd'hui j'ai revu le code pour notre moteur afin que celui-ci réalise 20° sur les coulommiers et non par rapport à l'axe du moteur.

Réalisation d'un autre montage avec le moteur NEMA 17, moteur pas à pas de 12 V :

• Matériels :
  • Arduino Uno + câble USB de liaison Arduino/Ordinateur
  • Câbles de connexion
  • Moteur Shield
  • Moteur NEMA 17 pas à pas

• Schéma de connexion :

•  Code : 
  • Petite partie calcule pour réaliser le code et essayer de trouver une façon pour que le moteur soit un mouvement plus fluide et plus saccadé et bruyant.

coulommiers = 100 bosses ; rouage = 18 bosses ; moteur pas à pas = 200 pas / tour

100/18=5.55 tours --> le bébé rouage effectuera donc 5.5 tour pour réaliser un tour complet du tour interne du coulommiers.

200 x 5.55 = 1 111 pas --> le moteur lui devra donc réaliser 1111 pas pour faire 360° donc un tour complet du coulommiers.

1111 x 20/360 = 61.7 pas --> le moteur devra réalisé environ 62 pas pour réaliser 20° sur le coulommiers. 

62 pas x 18 positions = 1 116 pas # 1 111 pas ! => possibilité d'alternance entre 62 et 61 pas pour obtenir pile 360° 

• • Pour éviter que le moteur soit saccadé on peut voir pour augmenter la vitesse de déplacement/ ou la diminuer.

#include <AFMotor_R4.h>

const int stepsPerRevolution = 200;   // pas moteur
const int stepsFor20Degrees = 62;     // calcul avec engrenage

AF_Stepper motor(stepsPerRevolution, 2);

void setup() {
  Serial.begin(9600);
  motor.setSpeed(10);  // vitesse RPM
}

void loop() {

  // 360° / 20° = 18 positions
  for(int i = 0; i < 18; i++) {

    motor.step(stepsFor20Degrees, FORWARD, SINGLE);

    Serial.print("Position : ");
    Serial.println(i + 1);

    delay(2000);   // pause entre chaque mouvement
  }

  Serial.println("Tour complet terminé");

  delay(10000);
}

• • 1er code testé : FONCTIONNEL !
  • Testez un autre code avec une alternance de 61 et 62 pas pour avoir pile 360° et voir si celui ci est plus fluide ou non.

#include <AFMotor_R4.h>

const int stepsPerRevolution = 200;

AF_Stepper motor(stepsPerRevolution, 2);

int positionIndex = 0;

// Séquence corrigée pour obtenir exactement 360°
int stepSequence[18] = {
  62,62,62,62,62,62,
  62,62,62,
  61,
  62,62,62,62,62,
  62,62,
  61
};

void setup() {

  Serial.begin(9600);

  motor.setSpeed(10);

  Serial.println("Systeme de rotation initialise");

}

void loop() {

  int steps = stepSequence[positionIndex];

  motor.step(steps, FORWARD, INTERLEAVE);

  Serial.print("Position : ");
  Serial.println(positionIndex + 1);

  positionIndex++;

  delay(2000);   // pause de 2 s entre chaque mouvement

  if(positionIndex >= 18)
  {
    positionIndex = 0;

    Serial.println("Tour complet termine");

    delay(10000);   // pause de 10 s après le tour complet
  }
}

Toujours un problème de fluidité, voir pour améliorer le 1er code ou le 2ème. 

Test de différentes vitesses : 5 et 30 plus ou moins OK, toujours saccadé et bruyant --> voir microstep ?

Recherche pour les caméras : Arducam Shield Mini 5MP Plus :

• Montage possible :

• • Carte SD nécessaire ? 
  • Dans ce montage, le module caméra 5MP serait utilisé avec une carte Arduino UNO pour capturer des images à intervalles réguliers. Sans carte microSD, les photos ne peuvent pas être stockées directement sur le système embarqué.
  • À la place, les données de l'image au format JPEG seront envoyées via la liaison série (USB) vers un ordinateur. L'Arduino déclenche une prise de vue, transmet les données binaires correspondantes, puis attend 30 secondes avant de recommencer (pour notre projet).
  • Comme l'Arduino Uno possède une mémoire limitée, il est nécessaire de réduire la résolution des images afin d'assurer un fonctionnement stable. --> utilisation d'une autre carte ?
  • Les images reçues sur l'ordinateur peuvent ensuite être reconstruites et visualisées à l'aide d'un programme externe, par exemple en Python.

--> Prochaine séance : Test de 25 - 5° pour améliorer la fluidité + CAMÉRAS ! redemander les bibliothèques.

On galère avec les caméras....

Partie conception 3D : Création du bras photographique

Ce bras s'encoche dans la partie haute de la pièce arrière. Il est conçu en une pièce unique (dû à la limitation de taille d'impression de l'imprimante 3D, la pièce a été scindé en deux pour les tests) en trois parties.

1. La partie basale est composée de deux tubes permettant l'insertion à la pièce arrière. Les encoches étant de 8,25mm de rayon, le tubes ont un rayon de 7,25mm.
2. Le bras incurvé, arc de cercle de 692 mm de diamètre. Il forme un angle de 72,70°. Afin d'alléger la structure, mais aussi de limiter l'utilisation de plastique, des triangles équilatéraux d'une arête de 34,1738mm sont disposés de façon alterne. Cinq triangles avec la pointe distal au support central, quatre avec une pointe qui lui est proximal.
3. Deux nouvelles encoches à 19,96° et 59,39° de 7mm de diamètre permettront l'insertion des caméras.

Fichier STL de la pièce décrite : 

Le bras du Tournicayou est imprimé !

!!!! Comprendre les caméras !!!!

• Matériels :
  • Arduino Uno + câble USB de liaison Arduino/Ordinateur
  • Câbles de connexion
  • Module caméra Mini 5MP Plus OV5642

• Schéma de connexion :

•  Code : 
  • Essais avec énormément de codes différents, beaucoup de difficultés pour ce qui est de comprendre l'utilisation des différentes fonctions lié à la caméra.

#include <Wire.h>
#include <SPI.h>
#include <ArduCAM.h>
#include "memorysaver.h"

#if !(defined OV5642_MINI_5MP_PLUS)
  #error Please select the hardware platform and camera module in memorysaver.h
#endif

#define BMPIMAGEOFFSET 66

const int CS = 7;
bool is_header = false;
int mode = 0;
uint8_t start_capture = 0;

ArduCAM myCAM(OV5642, CS);

uint8_t read_fifo_burst(ArduCAM myCAM);

void setup() {
  uint8_t vid, pid;
  uint8_t temp;

  Wire.begin();
  Serial.begin(921600);

  Serial.println(F("ACK CMD ArduCAM Start! END"));

  pinMode(CS, OUTPUT);
  digitalWrite(CS, HIGH);

  SPI.begin();

  // Reset caméra
  myCAM.write_reg(0x07, 0x80);
  delay(100);
  myCAM.write_reg(0x07, 0x00);
  delay(100);

  // Test SPI
  while (1) {
    myCAM.write_reg(ARDUCHIP_TEST1, 0x55);
    temp = myCAM.read_reg(ARDUCHIP_TEST1);
    if (temp != 0x55) {
      Serial.println(F("ACK CMD SPI interface Error! END"));
      delay(1000);
    } else {
      Serial.println(F("ACK CMD SPI interface OK. END"));
      break;
    }
  }

  // Vérif caméra
  while (1) {
    myCAM.wrSensorReg16_8(0xff, 0x01);
    myCAM.rdSensorReg16_8(OV5642_CHIPID_HIGH, &vid);
    myCAM.rdSensorReg16_8(OV5642_CHIPID_LOW, &pid);

    if ((vid != 0x56) || (pid != 0x42)) {
      Serial.println(F("ACK CMD Can't find OV5642 module! END"));
      delay(1000);
    } else {
      Serial.println(F("ACK CMD OV5642 detected. END"));
      break;
    }
  }

  myCAM.set_format(JPEG);
  myCAM.InitCAM();
  myCAM.OV5642_set_JPEG_size(OV5642_320x240);

  delay(1000);

  myCAM.clear_fifo_flag();
}

void loop() {
  uint8_t temp;

  if (Serial.available()) {
    temp = Serial.read();

    switch (temp) {

      case 0x10:
        mode = 1;
        start_capture = 1;
        Serial.println(F("ACK CMD CAM start single shoot. END"));
        break;

      case 0x11:
        myCAM.set_format(JPEG);
        myCAM.InitCAM();
        break;

      default:
        break;
    }
  }

  if (mode == 1) {
    if (start_capture == 1) {
      myCAM.flush_fifo();
      myCAM.clear_fifo_flag();
      myCAM.start_capture();
      start_capture = 0;
    }

    if (myCAM.get_bit(ARDUCHIP_TRIG, CAP_DONE_MASK)) {
      Serial.println(F("ACK CMD CAM Capture Done. END"));
      read_fifo_burst(myCAM);
      myCAM.clear_fifo_flag();
    }
  }
}

// --- Version corrigée pour Host App ---
uint8_t read_fifo_burst(ArduCAM myCAM) {
  uint8_t temp = 0, temp_last = 0;
  uint32_t length = myCAM.read_fifo_length();

  if (length == 0 || length >= MAX_FIFO_SIZE) {
    Serial.println(F("ACK CMD Size error. END"));
    return 0;
  }

  myCAM.CS_LOW();
  myCAM.set_fifo_burst();

  temp = SPI.transfer(0x00);
  length--;

  while (length--) {
    temp_last = temp;
    temp = SPI.transfer(0x00);

    if (is_header) {
      Serial.write(temp);   // flux JPEG pur
    } else if ((temp == 0xD8) && (temp_last == 0xFF)) {
      is_header = true;
      Serial.write(temp_last);
      Serial.write(temp);  // début JPEG
    }

    if ((temp == 0xD9) && (temp_last == 0xFF)) break;  // fin JPEG
  }

  myCAM.CS_HIGH();
  is_header = false;

  return 1;
}

• • Voici ci-dessus le dernier code utilisé pour obtenir des photos et qui est lié avec l'ArduCam Host App.
  • Dernier test plutôt positifs avec l'ArduCam Host App mais toujours pas un succès...

D'après le logiciel on arrive à prendre des photos (ArduCam Host App --> photo ci-dessous)

Où sont les photos ? C'est le plus gros des problèmes, réussir a retrouver les photos et savoir si celle-ci se sont réellement enregistrées ou non, ou si plus généralement on arrive vraiment à prendre des photos.

Pour la prochaine séance --> résoudre le problème : où sont les photos ?!?

Objectif : se débarrasser du problème CAMÉRA !

https://www.arducam.com/camera-modules/5mp-ov5642/

Fab a du fil à retordre

Le code photo fonctionne, il est possible de prendre des photos.

Problèmes :

• Au bout d'un certain nombre de photos, il n'est plus possible d'en prendre (D'après Claude c'est un problème de FIFO où Host App/Arduino essaye de lire la photo avant qu'elle ne soit prise).
• Il faut trouver un moyen d'automatiser les photos pour un tour complet de coulommiers.
• Reste à savoir si fonctionne avec deux caméras.

Partie conception 3D : Révision du coulommiers

La première version du coulommiers avait un léger problème de dimension. Notamment avec ses 20 centimètres de haut. En réalité, le coulommiers ne nécessite que 4 centimètres de haut. Autre problème auquel faire face... 60 centimètre de diamètre sort du plateau d'impression de l'imprimante 3D. 

Ainsi le nouveau coulommiers ne fait "que" 4 centimètre de haut, est monté sur un un plateau support de 5 millimètres de diamètre permettant le roulement de la pièce arrière. La structure montante du coulommiers est creuse, permettant d'user de moins de plastique. Le coulommiers a été modélisé en quart, avec des pièces mâles femelle basales permettant un montage en puzzle. Ces structures sont ainsi disposées pour limiter un maximum au support moteur de rouler sur des failles. Cependant la partie mâle dépasse toujours du support d'impression. 

La pièce est encore à revoir. Durant cette révision, le plateau support sera retravaillé afin de limiter au mieux l'usage de plastique.

Photos multiples possible à rédiger

on re test moteur sur roue --> problemo

Re modélisation de certaines pièces

Aujpurd'hui nous avons essayé de monter les différrentes toutes ensembles. Plusieurs problemes se sont alors présentés à nous:

• Les puzzles ont des marges d'erreurs sur estimées. Il faudrait à l'avenir les repenser afin de faciliter le montage. Toutes les complémentarités sont à revoir, nonobstant, celle entre le socle moteur et la pièce arrière est primordiale. 
• La pièce arrière avait été pensée pour avoir une roue permettant de faire encoche avec le coulommiers, permettant alors de maintenir le tout sans branlements. Il faudrait donc, soit retirer la butte, soit redesigner la pièce dans son ensemble. 
• Le support moteur est à retravailler. Imaginer au départ comme nécessitant une pièce complémentaire pour être stable, il devra dorénavant obtenir une stabilité autonome. L'idée de sera d'ajouter des butes sur le bord distal au foyer du coulommiers. Plusieurs modèle de butes seront testés.
• Le coulommiers en lui même ne sera pas modifié, mais des explications supplémentaires quant à sa conception peuvent être ajoutées. Le principe du coulommiers est de permettre une rotation d'un bras photographique autour du support -substituant la rotation du support lui même-. Les dents sont sur la surface interne du coulommiers Pourquoi ? --> Pour permettre un ancrage par le rouage et une autre encoche à la surface opposée. L'idée de roue sur sur le coté haut du coulommiers a été proposée. Elle ne nous semble que peu adéquate au projet. En effet, elle poserait plus de problèmes, necessitant deux encoche, et un rougage circulaire a la citroen. IMPOSSIBLE.