📹 UE LU1SXARE - CURIOUS

Atelier de Recherche Encadré CURIOUS-Info

Contexte et objectifs de l'Atelier

Des recherches sont nécessaires pour répondre aux nombreuses questions posées sur les réponses des écosystèmes et espèces des fonds marins au changement climatique et aux impacts d’activités humaines.  Ces recherches font appel au développement de nouveaux outils d’observation in situ miniaturisés, autonomes et à coûts limités pour pouvoir être largement partagés. Des caméras et des capteurs intégrés à des caissons étanches permettent notamment d’étudier les fluctuations microclimatiques et de décrire comment les espèces font face aux évènements les plus extrêmes. Des dispositifs déployés lors d'expéditions récentes en grande profondeur sont transférés pour les milieux littoraux dans le cadre du projet de recherche participative MOOREV (CNRS-MITI et Fondation de France).

L'atelier de Recherche Encadré CURIOUS se déroule  sous forme projets dédiés à l’analyse d’images sous-marines acquises sur le littoral, ou au développement des méthodes d'acquisition pour les rendre plus accessibles. Les groupes de projet peuvent choisir d'explorer au FabLab les possibilités offertes par les technologies actuelles open source, notamment le pilotage de caméras reconditionnées par une interface de type Arduino nano ou ESP32 pour une autonomie de plusieurs jours à plusieurs semaines.  Les groupes de projet utiliseront différents logiciels pour calibrer et analyser des vidéos et photos sous-marines, construire une base de donnée de reconnaissance d’espèces, et élaborer des tutos pour permettre à d’autres utilisateurs de contribuer à ces recherches.

Projet -ScFo MOOREV_Timer-Camera

Objectif : Définition, évaluation et test d'une interface programmable et de l'alimentation pour l'acquisition de séquences photos et vidéo en autonome avec GoProHero3+ et LED Cree sur de longues durées (plusieurs semaines à mois) avec ESP32et/ou Arduino Nano.

Matériel fourni :

2 Arduino Nano 
1 GoPro HERO3+
Carte interface CamDo TTL004
BLINK CamDo Time Lapse Controller
1  Carte mesure SENSE0161 DFRobot avec electrode pH
3 LED CREE

Projet-ScFo MOOREV-Stéréovision_Calibration

Objectif : Etablir un protocole d'acquisition d'image sous-marines en stéréovision.
 Réalisation du banc de calibration pour deux caméras GoProHero3+  et tests pour application en imagerie sous-marine.

Matériel fourni :

2 GoPro HERO3+ reconditionnées 2022A et 2022B
2 caissons 30m pour essai dans l'eau au FabLab
1 Caisson GoBenthic GroupBinc avec Extension et Connecteur (pour mesures de taille, distance entre caméras)
Echiquier ou mire à fabriquer au FabLab

Projet-ScIn MOOREV-Stéréovision-Traitement_image

Objectif : Etablir un protocole d'analyse d'image en stéréovision pour application en imagerie sous-marine

Traitement des images avec correction de distorsion - voir GitHub UnderSea (PFE Master SPI-ISI)

Tests cartes et caméra Raspberry : comparaison de différentes stratégies (Raspberry-Pi avec traitement embarqué versus GoPro Hero3+ et traitement différé).

Matériel fourni :

2 GoPro HERO3+ reconditionnées 2022A et 2022B + exemple de vidéos in situ

Projet-ScIn MOOREV_ Trigger-Caméra Modulation Fréquence

INTRODUCTION

Le but de notre projet ARE est de déclencher une caméra Go Pro à l’aide d’une carte électronique Arduino dans le but de récolter des données. Les données qui seront les causes du déclenchement pourront être le pH de l’eau, la température etc. Cela appelle aussi à une adaptation de la caméra au milieu avec un processus d’éclairage la nuit, un potentiel processus de détection des espèces. Le cœur du sujet résidera donc dans le fait de déclencher la caméra sous l’action de certaines conditions nécessaires. Le dessein final serait de mettre le système dans des conditions réelles en milieu extérieur, ce pendant plusieurs jours, afin d’en observer les résultats.

Objectif : Intégration d'une carte mesures de pH + température et d'une Arduino pour la programmation du déclenchement  d'une caméra Go Pro autonome.

Il s'agit d'interfaçage de l'Arduino avec les cartes de mesures de pH SENSE0161 (ou ADCM355), avec enregistrement des mesures sur carte microSD, pour pouvoir réveiller  la caméra sur un seuil de mesure de température ou de pH.

Matériel fourni :

