Управление записью для камер Canon 5D (7D, 700D и т.д.) на основе Ардуино.

Если ставить зеркалку Canon 5D (7D, 700D и т.д.) , например, на стедикам, на основе подвеса на бесколлекторниках, то очень желательно иметь возможность включать запись дистанционно. Если съемка со стедиком - включать запись просто неудобно, а если съемка коптером, то приходится включать запись на земле и писать все подряд.

Вот я и заморочился сделать дистанционное включение записи для камер Canon. Готовых решений я не нашел, так чтобы взять, купить и пользоваться. Есть шуттеры для спуска затвора, а для включения записи я не встречал.

Нашел на просторах инета переписку Энгельса с Каутским про автоматическое включение записи на камерах Canon, (5D и 7D пишет по 12 мин. файл до 4ГБ). Так вот, они там предложили запускать камеру через ИК порт, при этом автоматически камера останавливается и перезапускается каждые 11 мин… Идея интересная, но не в этом суть…Они там описали код для ИК управления Canon 5D. У них получилось ДУ, управляемое одной кнопкой (почему-то двойным нажатием). Я повторил конструкцию, прошил код, все работает. И все бы хорошо, но кнопка - это не наш вариант, нам нужно подавать на вход либо PWM либо PPM.
А еще лучше иметь два, PPM и PWM с возможностью выбора входа и канала в случае управления через PPM.

Вот здесь для меня тупик… нужна помощь! Доделать код знаний не хватает. Давайте вместе сделаем, и всем нам будет польза.

Код:

/*
Canon 7D remote record trigger, autoloop

2010 Oct 29 tested with 550D (use 12 microseconds for pulseDuration instead of 10)
2010 Oct 16 improved by Sander Bontje

Based on Martin Koch’s work so all credits should go to him:

Arduino sketch for simulating a Canon RC-1 IR remote control to start and stop video recording on a Canon 5D Mark II or 7D
2010, Martin Koch
controlyourcamera.blogspot.com
Huge thanks go to www.doc-diy.net/photo/rc-1_hacked/index.php for figuring out the IR code.
*/

#define irLEDpin 2 // pin the IR LED is connected to on the Arduino
#define swPin 4 // pin switch
#define statusLEDpin 3 // pin with the status LED
// pulseDuration: the 5DmkII and 7D are fine with a value of 10,
// the 550D requires 12 (the 7D works with this value too)
unsigned int pulseDuration = 11; // microseconds
//The required 15 microseconds pulseDuration didn’t work since digitalWrite consumes some additional time
//thats adds to pulseDuration value. 10 to 12 microseconds seem to work for a Canon 7D and a 5DmkII.
unsigned int photo = 7330; // ms, a 7330 microseconds delay between bursts shoots a photo.
unsigned int newClipDelay = 2000; // ms, a 1 s delay between stop and start of next clip
unsigned int video = 5360; // ms, a 5360 microseconds delay between bursts starts/stops video recording.
boolean recording = false; // flag to indicate if we’re recording or not
boolean autoRecording = false; // flag to indicate if we’re recording automatically or not
unsigned long startRecMillis = 0; // ms, start of initial record, used to check if autoStartDelay has been reached
// millies() returns the number of milliseconds since the Arduino board began running the current program.
// This number will overflow (go back to zero), after approximately 50 days.
unsigned int autoStartDelay = 4000; // ms, after pressing the sw this log autoRecording mode is entered
boolean inAutoRecGraceTimeIn = false; // flag to remember that we just pressed the sw to enter autoRecording mode and should not stop recording
boolean inAutoRecGraceTimeOut = false; // flag to remember that we just pressed the sw to exit autoRecording mode and should not restart recording immediately
unsigned long currentClipStartTime = 0; // ms, start of recording of current clip
unsigned long currentClipDuration = 0; // ms, duraction of the currently recorded clip
unsigned long maxClipTime = 660000; // ms, default for 11 minute clips: 11 * 60 * 1000 ms = 660000 s
unsigned int blinkInterval = 500; // ms interval to blink the status LED
unsigned long blinkedTimerMillis = 0; // amount of ms of the previous blink on/off
unsigned int statusLEDstate = LOW; // statusLED’s state

void setup() {
Serial.begin(9600);
Serial.println(“Ready”);
pinMode(irLEDpin, OUTPUT);
pinMode(statusLEDpin, OUTPUT);
pinMode(swPin, INPUT);
digitalWrite(swPin, HIGH); // turn on internal 20k pullup resistor so the open input state is HIGH.
digitalWrite(irLEDpin, LOW);
digitalWrite(statusLEDpin, LOW);
}

