Intervallomètre photo
Deux séquenceurs (intervallomètres) photo pour Canon EOS.
Avec Arduino .
Et comment réaliser un film .avi avec les clichés.
Et comment réaliser un film .avi avec une Webcam !
Utilisation de la pose "B"
Si vous avez un Canon EOS, vous remarquerez qu'il existe sur le coté de l'appareil, une prise jack stéréo femelle en 2,5 mm de diamètre.
Cette prise permet de relier une télécommande.
Rien de plus simple, deux poussoirs furtifs , un jack de 2,5mm stéréo et une longueur de câble avec soit deux fils et une masse, soit 3 fils.Et un petit boîtier plastique pour contenir les deux poussoirs furtifs. Ce petit boîtier permet avec un trépieds de faire de la longue pose en réalisant un seul cliché. Simple, facile et peu onéreux !
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet."
Si vous allez sur Youtube vous trouverez une vidéo réalisée par un astronome amateur.
De la magie, de la beauté à l'état pur !
https://www.youtube.com/watch?v=AhEOLBXf6hE
Pour moins de 50 euros vous avez une télécommande de professionnel. Mais comme je suis aussi radio-amateur (F5NDL), j'ai un stock de composants qui dorment. Une carte Arduino ou un clone , un optocoupleur, une résistance 1/4 de watt, une diode, une diode électro-luminescente et une plaquette d'essais permettent de réaliser ce montage d'essais.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet."
Premier intervallomètre, pour ce faire la main !
Le même plan sur mini plaquette d'essais.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Voici le montage que j'utilise, avec un bloc d'alimentation 230 Vac/5Vdc, et une grande rallonge 230 volts pour aller au fond du jardin !
Mais en pleine campagne, un bloc 12Vdc/5Vdc pour voiture,sur la prise "allume-cigare"cela fonctionne aussi !
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Voici le montage que j'utilise, avec un bloc d'alimentation 230 Vac/5Vdc, et une grande rallonge 230 volts pour aller au fond du jardin !
Mais en pleine campagne, un bloc 12Vdc/5Vdc pour voiture,sur la prise "allume-cigare"cela fonctionne aussi !
Avec la carte Arduino, nous allons commander une sortie data pour piloter une diode électroluminescente , une LED. Dans la même ligne , en série, la diode de l’optocoupleur. La résistance est obligatoire, pour limiter l'intensité du circuit de pilotage du TIL111 ou du CNX35. Chaque fois que notre diode sera allumé, notre transistor de sortie sera passant. Le transistor se comportera comme un interrupteur! Donc nous avons une isolation parfaite entre la commande et l'appareil photographique.
Le TIL111 est piloté par la carte Arduino.
L'éditeur de programme pour les cartes Arduino se trouve à :
https://www.arduino.cc/en/main/software
Le programme :
Une ligne de déclaration pour indiquer que la ligne 8 sera active
void setup() {
pinMode(8, OUTPUT);
Dans la boucle : } void loop() { la ligne 8 est mise à l’état haut pendant 14000 millisecondes, donc 14 secondes !
digitalWrite(8, HIGH); delay(14000);
En pose B sur l’appareil photographique.
Et donc dans notre montage le TIL 111 est actif, le phototransistor est passant, l’appareil photographique voit un contact fermé, l’obturateur s’ouvre pendant 14 secondes. Nous sommes de nuit dans un coin bien sombre, et théoriquement sans pollution lumineuse ! ( Il est permis de rêver quand même!) Nous sommes toujours dans la boucle et les 14 secondes ce sont écoulés, le programme passe à la ligne suivante.
Nous passons « LOW » L’état bas ! « le tabac c’est pas bon !» , désolé, j’ai craqué !
Donc la diode n’est plus alimentée, le transistor du TIL11 se bloque, l’obturateur se ferme !
digitalWrite(8, LOW); delay(1000); }
Et là, la boucle reprend !
Donc le programme Arduino !
////////////////////////////////////////////////////////////////////////////////
// début du programme
// LED connectée à la broche numérique n° 13/
int ledPin = 13;
void setup()
{
pinMode(ledPin, OUTPUT); // mettre la broche 13 en mode SORTIE
}
// lancement de la boucle
void loop() {
digitalWrite(8, HIGH); // mettre la broche 13 en mode SORTIE HAUT la diode s allume
delay(14000); // compter 14 000 millisecondes soit 14 secondes
digitalWrite(8, LOW); // mettre la broche 13 en mode SORTIE BAS la diode est éteinte
delay(1000); // compter 1000 millisecondes soit une seconde
} // reprendre le début de la boucle
// fin de programme
/////////////////////////////////////////////////////////////////////////
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Voilà nous avons la base pour un intervallometre! Ensuite nous pourrions envisager par le biais de différents contacts sur les autres entrées de modifier le temps. Mais cela suppose de déclarer les autres entrées, et un allongement du programme ! C'est le modèle présenté au chapitre suivant. En l’état, nous avons un montage d’une simplicité enfantine et qui fonctionne comme une clepsydre Helvète qui fait coucou!
Jamais en panne !
Et voilà un essais sur les nuages!
https://www.youtube.com/watch?v=hE_uFYpcAzw
Second intervallomètre
Quand on souhaite faire un film image par image, de minuit à quatre heure du matin, On utilise la pose"B" et un temps d'exposition relativement long, en fonction du résultat désiré.
Mais si à 16h30 le lendemain, un ciel est joliment bouleversé par un passage de nuages, il faut téléverser avec l'éditeur "Arduino" le programme avec une correction de temps qui peut-être alors du genre, 14,7 seconde d'attente, et 0,3 seconde de commande, soit une image toutes les quinze secondes.
Pour éviter les manipulations :
- corrections de lignes de programme.
- rechargement.
la solution est d'avoir un choix de temps plus vaste.
Le second montage permet d'avoir un outil polyvalent dans son sac photo, sans être obligé de repasser par la case programmation.
Les deux organes principaux, Arduino, qui commande, et un optocoupleur, pour isoler notre appareil photographique de la commande. Cela se nomme "isolation galvanique complète".
Nous pourrions utiliser un relais, mais la mécanique avec les basses températures de nuit et l'humidité pendant les observations, j'ai des craintes. L’optocoupleur, étanche présente une faible consommation électrique et une isolation galvanique. Il est d'un prix dérisoire ! Que du bonheur pour un bricoleur dans mon genre!
Je ne vais pas détailler le programme, mais il y a sept solutions pour la temporisation. Avec l'éditeur Arduino, vous pouvez modifier les temps.
Le nouveau programme.
/////////////////////////////////////////////////////////////////////////////////////
/////////////// DÉBUT DE PROGRAMME ///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// Programme écrit par Jean-Pierre Lainé
// jpierrel85@gmail.com
//////////////////////////////////////////////////
//// Programme corrigé par"Le Tigre" ////
//// Un million de mercis au "Tigre" ////
///////////////////////////////////////////////////
//
// Programme pour piloter un séquenceur photographique
// Pour Canon EOS60D ou tout appareil photographique avec télécommande par fermeture de contact
// Pour EOS60D le contact est entre l’âme du jack stéréo et la masse.
// Ce programme est libre.
// Vous pouvez modifier le programme, ( vous le devez si nécessaire!)
// Vous pouvez l'utiliser librement, dans les limites des lois de votre pays.
const int ChxVitObtEtPause=0; // constante état du BP - appui sur niveau bas
// const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut
const int BPA=3; // declaration constante de broche 3 vitesse à définir
const int BPB=4; // declaration constante de broche 4 vitesse à définir
const int BPC=5; // declaration constante de broche 5 vitesse à définir
const int BPD=6; // declaration constante de broche 6 vitesse à définir
const int BPE=7; // declaration constante de broche 7 vitesse à définir
const int BPF=8; // declaration constante de broche 8 vitesse à définir
const int BPG=9; // declaration constante de broche 9 vitesse à définir
const int LedDeCommande=13; // declaration sortie de commande pour MOC
const int LedDAlarme=12; // declaration sortie de commande pour MOC
int ETAT_BP1; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP2; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP3; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP4; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP5; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP6; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP7; // lit l'état du BP et met la valeur 0/1 dans la variable
void setup() // initialisation
{
pinMode(LedDeCommande,OUTPUT); // broche de commande du MOC
pinMode(LedDAlarme,OUTPUT); // broche de commande du MOC
pinMode(BPA,INPUT); // broche d'entrée commande du 1er interupteur
pinMode(BPB,INPUT); // broche d'entrée commande du 2eme interupteur
pinMode(BPC,INPUT); // broche d'entrée commande du 3eme interupteur
pinMode(BPD,INPUT); // broche d'entrée commande du 4eme interupteur
pinMode(BPE,INPUT); // broche d'entrée commande du 5eme interupteur
pinMode(BPF,INPUT); // broche d'entrée commande du 6eme interupteur
pinMode(BPG,INPUT); // broche d'entrée commande du 7eme interupteur
}
void loop()
{ //installation d'une boucle
ETAT_BP1=digitalRead(BPA); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP2=digitalRead(BPB); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP3=digitalRead(BPC); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP4=digitalRead(BPD); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP5=digitalRead(BPE); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP6=digitalRead(BPF); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP7=digitalRead(BPG); // lit l'état du BP et met la valeur 0/1 dans la variable
/////////////////////////////////////////////////////////////////////////////////////
if (ETAT_BP1==ChxVitObtEtPause)
{ // si l'état du BP1 est appuyé (càd si variable état BP1 = 0)
// pause de nuit 30 secondes
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(25000); // pendant 30 secondes
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(5000); // pendant 30 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP2==ChxVitObtEtPause)
{ // si l'état du BP2 est appuyé (càd si variable état BP2 = 0)
// // pause de nuit 15 secondes
// pause de nuit 15 secondes
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(14500); // pendant 14,5 secondes
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(500); // pendant 0.5 seconde
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP3==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP3 = 0)
// // pause de jour 5 secondes
// 5 secondes entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(4700); // pendant 4.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP4==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP4 = 0)
// // pause de jour 15 secondes
// 15 secondes entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(14700); // pendant 14.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP5==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP5 = 0)
// // pause de jour 10 minutes
// 10 minutes entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(59700); // pendant 14.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP6==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP6 = 0)
// // pause de jour 1 heure
// 1 heure entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(3599700); // pendant 3599.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP7==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP6 = 0)
// // pause de jour 1 cliché par 24 heures
// 1 heure entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(86399700); // pendant 24 heures
}
/////////////////////////////////////////////////////////////////////////////////////
else
digitalWrite(LedDAlarme, HIGH); // allume la LED alarme
delay(200); // pause 0.2 seconde
digitalWrite(LedDAlarme, LOW); // éteint la LED alarme
delay(500); // pause 1 seconde
// si tous les inter à 0 = diode alarme
// }
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////// FIN DE PROGRAMME ///////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
Le montage électronique, Il s'articule sur deux pivots:
- l'arduino qui boucle en permanence le programme, et qui donne les ordres et interprètes les informations.
- l'optocoupleur qui commande l'appareil photographique.
- Et ici dans ce montage, Arduino interroge en permanence un commutateur. Par le biais d'un commutateur, le microcontrôleur va faire fonctionner une des sept boucles.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Le montage, globalement, nous sommes presque sur du copié/collé. Mais pour éviter l'effet rebond pendant le mouvement du commutateur, chaque entrée est équipée d'un condensateur, les résistances sont nécessaires pour présenter du 5 volts sur l'entrée quand le commutateur est ouvert, nous fonctionnons en logique inversée! Quand nous fermons le contact l'entrée est au potentiel de la masse, Arduino détecte le niveau "0" est appel la boucle correspondante dans le programme.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Le montage est réalisé sur une plaque d'essais.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Le montage sans le commutateur pendant les essais ! Le montage est alimenté par le câble USB.
Là, la diode verte indique que la commande de l'obturateur est active.
Si l'obturateur n'est pas commandé ! Croisez les fils qui vont à l'EOS60D ! Broche 4 & 5 du TIL111 vu de dessus en partant du point dans le sens anti-horaire.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
L'Alimentation électrique.
Pour prendre des photographies dans le but de faire un film au fin fond de la campagne, loin de la pollution lumineuse, il faut une alimentation autonome.
Mais pour alimenter en campagne l'intervallomètre et l'appareil photographique, EOS60D, il faut en réalité, deux alimentations !
Une alimentation électrique en huit volts, sous trois ampères, ( 8 Vdc / 3 A ) , pour l'EOS60D, et une autre alimentation électrique en cinq volts, pour alimenter l'Arduino.
Il est indispensable d'avoir une batterie de douze volts auto, bien chargée. Batterie qui ne sera pas celle de la voiture! Rentrer à pieds aux pâles aurores, après une nuit de veille, parce que la batterie de la voiture est à plat, n'est pas un exercice amusant.
Voici le plan d'une alimentation en huit et cinq volts. Afin d'éviter une erreur accidentelle de raccordement à la batterie, un pont de diodes assure la sécurité en garantissant au montage une tension correctement polarisée. Derrière rien de bien sorcier, un premier régulateur avec un gros transistor pour assurer un courant suffisant, en huit volts , pour l'EOS60D. Un second régulateur assure l'alimentation en cinq volts pour l'Arduino. Pour les débutants, le montage est présenté câblé à plat!
V1 est un voyant monté en parallèle sur le fusible. Quand le fusible est coupé, un faible courant traverse le voyant indiquant qu'il faut remplacer le fusible. Les autres voyants , V2 pour indiquer que le montage est sous tension, V3 pour indiquer qu'il y a du huit volts & V4 pour indiquer qu'il y a du cinq volts !
Vérifier et revérifier avant de mettre sous tension, ensuite mesurer si les tension sont bien là, et surtout, attention aux polarités tant pour l'appareil photographique que pour l'Arduino.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Un point qui est important, l'embout d'alimentation. Il doit être muni d'une "lyre"! La lyre est un petit ressort en forme de lyre, qui permet un bon maintient mécanique du branchement, et un bon contact électrique. Ce détail est important !
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Pour la prise USB qui va alimenter l'Arduino, là aussi, pas question de se tromper sous peine de provoquer la destruction du micro-contrôleur!
L'image représente la sortie coté utilisateur.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
La photographie du bricolage, la boite est une boite de bonbons.
En bas à droite le pont de diodes pour éliminer les erreurs de branchements, en bas à gauche le porte fusible avec son voyant de défaut.
Au dessus, le transistor de puissance avec son radiateur. Sur la gauche, les pinces pour connecter sur une batterie de 12 Vdc. En haut à gauche coincé dans le couvercle, la prise 8Vdc pour le Canon EOS60D et à droite la sortie 5Vdc au format USB.
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Pour les utilisateurs de Linux.
Traitement des images provenant d’un Canon EOS60,
pour réaliser des petits films image par image,
Les anglos saxons disent un « time-lapse ».
Le Canon EOS génère des fichiers images du type : IMG_xxxx.CR2
Pour traiter les images et les transformer en film, Il faut un script.
Merci au Tigre !
Novelle version du programme au 5 avril 2020.
Voici le couteau suisse de la prise d'image pour un débutant comme moi !
Ce programme fonctionne sous Linux!
Il faut cliquer sur le lien souligné en bleu marqué "le programme".
Vous téléchargez un fichier qui a pour nom: "generateVideo.sh", et qui doit, théoriquement, se retrouver dans votre ordinateur dans le répertoire "Téléchargement".
/////////////////////////////////////////////////////////////////////////////////////
/////////////// DÉBUT DE PROGRAMME ///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// Programme écrit par Jean-Pierre Lainé
// jpierrel85@gmail.com
//////////////////////////////////////////////////////
// Programme corrigé et débuggé par"Le Tigre" ////
// Un million de mercis au "Tigre" ////
//////////////////////////////////////////////////////
//
// Programme pour piloter un sequenceur photographique
// Pour Canon EOS60D ou tout appareil photographique avec télecommande par fermeture de contact
// Pour EOS60D le contact est entre l'ame du jack stéréo et la masse.
// Ce programme est libre.
// Vous pouvez modifier le programme, ( vous le devez si necessaire!)
// Vous pouvez l'utiliser librement, dans les limites des lois de votre pays.
const int ChxVitObtEtPause=0; // constante état du BP - appui sur niveau bas
// const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut
const int BPA=3; // declaration constante de broche 3 vitesse à définir
const int BPB=4; // declaration constante de broche 4 vitesse à définir
const int BPC=5; // declaration constante de broche 5 vitesse à définir
const int BPD=6; // declaration constante de broche 6 vitesse à définir
const int BPE=7; // declaration constante de broche 7 vitesse à définir
const int BPF=8; // declaration constante de broche 8 vitesse à définir
const int BPG=9; // declaration constante de broche 9 vitesse à définir
const int LedDeCommande=13; // declaration sortie de commande pour MOC
const int LedDAlarme=12; // declaration sortie de commande pour MOC
int ETAT_BP1; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP2; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP3; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP4; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP5; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP6; // lit l'état du BP et met la valeur 0/1 dans la variable
int ETAT_BP7; // lit l'état du BP et met la valeur 0/1 dans la variable
void setup() // initialisation
{
pinMode(LedDeCommande,OUTPUT); // broche de commande du MOC
pinMode(LedDAlarme,OUTPUT); // broche de commande du MOC
pinMode(BPA,INPUT); // broche d'entrée commande du 1er interupteur
pinMode(BPB,INPUT); // broche d'entrée commande du 2eme interupteur
pinMode(BPC,INPUT); // broche d'entrée commande du 3eme interupteur
pinMode(BPD,INPUT); // broche d'entrée commande du 4eme interupteur
pinMode(BPE,INPUT); // broche d'entrée commande du 5eme interupteur
pinMode(BPF,INPUT); // broche d'entrée commande du 6eme interupteur
pinMode(BPG,INPUT); // broche d'entrée commande du 7eme interupteur
}
void loop()
{ //installation d'une boucle
ETAT_BP1=digitalRead(BPA); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP2=digitalRead(BPB); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP3=digitalRead(BPC); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP4=digitalRead(BPD); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP5=digitalRead(BPE); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP6=digitalRead(BPF); // lit l'état du BP et met la valeur 0/1 dans la variable
ETAT_BP7=digitalRead(BPG); // lit l'état du BP et met la valeur 0/1 dans la variable
/////////////////////////////////////////////////////////////////////////////////////
if (ETAT_BP1==ChxVitObtEtPause)
{ // si l'état du BP1 est appuyé (càd si variable état BP1 = 0)
// pause de nuit 30 secondes
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(25000); // pendant 30 secondes
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(5000); // pendant 30 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP2==ChxVitObtEtPause)
{ // si l'état du BP2 est appuyé (càd si variable état BP2 = 0)
// // pause de nuit 15 secondes
// pause de nuit 15 secondes
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(14500); // pendant 14,5 secondes
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(500); // pendant 0.5 seconde
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP3==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP3 = 0)
// // pause de jour 5 secondes
// 5 secondes entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(4700); // pendant 4.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP4==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP4 = 0)
// // pause de jour 15 secondes
// 15 secondes entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(14700); // pendant 14.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP5==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP5 = 0)
// // pause de jour 10 minutes
// 10 minutes entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(59700); // pendant 14.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP6==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP6 = 0)
// // pause de jour 1 heure
// 1 heure entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(3599700); // pendant 3599.7 secondes
}
/////////////////////////////////////////////////////////////////////////////////////
else
if(ETAT_BP7==ChxVitObtEtPause)
{ // si l'état du BP3 est appuyé (càd si variable état BP6 = 0)
// // pause de jour 1 cliché par 24 heures
// 1 heure entre deux clichés
digitalWrite(LedDeCommande, HIGH); // allume la LED
delay(300); // pendant 0,3 seconde
digitalWrite(LedDeCommande, LOW); // éteint la LED
delay(86399700); // pendant 24 heures
}
/////////////////////////////////////////////////////////////////////////////////////
else
digitalWrite(LedDAlarme, HIGH); // allume la LED alarme
delay(200); // pause 0.2 seconde
digitalWrite(LedDAlarme, LOW); // éteint la LED alarme
delay(500); // pause 1 seconde
// si tous les inter à 0 = diode alarme
// }
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////// FIN DE PROGRAMME ///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
1 _ Enregistrer (copier) le fichier "generateVideo.sh" ( qui doit être dans votre dossier téléchargement) dans le même répertoire que les images à traiter !
2_Puis, rendre exécutable le fichier "generateVideo.sh" en tapant dans une console root:
chmod +x ./generateVideo.sh
3_ Pour traiter les images, vous devez lancer le script en tapant ( un copié/collé c’est bien aussi !)
./generateVideo.sh
Pour l'utilisation, il suffit juste maintenant de savoir lire un écran... Pas de paramètres compliqués à rentrer. Toutes les questions sont posées au fur et à mesure. Des valeurs par défaut sont entrées. Si les valeurs conviennent, il y a juste à valider avec la touche ENTER….
4_ La vidéo apparaît dans le même répertoire que les images, elle porte le nom que vous avez tapé, avec une extension « .avi ».
Et pour Webcam ?!
Second cas de figure , vous n'avez pas d'EOS. Et le maniement du fer à souder, ce n'est pas votre truc !
Mais vous avez une Webcam au fond du tiroir, elle dort !J'ai demandé à mon Ami, "Le Tigre", si il y avait une solution ?
A une promptitude à faire pâlir un éclair voulant pulvériser le record du monde de vitesse, mon ami répondait, avec, à la clef , la solution ! . .
"Comment filmer , image par image, une plante en train de germer , avec une webcam?",
Cela fonctionnera aussi pour réaliser un "image-par-image" sur le ciel.
Coté matériel cela mobilise un P.C. Mais vous avez peut-être un "vieux" P.C. sous une "ancienne" version de "la grande fenêtre" Et qui ne sert plus à rien !
Et bien les enfants, c'est le moment de franchir les portes! Il est grand temps pour vous d'avancer vers la lumière !
Il est grand temps pour vous, de ;
sortir du coté obscur de la Force!
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Dans cette ancienne machine, qui dort et qui ne sert plus à rien d'autre que de cale-porte, vous avez votre "Super-Intervalomètre" !
Installez dedans un "Linux MINT " , un "UBUNTU" ou un "DEBIAN" et il existe pleins d'autres solutions.
Pour "Linux Mint"
https://www.linuxmint.com/download.php
Pour "UBUNTU"
https://ubuntu-fr.org/
Pour "DEBIAN" le manuel pour l'installation
https://www.debian.org/releases/stable/amd64/install.pdf.fr
https://www.debian.org/distrib/netinst.fr.html
Voici le programme :
generateVideo.sh
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#!/bin/bash
COPYRIGHT="Madtiger mars 2020 - Libre de droit"
# ./generateVideo.sh
function pause {
echo "Appuyez sur ENTER pour continuer"
read
}
rep=1
while [ "$rep" -eq 1 ]; do
NBFILE_CR2=`find *.CR2 -maxdepth 1 -type f | wc -l | awk '{print $1}'`
NBFILE_JPG=`find *.jpg -maxdepth 1 -type f | wc -l | awk '{print $1}'`
clear
echo "**********************************"
echo "Outil de conversion de fichiers CANON *.CR2 en *.jpg"
echo "Outil de création d'une vidéo à partir des fichiers *.jpg"
echo "$COPYRIGHT"
echo "**********************************"
echo ""
echo " 1 - Convertir les $NBFILE_CR2 fichiers *.CR2 en *.jpg"
if [ "$NBFILE_JPG" = "0" ]; then
echo " 3 - Convertir les $NBFILE_CR2 fichiers *.CR2 et créer la vidéo à partir des fichiers *.jpg"
else
echo " 2 - Créer la vidéo à partir des $NBFILE_JPG fichiers *.jpg"
echo " 3 - Convertir les $NBFILE_CR2 fichiers *.CR2 et créer la vidéo à partir des fichiers *.jpg"
echo " 4 - Supprimer les $NBFILE_JPG fichiers *.jpg"
fi
echo " 5 - Acquisition d'images [NomRef_DATE_TIME.jpg] à partir d'une Webcam"
echo " q - Quitter"
read -p "Choix: " CHOIX
if [ "$NBFILE_JPG" = "0" ]; then
if [ "$CHOIX" = "2" ]; then
CHOIX=0
echo "Choix inconnu!!!"
exit
fi
fi
case "$CHOIX" in
1)
echo "Conversion des $NBFILE_CR2 fichiers *.CR2 en *.jpg"
if [ "$NBFILE_JPG" != "0" ]; then
rm *.jpg
fi
for i in *.CR2; do ufraw-batch --out-type jpg $i; done
pause ;;
2)
echo "Création de la vidéo à partir des $NBFILE_JPG fichiers *.jpg"
read -p "Nombre d'images par seconde: " -e -i 25 NBIMAGES
read -p "Largeur de la vidéo: " -e -i 800 W
read -p "Hauteur de la video: " -e -i 600 H
SIZE=$W"x"$H
read -p "Nom de la video: " -e -i maVideo.avi NOMVIDEO
rm $NOMVIDEO
ffmpeg -r $NBIMAGES/1 -pattern_type glob -i '*.jpg' -c:v libx264 -vf "format=yuv420p" -s $SIZE $NOMVIDEO
if [ -e $NOMVIDEO ]
then
echo "Création de la vidéo $NOMVIDEO ok"
else
echo "Erreur lors de la création de la vidéo $NOMVIDEO"
fi
pause ;;
3)
read -p "Nombre d'images par seconde: " -e -i 25 NBIMAGES
read -p "Largeur de la vidéo: " -e -i 800 W
read -p "Hauteur de la video: " -e -i 600 H
SIZE=$W"x"$H
read -p "Nom de la video: " -e -i maVideo.avi NOMVIDEO
if [ "$NBFILE_JPG" != "0" ]; then
rm *.jpg
fi
echo "Conversion des $NBFILE_CR2 fichiers *.CR2 en *.jpg"
for i in *.CR2; do ufraw-batch --out-type jpg $i; done
NBFILE_JPG=`find *.jpg -maxdepth 1 -type f | wc -l | awk '{print $1}'`
rm $NOMVIDEO
echo "Création de la vidéo à partir des $NBFILE_JPG fichiers *.jpg"
ffmpeg -r $NBIMAGES/1 -pattern_type glob -i '*.jpg' -c:v libx264 -vf "format=yuv420p" -s $SIZE $NOMVIDEO
if [ -e $NOMVIDEO ]
then
echo "Création de la vidéo $NOMVIDEO ok"
else
echo "Erreur lors de la création de la vidéo $NOMVIDEO"
fi
pause ;;
4)
read -p "Confirmez-vous la suppression des $NBFILE_JPG fichiers *.jpg [N/o]: " -e -i N SUPP
case "$SUPP" in
o)
echo "Suppression des $NBFILE_JPG fichiers *.jpg"
rm *.jpg
echo "Ok"
;;
O)
echo "Suppression des $NBFILE_JPG fichiers *.jpg"
rm *.jpg
echo "Ok"
;;
*)
echo "Suppression refusée!!!"
;;
esac
pause ;;
5)
read -p "Nom du périphérique d'acquisition vidéo' : " -e -i /dev/video0 DEVVIDEO
read -p "Temps entre chaque acquisition en seconde : " -e -i 600 IMAGETIMEWAIT
read -p "Nombre d'images à acquérir [si infini, mettre -1]: " -e -i '-1' NBTOTALIMAGES
read -p "Nombre d'images par seconde: " -e -i 1 NBIMAGES
read -p "Largeur de la vidéo: " -e -i 640 W
read -p "Hauteur de la video: " -e -i 480 H
SIZE=$W"x"$H
read -p "Nom de l'image de référence (sans l'extension jpg): " -e -i ImageDeSortie NOMIMAGEREF
read -p "Type d'extension: " -e -i jpg TYPEEXTENSION
IMAGETIMEWAIT=$[$IMAGETIMEWAIT-4]
if (( "$IMAGETIMEWAIT" < "0" )) ; then
IMAGETIMEWAIT="1"
fi
ATTENTE=$[$IMAGETIMEWAIT+4]
i="0"
if [ "$NBTOTALIMAGES" -eq "-1" ] ; then
while true;
do
DATETIME=`date +%Y%m%d_%H%M%S`
NOMIMAGE=$NOMIMAGEREF'_'$DATETIME'.'$TYPEEXTENSION
echo "-----------------------"
echo "Acquisition de l'image: $NOMIMAGE"
echo "***********************"
ffmpeg -f video4linux2 -s $SIZE -i $DEVVIDEO -ss 0:0:0 -frames $NBIMAGES "$NOMIMAGE"
i=$[$i+1]
echo "***********************"
echo "$i: $NOMIMAGE ok"
echo " "
echo "***********************"
echo " Appuyer sur CTRL + C pour arreter l'acquisition"
echo "***********************"
echo "Attente de $ATTENTE secondes"
sleep $IMAGETIMEWAIT
done
else
while [ $i -lt $NBTOTALIMAGES ];
do
DATETIME=`date +%Y%m%d_%H%M%S`
NOMIMAGE=$NOMIMAGEREF'_'$DATETIME'.'$TYPEEXTENSION
i=$[$i+1]
echo "-----------------------"
echo "Acquisition de l'image $i/$NBTOTALIMAGES: $NOMIMAGE"
echo "***********************"
ffmpeg -f video4linux2 -s $SIZE -i $DEVVIDEO -ss 0:0:0 -frames $NBIMAGES "$NOMIMAGE"
echo "***********************"
echo "$i/$NBTOTALIMAGES: $NOMIMAGE ok."
echo " "
echo "***********************"
echo " Appuyer sur CTRL + C pour arreter l'acquisition"
echo "***********************"
if (( "$i" < "$NBTOTALIMAGES" )) ; then
echo "Attente de $ATTENTE secondes"
sleep $IMAGETIMEWAIT
fi
done
fi
pause ;;
q)
rep=0 ;;
*)
echo "Choix inconnu!!!"
pause ;;
esac
done
exit
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Dans l'ordinateur!
Dans le dossier "image" vous créez un dossier du genre "image par image"
Et dans le nouveau dossier vous collez le fichier
"generateVideo.sh
En "root" allez dans une console ouvrir votre dossier "image par image" .
A - Lancez le micro programme .
B- Dans une console root:
chmod +x ./generateVideo.sh
C -Lancez le script en tapant ( un copié/collé c’est bien aussi !)
./generateVideo.sh
D - Et là, vous devez vous retrouvez en face de :
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
La première ligne concerne les fichiers images du Canon EOS60D, pour les convertir au format .jpg
La deuxième ligne génère une vidéo, il faut un minimum de dix images !
La troisième ligne permet de convertir et dans le même temps de générer une vidéo.
La quatrième ligne permet d'effacer les fichiers .jpg, attention ! Le couteau suisse est puissant !
La cinquième ligne permet de prendre image par image le flux d'une Webcam. Pas de filmer , de faire une photo, puis une autre et ainsi de suite . . .
q- quitter !
Je suis bricoleur, mais vraiment pas doué quand le verbe machiner doit s'accorder avec...... et le reste ! Et pour que le site soit lisible par tous, et qu'il puisse être automatiquement traduit pour les lecteurs qui ne parlent pas le Français.....
Merci de m'informer des fautes d'orthographe et de conjugaison et ... bref ! Des fautes !
Une question ? Tapez l'adresse dans votre boite courriels, l'escargot est l'arobas >"@", la coccinelle le point >"."
Pour agrandir l'image, positionner la souris sur l'image, et clic droit, "Ouvrir l'image dans un nouvel onglet.
Mardi 20 Février 2024 à 15:03.