1 Arduino Nano
1 carte support microSD 
2  Cartes mesure SENSE0161 DFRobot avec electrodes pH
2 cartes mesures  ADUCM355 WATER QUALITY SENSOR (T°C + pH ou REDOX(ORP)
2 sondes T°C long. 30 cm - thermistance (Thermocoax)

Code pour déterminer la température

/*
 * Created by ArduinoGetStarted.com
 *
 * This example code is in the public domain
 *
 * Tutorial page: https://arduinogetstarted.com/tutorials/arduino-temperature-sensor
 */

#include <OneWire.h>
#include <DallasTemperature.h>

const int SENSOR_PIN = 13; // Arduino pin connected to DS18B20 sensor's DQ pin

OneWire oneWire(SENSOR_PIN);         // setup a oneWire instance
DallasTemperature tempSensor(&oneWire); // pass oneWire to DallasTemperature library

float tempCelsius;    // temperature in Celsius
float tempFahrenheit; // temperature in Fahrenheit

void setup()
{
  Serial.begin(9600); // initialize serial
  tempSensor.begin();    // initialize the sensor
}

void loop()
{
  tempSensor.requestTemperatures();             // send the command to get temperatures
  tempCelsius = tempSensor.getTempCByIndex(0);  // read temperature in Celsius
  tempFahrenheit = tempCelsius * 9 / 5 + 32; // convert Celsius to Fahrenheit

  Serial.print("Temperature: ");
  Serial.print(tempCelsius);    // print the temperature in Celsius
  Serial.print("°C");
  Serial.print("  ~  ");        // separator between Celsius and Fahrenheit
  Serial.print(tempFahrenheit); // print the temperature in Fahrenheit
  Serial.println("°F");

  delay(500);
}

Code de déclenchement de caméra

#include <OneWire.h>

// Définir la broche de données pour le capteur DS18B20
#define ONE_WIRE_BUS 2

// Initialiser l'objet OneWire
OneWire oneWire(ONE_WIRE_BUS);

void setup() {
  // Ouvrir une communication série à 9600 bauds
  Serial.begin(9600);
}

void loop() {
  // Initialiser le capteur
  byte addr[8];
  if (!oneWire.search(addr)) {
    // Si aucun capteur n'est détecté, attendre
    delay(1000);
    return;
  }

  // Vérifier que le capteur est bien un DS18B20
  if (addr[0] != 0x28) {
    // Si ce n'est pas un DS18B20, attendre
    delay(1000);
    return;
  }

  // Initialiser la communication avec le capteur
  oneWire.reset();
  oneWire.select(addr);
  oneWire.write(0x44); // Lancer la conversion de température

  // Attendre la fin de la conversion
  delay(1000);

  // Lire la température
  oneWire.reset();
  oneWire.select(addr);
  oneWire.write(0xBE); // Demander la lecture de la température
  byte data[9];
  for (byte i = 0; i < 9; i++) {
    data[i] = oneWire.read();
  }
  int temp_raw = (data[1] << 8) | data[0];
  float temp_celsius = (float) temp_raw / 16.0;

  // Afficher la température
  Serial.print("Température: ");
  Serial.print(temp_celsius);
  Serial.println(" °C");

  // Attendre avant de recommencer
  delay(1000);
}

Code pour avoir le pH

/*
 # This sample code is used to test the pH meter V1.0.
 # Editor : YouYou
 # Ver    : 1.0
 # Product: analog pH meter
 # SKU    : SEN0161
*/
#define SensorPin A0            //pH meter Analog output to Arduino Analog Input 0
#define Offset 0.00            //deviation compensate
#define LED 13
#define samplingInterval 20
#define printInterval 800
#define ArrayLenth  40    //times of collection
int pHArray[ArrayLenth];   //Store the average value of the sensor feedback
int pHArrayIndex=0;
void setup(void)
{
  pinMode(LED,OUTPUT);
  Serial.begin(9600);
  Serial.println("pH meter experiment!");    //Test the serial monitor
}
void loop(void)
{
  static unsigned long samplingTime = millis();
  static unsigned long printTime = millis();
  static float pHValue,voltage;
  if(millis()-samplingTime > samplingInterval)
  {
      pHArray[pHArrayIndex++]=analogRead(SensorPin);
      if(pHArrayIndex==ArrayLenth)pHArrayIndex=0;
      voltage = avergearray(pHArray, ArrayLenth)*5.0/1024;
      pHValue = 3.5*voltage+Offset;
      samplingTime=millis();
  }
  if(millis() - printTime > printInterval)   //Every 800 milliseconds, print a numerical, convert the state of the LED indicator
  {
    Serial.print("Voltage:");
        Serial.print(voltage,2);
        Serial.print("    pH value: ");
    Serial.println(pHValue,2);
        digitalWrite(LED,digitalRead(LED)^1);
        printTime=millis();
  }
}
double avergearray(int* arr, int number){
  int i;
  int max,min;
  double avg;
  long amount=0;
  if(number<=0){
    Serial.println("Error number for the array to avraging!/n");
    return 0;
  }
  if(number<5){   //less than 5, calculated directly statistics
    for(i=0;i<number;i++){
      amount+=arr[i];
    }
    avg = amount/number;
    return avg;
  }else{
    if(arr[0]<arr[1]){
      min = arr[0];max=arr[1];
    }
    else{
      min=arr[1];max=arr[0];
    }
    for(i=2;i<number;i++){
      if(arr[i]<min){
        amount+=min;        //arr<min
        min=arr[i];
      }else {
        if(arr[i]>max){
          amount+=max;    //arr>max
          max=arr[i];
        }else{
          amount+=arr[i]; //min<=arr<=max
        }
      }//if
    }//for
    avg = (double)amount/(number-2);
  }//if
  return avg;
}

Code de déclenchement avec pH

// Inclure la bibliothèque pour la communication série
#include <SoftwareSerial.h>

// Définir les broches de communication série
SoftwareSerial pHSerial(2, 3); // RX, TX

// Définir la broche de commande de la caméra
const int cameraPin = 4;

// Définir les constantes pour la calibration du capteur de pH
const float pH7Voltage = 2.5;
const float pH4Voltage = 1.98;
const float pH10Voltage = 3.07;

// Fonction pour convertir la tension en pH
float convertToPH(float voltage) {
  float pH = 7 - (voltage - pH7Voltage) / (pH7Voltage - pH4Voltage) * 3;
  return pH;
}

void setup() {
  // Ouvrir la communication série pour le débogage
  Serial.begin(9600);
  // Configurer la communication série pour le capteur de pH
  pHSerial.begin(9600);
  // Définir la broche de commande de la caméra en mode sortie
  pinMode(cameraPin, OUTPUT);
}

void loop() {
  // Lire la tension du capteur de pH
  pHSerial.write('R'); // Envoyer la commande pour lire la tension
  delay(1000); // Attendre la réponse
  while (pHSerial.available() < 4) {} // Attendre la réponse complète
  float voltage = (float)pHSerial.parseFloat() / 1000.0; // Convertir la réponse en voltage
  // Convertir la tension en pH
  float pH = convertToPH(voltage);
  // Afficher les résultats
  Serial.print("Voltage = ");
  Serial.print(voltage, 2);
  Serial.print(" V, pH = ");
  Serial.print(pH, 2);
  Serial.println();
  // Déclencher la caméra si le pH est inférieur à 7
  if (pH < 7) {
    digitalWrite(cameraPin, HIGH);
    delay(500);
    digitalWrite(cameraPin, LOW);
  }
  // Attendre une seconde avant de recommencer
  delay(1000);
}

⚠Les codes ci-dessus restent à tester, aucune manipulation n'a été faites (On n'a pas eu accès à notre boite ouin ouin 🥲🥲).