void loop() {

unsigned long currentMillis = millis();

// in autoRecording mode or not?
if (autoRecording == false) {
// not in autoRecording mode

// first time the switch is pressed? start recording while the sw is down
if (digitalRead(swPin) == LOW) {
// sw is pressed

if (inAutoRecGraceTimeOut == true) {
// we just came from a long autoRecording session and will not continue until the sw is released
Serial.println(“sw pressed, in grace timeout. Release sw first.”);
} else {
digitalWrite(statusLEDpin, HIGH);
if (startRecMillis == 0) { // we’re starting a completely new recording
startRecMillis = currentMillis;
Serial.println(“sw pressed, starting a new recording”);
shoot(video); // start video recording with a new clip
currentClipStartTime = currentMillis;
recording = true;
}
else if (currentMillis - startRecMillis > autoStartDelay) {
// sw has been pressed long enough to start autoRecording mode
Serial.println(“sw pressed long enough, starting autoRecording mode. You may let go now.”);
//digitalWrite(statusLEDpin, LOW);
// statusLEDhigh = false;
// statusLED will blink from now on during autoRecording mode
autoRecording = true;
inAutoRecGraceTimeIn = true;
}
}
}
else {
// still not in autoRecording mode
// sw is released
// if we were recording just before…
if (recording == true) {
if (currentMillis - startRecMillis < autoStartDelay) {
// has the switch been released before entering autoRecording mode?
// if so, fire a stop command to the cam
Serial.println(“sw released, stopping recording”);
shoot(video); // stop video recording
}
}

// not recording anything, everything returns to their defaults:
startRecMillis = 10;
currentClipStartTime = 0;
currentClipDuration = 0;
statusLEDstate = LOW;
digitalWrite(irLEDpin, LOW);
digitalWrite(statusLEDpin, statusLEDstate);
inAutoRecGraceTimeIn = false;
inAutoRecGraceTimeOut = false;
recording = false;
}
} else {
// in autoRecording mode
// do nothing with the IR LED except if switch is pressed again or clip time limit is reached

// blink the statusLED to show we’re in autoRecording mode
if (currentMillis - blinkedTimerMillis > blinkInterval) {

// save the last time the LED blinked
blinkedTimerMillis = currentMillis;

// and blink
if (statusLEDstate == LOW) {
statusLEDstate = HIGH;
}
else {
statusLEDstate = LOW;
}
digitalWrite(statusLEDpin, statusLEDstate);
}

// abort recording when the switch is pressed, but only if we are not inAutoRecGraceTimeIn
if (digitalRead(swPin) == LOW) {
if (inAutoRecGraceTimeIn == true) {
Serial.println(“autoRecording: sw pressed, in grace timeout. Release the sw first.”);
} else {
Serial.println(“autoRecording: sw pressed, stop recording”);
shoot(video); // stop video recording
autoRecording = false;
inAutoRecGraceTimeOut = true;
// statusLED off
digitalWrite(statusLEDpin, LOW);
}
} else {
// sw has been released
inAutoRecGraceTimeIn = false;
}

currentClipDuration = currentMillis - currentClipStartTime;
// just for debugging
/*
if (currentClipDuration % 1000 == 0) {
Serial.print(“autoRecording: currentClipDuration (ms):\t”);
Serial.println(currentClipDuration);
}
*/

// automatically stat a new clip if neccesary
if (currentClipDuration > maxClipTime) {
Serial.print(“autoRecording: autoResume, currentClipDuration (ms)\t:”);
Serial.println(currentClipDuration);
shoot(video); // stop video recording
delay(newClipDelay); // a delay between stop and start of next clip
shoot(video); // restart video recording with a new clip
currentClipStartTime = millis(); // measure again because we might be already some delays further
}
}
}
void shoot(unsigned int delayBetweenBursts) { // sends the IR signal

// send first 16 bursts
for(int i=0; i<16; i++) {
digitalWrite(irLEDpin, HIGH);
delayMicroseconds(pulseDuration);
digitalWrite(irLEDpin, LOW);
delayMicroseconds(pulseDuration);
}

delayMicroseconds(delayBetweenBursts);

// send second 16 bursts
for(int i=0; i<16; i++) {
digitalWrite(irLEDpin, HIGH);
delayMicroseconds(pulseDuration);
digitalWrite(irLEDpin, LOW);
delayMicroseconds(pulseDuration);
}

}