Mardi 11 Avril


Nous avons eu accès à notre boîte et avons put effectuer quelques manipulations.

Nous avons testé le code pour la mesure du pH que l'on à trouvé sur le wiki de dfrobot; à l'aide d'une sonde de pH, de notre carte Arduino Nano, d'un Mac et de quelques branchements.

1D3193BA-DB60-4173-9485-CAAFD5338D89.JPG:63A324D4-9473-4796-94C0-EBE80CA12DC8.JPG


Comme les images ci-dessus l'indique, le code a fonctionner et la sonde est en capacité de prélever le pH d'un liquide. ( L'eau étant prélevée du robinet il est normal que le pH ne soit pas exactement équivalent à 7, mais qu'il s'en approche)


Nous avons aussi testé le code de prélèvement de température écrit précédemment, le code semble bien fonctionné, on reçoit bien des valeurs de Température dans le Serial Monitor cependant les valeurs ne semblent pas cohérentes probablement  dût à un problème de conversion .


ED32A337-9236-4F4E-82E3-73069D604830.JPG

BIBLIOGRAPHIE

  1. Analog Input | Arduino Documentation. https://docs.arduino.cc/built-in-examples/analog/AnalogInput. Consulté le 30 mars 2023.

  2. analogRead() - Arduino Reference. https://www.arduino.cc/reference/en/language/functions/analog-io/analogread/. Consulté le 30 mars 2023.

  3. Nano | Arduino Documentation. https://docs.arduino.cc/hardware/nano. Consulté le 30 mars 2023.

  4. SPI - Arduino Reference. https://www.arduino.cc/reference/en/language/functions/communication/spi/. Consulté le 30 mars 2023.

  5. WiFi101 - Arduino Reference. https://www.arduino.cc/reference/en/libraries/wifi101/. Consulté le 30 mars 2023.

  6. « Arduino - Temperature Sensor | Arduino Tutorial ». Arduino Getting Started, https://arduinogetstarted.com/tutorials/arduino-temperature-sensor. Consulté le 30 mars 2023.

  7. DS18B20 Temperature Sensor For Arduino - DFRobot Wiki. https://wiki.dfrobot.com/Gravity__DS18B20_Temperature_Sensor__Arduino_Compatible__V2_SKU__DFR0024. Consulté le 30 mars 2023.

  8. SKU SEN0161 PH Meter. https://wiki.dfrobot.com/PH_meter_SKU__SEN0161_. Consulté le 7 avril 2023.

Projet-ScIn_MOOREV-Espèces-annotation

Objectif : Réaliser un tutoriel pour la construction d'une banque d'images sous-marines pour la reconnaissance d'espèces communes des habitats littoraux de Atlantique.

Comparaison des images extraites des séries acquises par le projet MOOREV avec les bases de données biodiversité. Tests des logiciels d'annotation d'images (Roboflow ou autres logiciels Open Source).

Le projet de recherches participatives MOOREV

Le projet MOOREV-Microclimats et nouveau Outils d’Observation des Réponses du Vivant sur les fonds marins est soutenu par la Mission Interdisciplinaire et des Initiatives Transverses du CNRS et également par la Fondation de France.

Le projet s’inspire d'instruments développés pour les recherches sur les fonds marins en grande profondeur pour construire des instruments pouvant être utilisés par un plus large public. Notre objectif est de permettre la co-conception et l’appropriation de modules d'observation miniaturisés et autonomes, dans un cadre de recherches participatives, pour partager les connaissances sur le rôle d'espèces constructrices d'habitats et la sensibilité aux perturbations climatiques.

L’intégration de caméras et de capteurs et l’adaptation de méthodes d’analyse d’image et des outils de l’IA sont développées avec le FabLab SU dans le cadre des Ateliers de Recherche Encadrés CURIOUS (Licence 1 Sorbonne Université).
Le déploiement des équipements sur le terrain, puis l’analyse des données acquises, participent aux supports pédagogiques développés à la Station Marine de Concarneau dans le cadre des ateliers des Aires Marines Educatives animés par Esprit Nat'ure.

Documentation MOOREV-Timer-Camera ScFo

Information:

Groupe de projet: L1 - Science Formelles Maths-Info - (février - avril 2023)

- CHU Amélie amelie.chu@etu.sorbonne-universite.fr

- SAE LIM Thierry thierry.sae_lim@etu.sorbonne-universite.fr

- PERRIN DE BRICHAMBAUT Jules jules.perrin_de_brichambaut@etu.sorbonne-universite.fr

Contexte:

Dans le cadre de notre projet d'ARE, nous nous focalisons sur la récolte de données images et vidéos d'espèces marines à l'aide de caméras et de capteurs. 

Objectif:

Notre objectif est de concevoir un système autonome qui permet d'enregistrer ces données en profondeur sur une longue durée (plusieurs semaines à plusieurs mois), à faible coût et à faible consommation d'énergie. 

Le but de ce tuto est de mettre en place un système autonome sous marin qui permet de prendre des données photos et vidéos d’espèces aquatiques sur une durée déterminée. Notre objectif est donc de finaliser un prototype peu coûteux et ayant une consommation d’énergie minimale.

Matériel:

- GoPro Hero 3+S

- Adafruit ESP32 Feather [0]

- Arduino NANO

- Breadboard

- connecteur arrière de la caméra (connecteur herobus) modèle DD1P030MA1

- Carte SD 64 Go (ou 32 Go)

- ESP32-Cam

- Multimètre (modèle utilisé TENMA 72-14620)

Le tuto se découpera en plusieurs parties:

  1. IDE et programmation des microcontrôleurs
  2. Réalisation de tests de consommations
  3. Script de la GoPro
  4. Assemblage du prototype
  5. Alternative: ESP32-Cam
  6. Références

Machines utilisées:

- fer à souder

 

1.TUTO:  IDE et programmation des microcontrôleurs

Etape 1 :

On installe tout d’abord l’IDE Arduino (Integrated Development Environment) pour pouvoir programmer les scripts des deux cartes: https://www.arduino.cc/en/software [1] (lien pour le téléchargement).

image-1684429458385.png

Interface du logiciel en question

Une fois téléchargé, lancez l’application. En haut à gauche, choisir le microcontrôleur adapté (dans notre cas, il s’agit d’un Adrafruit ESP32 Feather, d’un ESP32-CAM ou d’un Arduino Nano). Sur la gauche, cliquer sur la deuxième icône ‘BOARDS MANAGER’ et rechercher ‘esp32’. Installer la plus récente version de la librairie ‘esp32’ par Expressif Systems. Cela permettra d’avoir la gestion pour programmer les ESP32.

Etape 2:

Nous allons maintenant écrire les scripts pour les deux cartes. Notre script va simuler une séquence où la carte allume une LED toutes les minutes pendant 5 secondes.

Le lien vers notre GitHub contient les scripts des deux cartes dans les deux fichiers ESP32 et Arduino [2] :

https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera [3]

Pour transmettre les fichiers, relier la carte à l’ordinateur, sélectionner le port COM de la carte, et cliquer en haut à gauche sur le bouton flèche ‘upload’. Pour chaque modification du script, il faudra réitérer cette opération.

 

 
2.TUTO: Réalisation de tests de consommations

On réalise maintenant les tests de consommations. Pour cela, nous allons utiliser le multimètre. Nous souhaitons récolter les données.


Etape 1: installation du logiciel

En fonction du multimètre utilisé, la fonctionnalité peut ne pas être disponible. Il faudra alors noter manuellement les données. Dans le cas contraire, installer le logiciel associé. Dans notre cas avec ce modèle, installer le logiciel à l’aide du CD fourni avec le manuel d’utilisation. Lancer le logiciel puis brancher l’ordinateur au multimètre.

Modèle du multimètre utilisé dans notre cas : TENMA 72-14620

- Installer sur l’ordinateur le modèle du multimètre correspondant au modèle

- Connecter l’ordinateur et l’appareil grâce au câble fourni avec l‘appareil

- Régler le logiciel sur la connexion via USB, l’enregistrement est prêt à démarrer avec le bouton «Démarrer».

- Différentes options sont disponibles une fois l'enregistrement terminé: enregistrer les données dans un fichier ou les imprimer.

image-1684429581795.png

Inteface du logiciel

Etape 2: Branchement

Nous allons réaliser un branchement pour alimenter les cartes et mesurer les consommations. On enfiche les cartes sur une breadboard, puis on les alimente avec un générateur réglé sur 5V. On n’oublie pas le multimètre dans le branchement.

On alimente les cartes et on récolte les données sur une durée de 3 séquences, soit environ 3 minutes afin d’avoir une moyenne à la fin. On enregistre le fichier sous forme Excel (ou autre format).

Afin de d’alimenter les cartes pour réaliser les mesures de l’intensité utilisé, on connecte une source en +5V sur le pin 5V et la masse sur le pin GND de l’arduino Nano [4].

Pour l’ESP32 (avec une carte Adafruit HUZZAH32 - ESP32 Feather), connecter la broche USB au 5V et la masse à la broche GND [5].

Ne pas oublier de brancher le multimètre en série du microcontrôleur et de ne pas utiliser le port USB des cartes arduino ou ESP32 lors des mesures (sous risques d'endommager l'appareil branché en USB) !

                                                 arduinof.jpg   branchement.jpg

Branchements et circuit réalisés

On récolte les données de consommation pour les deux cartes à l'aide du logiciel sur ordinateur.

 

Etape 3: analyse des données

Nous analysons ensuite les données en utilisant les bibliothèques python Pandas et Matplotlib avec Python. 

Pour pouvoir exploiter le fichier Excel sous Python, il ne faut pas oublier de remplacer les «,»

 par des «.».

Le fichier qui nous a permis de faire le graphique est disponible sur le GitHub sous le nom de «plot_conso» [3].

graphe.png

On observe que l'Arduino Nano consomme moins que l'ESP32. Les pics de chaque lignes correspondent à l'allumage de la LED de chaque carte, et l'espace entre chaque pic correspond au mode veille. L'Arduino semble le mieux adapté en terme de consommation.


 Arduino
 ESP32
mean 6.1727 mA 10.5101 mA
standard deviation 4.6997
 11.8473 
total time 5.0 min 18.0 s 5.0 min 0.0 s
total time consumption

2981.44 mA

 4792.6 mA
average consumption 22.2219 mW/h 37.8363 mW/h

 

Etape 4: soudure des fils

Nous avons choisi de contrôler la caméra via le connecteur arrière [6] qui permet d’avoir accès à une grande partie des fonctionnalités. Pour utiliser notre connecteur, il nous faut souder des fils dessus.



image-1684430450355.jpg             image-1684430506024.jpg

Les 30 fils de couleurs différentes     Les pins du connecteur

afin que l’on puisse distinguer les pins

adjacentes 

 

Nous allons souder les 30 pins. Il est possible pour plus de facilité de ne souder que les pins concernés, mais le tuto se reposera sur les 30 pins [7]. 

- Couper et dénuder 30 fils

- Chauffer les fers à souder à 350° (pas trop sinon l’étain fond mal)

- Prendre le fer à souder et plaquer fermement le fil au pin, puis approcher l’étain pour le faire fondre grâce au flux.

 

   soudage.jpg

Brasure de deux pins adjacentes

 

3.TUTO: Script de la GoPro

La GoPro Hero 3+S a pour avantage de pouvoir lancer un script présent sur la carte SD dès son allumage. Nous allons configurer la caméra et écrire le script.

GoPro.jpg

Etape 1: 

Allumer la caméra et se rendre dans les paramètres. Chercher l’option «One Button» et la configurer sur OFF. 

Configurer au passage la résolution souhaitée pour les photos et vidéos

Etape 2:

Pour le script de la GoPro, il faut enregistrer le fichier sous extension “.ash” . Il est disponible sur notre  GitHub [4]. Le script que nous avons écrit permet de prendre une vidéo et trois photos avant de redémarrer. Disposer de ce script dans la racine de la carte SD/créer un dossier AUTOEXEC qui contiendra le fichier [8]. Enregistrer le fichier sous le nom «autoexec.ash»

Commandes

Utilisation

sleep x

Rendre la caméra inactive pendant x secondes. Temps d’attente

t app appmode video

Passage en mode vidéo de la caméra

t app appmode photo

Passage en mode photo

t app button shutter PR

Enclenchement du bouton déclencheur pour prendre une photo, prendre une vidéo/arrêter une vidéo

Il est intéressant de programmer les séquences en tenant en compte de la batterie et de la capacité de stockage de la carte SD. Pour la GoPro Hero3+S, nous disposons de 64G et d’une batterie d’environ 10 000A. En prenant en compte la taille d’une photo (12MPX) et d’une seconde de vidéo (en 1080p), on peut calculer combien de temps peut tenir notre prototype.

Taille en ko 1 photo  vidéo (1 sec)
GoPro Hero 3+S 4000 5000

On calcule ainsi par approximation le nombre de jour que nous pouvons tenir sous l’eau tout en enregistrant des données avec la formule:

(Capacité de la carte SD) / ( (nombre de photos par jour)*(taille d’une photo) + (temps de vidéo en seconde par jour)*(taille d’une seconde de vidéo) )

Le calcul peut se faire sur une durée d’un mois ou bien d’un an.

Par exemple, pour 10 secondes de vidéos et 24 photos par jour, cela nous fait:

64000000/(24*40000 + 10*5000) = 438,36 soit environ 438 jours, équivalent à environ 14 mois.

Il est aussi possible de calculer la durée en fonction de la consommation de la caméra [9].

 

4.TUTO: Assemblage du prototype

Maintenant que nous disposons de tous les éléments dont nous avons besoin, nous pouvons brancher le tout. On branche à l’Arduino NANO sur le pin A0 et le pin GND aux pins de la masse et du bouton d’alimentation (respectivement le pin 30 et le pin 19) [10].

Grâce au programme écrit pour l’Arduino NANO, nous avons programmé des séquences d’allumage de la caméra. Nous avons maintenant une caméra qui prend trois photos toutes les 30 secondes dix fois de suite.

branchementfinal.jpg 

Montage de la Gopro relié à l'Arduino Nano

 

5. Alternative: ESP32-Cam

esp32cam.jpg

         ESP32-Cam

Pour utiliser une carte SD avec un ESP32-CAM, il est nécessaire de la formater en FAT32 (Attention, même si la carte SD fait plus de 4Go, l’ESP32-CAM ne sait pas gérer plus avec le port intégré)

Programmation d’une séquence de test pour l’ESP32-CAM : 

-    Connexion de l’ESP32-CAM avec une cable usb-ttl à l’ordinateur :

o    Broche rx sur u0t

o    Broche tx sur u0r

o    GND sur GND

o    5v sur 5v

o    Relier les broches IO0 et GND

Dans le menu de sélection de la carte, choisir la carte “AI-Thinker ESP32-CAM” et le port COM sur lequel est connecté l’ESP32.

Récupérer le code disponible pour prendre une photo:

https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera/blob/main/ESP32/ESP32_CAM_test_photo/ESP32_CAM_test_photo.ino 

ou un équivalent de vidéo, en réalité plusieurs photos par secondes:

https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera/blob/main/ESP32/ESP32_CAM_test_video/ESP32_CAM_test_video.ino 


Après cela, il ne reste plus qu’à téléverser le code sur l’ESP32-CAM, si la connexion ne s’effectue pas directement, appuyer sur le bouton de reset du microcontrôleur.

Afin d’afficher les messages envoyées par la carte en débug, ouvrir la console série intégrée de l’IDE et choisir une vitesse de transfert de 115200. 


Le code pour photo réalise une photo à chaque allumage ou redémarrage de la carte et celui-ci pour la “vidéo” prend 10 images par secondes dans la configuration actuelle jusqu’au débranchement de la carte.

Pour comprendre plus en détail le fonctionnement des scripts, je vous conseille l’article sur l’ESP32-CAM en référence  [11]. 

6. Références:

Référence de l’ESP32:

[0] https://www.adafruit.com/product/3405

Téléchargement de l’IDE:

[1] https://www.arduino.cc/en/software

Référence sur les modes de l’ESP32 pour le code:

[2] https://letmeknow.fr/fr/blog/142-tutoriel-les-sleep-modes-de-lesp32

Lien vers notre GitHub:

[3] https://github.com/ursusnocte/ARE_Curious_Info-Moorev-Timer-Camera 

Lien pour alimentation de l’Arduino:

[4]https://idehack.com/alimenter-larduino-nano/

Lien pour branchement ESP32:

[5] https://learn.adafruit.com/adafruit-huzzah32-esp32-feather/power-management

Lien vers le modèle du connecteur Herobus:

[6] https://www.digikey.fr/en/products/detail/jae-electronics/DD1P030MA1/1283154

Lien vers les descriptions des pins du connecteur arrière de la caméra:

[7] https://mewpro.cc/en/2014/10/14/herobus-pinout-of-gopro-hero-3-black/

Référence autoexec scripts:

[8] https://github.com/KonradIT/autoexechack

Lien vers les informations concernant le connecteur herobus:

[10] https://github.com/KonradIT/gopro-herobus-sdk/blob/master/diyprojects.md

Lien vers le site de Camdo sur la batterie des caméras:

[9] https://cam-do.com/pages/power-consumption-by-gopro-camera-model

Lien vers l’article sur l’ESP32-Cam :

[11] https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/

Journal de bord MOOREV-Timer-Camera ScFo

Journal de bord:

06/03:

- Pour notre système il faut que l'on choisisse entre l'Arduino NANO et l'ESP32 en se basant sur leur consommation en énergie. Il faut que l'on puisse mesurer la consommation en énergie sur différentes séquences et différentes durée. 

09/03: [séance Fablab]

- Durant la séance nous avons discuté du projet et en quoi le Fablab peut nous aider. Réflexion sur les tests et les protocoles à réaliser pour la consommation de la batterie avec les deux cartes, avec recherches sur la mise en veille des cartes. Recherches sur les aspects de la GoPro Hero3+ et comment la manipuler avec un programme implanté. Réflexion sur les durées et les séquences d'enregistrements pour la caméra.

- Visite de l'atelier Fablab partie électronique, avec présentation du matériel mis à disposition. Préparation du matériel pour la prochaine séance au Fablab.


10/03: [séance Fablab]

- Point et vu d'ensemble sur tout le matériel que nous possédons.

- Point sur la façon de relier le micro processeur à la GoPro. Recherches sur le port Hero de la GoPro Hero 3+ qui nous permet de conclure sur l'utilisation du port Hero pour contrôler de manière filaire la caméra. Recherche de références afin de pouvoir trouver et se procurer un branchement compatible au port Hero.

Liens:

Autre possibilité pensée de connecter la GoPro qui nécessite la modification de la caméra (idée mise de côté):

https://hackaday.io/project/12108-gopro-hero-4-wired-control

https://www.youtube.com/watch?v=mpPfk4sLb3I

Informations sur le port Hero Bus de la GoPro Hero:

https://wiki.logre.eu/index.php/GObotPRO

17/03: [séance Fablab]

- Réunion afin de préparer les tests de consommation d'énergie entre l'Arduino Nano et l'ESP32. Acquisition du matériel nécessaire, et codage des cartes.

- Tests (code) du nombre de cycles par minutes possible sur l'Arduino qui va permettre d'allumer et d'éteindre la caméra.

- Emprunt d'un ESP32 qu'on a du souder au labo électronique.

- Création d'une page GitHub afin de déposer notre code et recherches sur le mode hibernation de l'esp32 ainsi que la façon de récupérer les données d'un multimètre sur l'ordinateur afin d'enregistrer les données.

24/03: [séance Fablab]

- Prise de mesures des consommations.

- Programmation de l'ESP32 en mode basse consommation, mise à disposition du code sur Github. Réalisation d'un montage sur planche de prototypage pour mesurer la consommation des microcontrôleurs avec un multimètre. 

(Lien vers le GitHub)

- Téléchargement d'un logiciel lié au multimètre afin de le connecter à ce dernier pour récolter en temps réel les données mesurées. 

- Réalisation des tableaux Excel avec les résultats.

31/03: [Séance Fablab]

- Réception du matériel nécessaire (ESP32-CAM et port Hero) pour connecter le microcontrôleur à la GoPro.

- On procède ensuite à la soudure de fils sur le port de chaque pins afin de pouvoir accéder aux pins

- Réflexion sur la programmation de l'ESP32-Cam

- Calcul sur tableau Excel des différentes séquences possible en prenant en compte la capacité de stockage de la carte SD et de la taille d'une vidéo/photo.

Tableau de séquence dans le répertoire GitHub: Lien vers le GitHub

04/04: [Séance Fablab]

- Continuation de la soudure des pins sur le connecteur

- Programmation de l'ESP32 Cam et test des photos. Mesure de leur capacité de stockage photos et vidéos. Rencontre d'un problème: ESP32 cam -> focal fixe par défaut avec le capteur OV2640, à remplacer par un autre capteur plus adapté (lien vers le capteur). 

- Test des pins du connecteur et confirmations des ports (port 19 pour allumage de la caméra). Test lancer un script sur carte SD en allumant la GoPro. 

07/04: [Séance Fablab]

- Nous avons constaté que la soudure n'a pas tenue et que des broches ont été cassé lors de la manipulation. Nous réfléchissons donc à un autre moyen de souder des fils moins rigides, ou bien à une alternative.

- Le but de la séance était d'allumer la GoPro à l'aide de l'arduino et du port Hero, et de vérifier que le script se lançait à l'allumage de la caméra. Nous rencontrons toutefois un problème concernant la lecture du script, que la caméra ne détecte pas. 

14/04: [Séance Fablab]

-Tests du fonctionnement du script sur la GoPro. Préparation de la présentation à l'oral et des comptes rendus concernant l'UE.

Le script lancé est disponible sur le répertoire GitHub sous le nom de 'autoexec.ash'.

(Lien vers le GitHub) 

(Une fois que nous pouvons connecter l'Arduino à la GoPro, nous devons nous assurer que la GoPro lit bien le script présent sur la carte SD dès l'allumage. Pour cela, nous allons déposer dans la racine de la carte un fichier sous le nom de 'autoexec.ash' et qui contient les instructions.  )

18/04: [Séance Fablab]

Dernière séance avant le rendu des travaux. Nous avons testé une dernière fois le lancement du script sur la GoPro en branchant le tout sur l'Arduino. Nous avons fait face à quelques problème au niveau des branchements qui n'allumait pas la caméra. Le problème a été résolu à la fin grâce à l'aide d'un chercheur présent au Fablab.

Le prototype fonctionne, il ne reste qu'a programmer la bonne séquence sur le script de la GoPro.

Journal de bord MOOREV-Stéréovision_Calibration

Journal de bord:

Vendredi 7 avril:

-On a imprimer préalablement des échiquier pour la calibration.

-On a utiliser les 2 Gopros Heroes 3+ pour prendre des photos.

-On a placé les caméras et l'échiquier à une distance de 20cm

image-1680882422696.jpeg

-On a pris des photos de l'échiquier dans plusieurs angles.

-On les a trier et séparer par photo droite et gauche,

image-1680882237015.pngimage-1680882252619.png

-On a calibré les photos grâce a l'application "Stereo Camera Calibrator" de MatLab

Capture d’écran 2023-04-09 à 16.55.30.png

Mardi 11 avril:

-On refait de la calibration, on réduit la marge d'erreur de la reprojection pour être environ en dessous de 10 pixelCapture d’écran 2023-04-11 à 16.32.46.pngIMG_4527.JPG