Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 1701 → Rev 1702

/C-OSD/arducam-osd/libraries/PTPCamera/examples/EOSHDRCapture/EOSHDRCapture.pde
0,0 → 1,114
/* Exposure compensation change demo */
#include <inttypes.h>
#include <avr/pgmspace.h>
 
//#include <Spi.h>
#include <Max3421e.h>
#include <Max3421e_constants.h>
#include <Max_LCD.h>
#include <Usb.h>
#include <ptp.h>
#include <canoneos.h>
#include <qep_port.h>
 
#include "hdrcapture.h"
 
#define DEV_ADDR 1
 
// Canon EOS 400D
#define DATA_IN_EP 1
#define DATA_OUT_EP 2
#define INTERRUPT_EP 3
#define CONFIG_NUM 1
 
class CamStateHandlers : public EOSStateHandlers
{
enum CamStates { stInitial, stDisconnected, stConnected };
CamStates stateConnected;
public:
CamStateHandlers() : stateConnected(stInitial)
{
};
virtual void OnDeviceDisconnectedState(PTP *ptp);
virtual void OnDeviceInitializedState(PTP *ptp);
};
 
CamStateHandlers CamStates;
CanonEOS Eos(DEV_ADDR, DATA_IN_EP, DATA_OUT_EP, INTERRUPT_EP, CONFIG_NUM, &CamStates);
HDRCapture hdrCapture(Eos);
QEvent msTick;
QEvent secTick;
 
void CamStateHandlers::OnDeviceDisconnectedState(PTP *ptp)
{
if (stateConnected == stConnected || stateConnected == stInitial)
{
stateConnected = stDisconnected;
Notify(PSTR("Camera disconnected\r\n"));
}
}
 
void CamStateHandlers::OnDeviceInitializedState(PTP *ptp)
{
if (stateConnected == stDisconnected)
{
stateConnected = stConnected;
Serial.println("Connected");
 
SetEvt setEvt;
setEvt.sig = RUN_SIG;
hdrCapture.PostEvent(&setEvt);
}
hdrCapture.Run();
hdrCapture.PostEvent(&msTick); // post TICK_MILLIS_SIG event
}
 
void setup()
{
Serial.begin( 115200 );
Serial.println("Start");
 
Eos.Setup();
delay( 200 );
 
hdrCapture.init();
SetEvt setEvt;
setEvt.sig = SET_FRAMES_SIG;
setEvt.value = 3;
hdrCapture.dispatch(&setEvt);
setEvt.sig = SET_FRAME_TIMEOUT_SIG;
setEvt.value = 5;
hdrCapture.dispatch(&setEvt);
setEvt.sig = SET_SELF_TIMEOUT_SIG;
setEvt.value = 3;
hdrCapture.dispatch(&setEvt);
SetBktEvt setBktEvt;
setBktEvt.sig = SET_BRACKETING_SIG;
setBktEvt.step = 2;
setBktEvt.negative = 3;
setBktEvt.positive = 9;
hdrCapture.dispatch(&setBktEvt);
msTick.sig = TICK_MILLIS_SIG;
}
 
void loop()
{
Eos.Task();
delay(1);
}
 
/C-OSD/arducam-osd/libraries/PTPCamera/examples/EOSHDRCapture/expcomp_macro.h
0,0 → 1,9
#if !defined(__EXPCOMP_MACRO_H__)
#define __EXPCOMP_MACRO_H__
 
uint8_t expComp[] = { 0xF0, 0xF3, 0xF5, 0xF8, 0xFB, 0xFD, 0, 0x03, 0x05, 0x08, 0x0B, 0x0D, 0x10 };
 
 
#define EXP_COMP_VALUE(i)((uint32_t)expComp[(i)])
 
#endif // __EXPCOMP_MACRO_H__
/C-OSD/arducam-osd/libraries/PTPCamera/examples/EOSHDRCapture/hdrcapture.cpp
0,0 → 1,336
#include "hdrcapture.h"
#include "expcomp_macro.h"
 
/* fixes avr-gcc incompatibility with virtual destructors */
void operator delete( void *p ) {}
 
QState HDRCapture::Initial(HDRCapture *me, QEvent const *e)
{
return Q_TRAN(&HDRCapture::Inactive);
}
 
QState HDRCapture::Inactive(HDRCapture *me, QEvent const *e)
{
switch(e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Inactive\r\n");
return Q_HANDLED();
case SET_FRAMES_SIG:
me->frmCount = (uint16_t)((SetEvt*)e)->value;
return Q_HANDLED();
case SET_SELF_TIMEOUT_SIG:
me->selfTimeout = ((SetEvt*)e)->value;
return Q_HANDLED();
case SET_FRAME_TIMEOUT_SIG:
me->frameTimeout = ((SetEvt*)e)->value;
return Q_HANDLED();
case SET_BRACKETING_SIG:
me->bktStep = ((SetBktEvt*)e)->step;
me->bktNegative = ((SetBktEvt*)e)->negative;
me->bktPositive = ((SetBktEvt*)e)->positive;
return Q_HANDLED();
case RUN_SIG:
me->frmCntdn = me->frmCount;
me->bktCntdn = (me->bktStep) ? (me->bktPositive - me->bktNegative) / me->bktStep + 1 : 1;
me->bktPos = me->bktNegative;
return Q_TRAN(&HDRCapture::Active);
}
return Q_SUPER(&QHsm::top);
}
 
QState HDRCapture::Active(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Active\r\n");
return Q_HANDLED();
case Q_EXIT_SIG:
PTPTRACE("::Q_EXIT_SIG\r\n");
return Q_HANDLED();
case Q_INIT_SIG:
PTPTRACE("Q_INIT_SIG\r\n");
return Q_TRAN(&HDRCapture::SaveSettings);
case RUN_SIG:
PTPTRACE("::RUN_SIG\r\n");
return Q_TRAN(&HDRCapture::SaveSettings);
case ABORT_SIG:
PTPTRACE("ABORT_SIG\r\n");
return Q_TRAN(&HDRCapture::RestoreSettings);
case PTP_RC_SIG:
PTPTRACE("::PTP_RC_SIG\r\n");
switch (((PTP_RC_Evt*)e)->rc)
{
case PTP_RC_OK:
me->qpEvt.sig = PTP_RC_OK_SIG;
me->theQueue.Push(&me->qpEvt);
return Q_HANDLED();
case PTP_RC_DeviceBusy:
me->toEvt.timeout = PTP_TIMEOUT;
me->toEvt.attribs = TA_PTP_TIMEOUT;
me->theQueue.Push(&me->toEvt);
return Q_TRAN(&HDRCapture::Timeout);
default:
return Q_TRAN(&HDRCapture::Inactive);
}
case SET_TIMEOUT_SIG:
PTPTRACE("::SET_TIMEOUT_SIG\r\n");
return Q_HANDLED();
case TIMEOUT_SIG:
PTPTRACE("::TIMEOUT_SIG\r\n");
return Q_TRAN(me->activeHistory);
case PTP_RC_OK_SIG:
PTPTRACE("::PTP_RC_OK_SIG\r\n");
return Q_TRAN(me->activeHistory);
case TICK_MILLIS_SIG:
PTPTRACE("::TICK_MILLIS_SIG\r\n");
return Q_HANDLED();
}
return Q_SUPER(&QHsm::top);
}
 
QState HDRCapture::SaveSettings(HDRCapture *me, QEvent const *e)
{
static bool bSaved = false;
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("SaveSettings\r\n");
me->activeHistory = (QStateHandler)&SaveSettings;
// me->rcEvt.rc = me->Eos.GetProperty(EOS_DPC_ExposureCompensation, me->bktOldVal);
me->rcEvt.rc = PTP_RC_OK;
me->theQueue.Push(&me->rcEvt);
me->bktOldVal = (uint8_t)0;
return Q_HANDLED();
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
if (me->selfTimeout)
{
me->theQueue.Push((QEvent*)e);
return Q_TRAN(&HDRCapture::SelfTimer);
}
return Q_TRAN(&HDRCapture::PreCapture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::SelfTimer(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("SelfTimer\r\n");
me->activeHistory = (QStateHandler)&SelfTimer;
return Q_HANDLED();
case TICK_MILLIS_SIG:
PTPTRACE("TICK_MILLIS_SIG\r\n");
return Q_TRAN(&HDRCapture::PreCapture);
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
me->toEvt.timeout = me->selfTimeout;
me->toEvt.attribs = TA_SELF_TIMER;
me->theQueue.Push(&me->toEvt);
return Q_TRAN(&HDRCapture::Timeout);
case TIMEOUT_SIG:
PTPTRACE("TIMEOUT_SIG\r\n");
return Q_TRAN(&HDRCapture::PreCapture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::RestoreSettings(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("RestoreSettings\r\n");
me->activeHistory = (QStateHandler)&RestoreSettings;
me->rcEvt.rc = me->Eos.SetProperty(EOS_DPC_ExposureCompensation, me->bktOldVal);
me->theQueue.Push(&me->rcEvt);
return Q_HANDLED();
case PTP_RC_OK_SIG:
return Q_TRAN(&HDRCapture::Inactive);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::PreCapture(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("PreCapture\r\n");
me->activeHistory = (QStateHandler)&PreCapture;
return Q_HANDLED();
case TICK_MILLIS_SIG:
PTPTRACE("TICK_MILLIS_SIG\r\n");
if (!me->bktCntdn)
{
me->bktCntdn = (me->bktStep) ? (me->bktPositive - me->bktNegative) / me->bktStep + 1 : 1;
me->bktPos = me->bktNegative;
}
if (me->bktStep)
return Q_TRAN(&HDRCapture::ExpCompSet);
return Q_TRAN(&HDRCapture::Capture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::Capture(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Capture\r\n");
me->activeHistory = (QStateHandler)&Capture;
me->rcEvt.rc = me->Eos.Capture();
// me->rcEvt.rc = PTP_RC_OK;
me->theQueue.Push(&me->rcEvt);
return Q_HANDLED();
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
return Q_TRAN(&HDRCapture::PostCapture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::PostCapture(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("PostCapture\r\n");
me->activeHistory = (QStateHandler)&PostCapture;
return Q_HANDLED();
case TICK_MILLIS_SIG:
PTPTRACE("TICK_MILLIS_SIG\r\n");
 
if (!me->bktCntdn)
return Q_TRAN(&HDRCapture::PreCapture);
 
me->bktPos += me->bktStep;
if (--me->bktCntdn == 0)
{
--me->frmCntdn;
me->OnFrameCaptured(me->frmCntdn);
}
me->OnBktFrameCaptured(me->bktCntdn);
 
// if it was the last frame in total
if (!me->frmCntdn)
{
me->qpEvt.sig = ABORT_SIG;
me->theQueue.Push(&me->qpEvt);
return Q_HANDLED();
}
if (me->bktCntdn)
return Q_TRAN(&HDRCapture::PreCapture);
 
// if it was the last frame in bracketing
me->toEvt.timeout = me->frameTimeout;
me->toEvt.attribs = TA_INTR_TIMER;
me->theQueue.Push(&me->toEvt);
return Q_TRAN(&HDRCapture::Timeout);
case TIMEOUT_SIG:
PTPTRACE("TIMEOUT_SIG\r\n");
return Q_TRAN(&HDRCapture::PreCapture);
}
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::ExpCompSet(HDRCapture *me, QEvent const *e)
{
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("ExpCompSet\r\n");
me->activeHistory = (QStateHandler)&ExpCompSet;
me->rcEvt.rc = me->Eos.SetProperty(EOS_DPC_ExposureCompensation, EXP_COMP_VALUE(me->bktPos));
// me->rcEvt.rc = PTP_RC_OK;
me->theQueue.Push(&me->rcEvt);
return Q_HANDLED();
case PTP_RC_OK_SIG:
PTPTRACE("PTP_RC_OK_SIG\r\n");
return Q_TRAN(&HDRCapture::Capture);
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
QState HDRCapture::Timeout(HDRCapture *me, QEvent const *e)
{
static uint32_t timeout = 0;
static uint32_t local_time = 0;
static uint32_t seconds_left = 0;
static uint8_t attribs = 0;
static uint16_t sec_cntdn = 1000;
switch (e->sig)
{
case Q_ENTRY_SIG:
PTPTRACE("Timeout\r\n");
return Q_HANDLED();
case SET_TIMEOUT_SIG:
attribs = ((SetTimeoutEvt*)e)->attribs;
timeout = (attribs & 0x01) ? ((SetTimeoutEvt*)e)->timeout * 1000 : ((SetTimeoutEvt*)e)->timeout;
if (attribs & 0x01)
{
seconds_left = ((SetTimeoutEvt*)e)->timeout;
sec_cntdn = 1000;
switch (attribs)
{
case TA_SELF_TIMER:
me->OnSelfTimerProgress(seconds_left);
break;
case TA_INTR_TIMER:
me->OnIntrTimerProgress(seconds_left);
break;
// case TA_BULB_TIMER:
// me->OnBulbTimerProgress(seconds_left);
// break;
} // switch
}
local_time = millis();
return Q_HANDLED();
case TICK_MILLIS_SIG:
uint32_t dt = local_time;
local_time = millis();
dt = local_time - dt;
timeout = (timeout < dt) ? 0 : timeout - dt;
 
if (attribs & 1)
{
bool bTick = (sec_cntdn <= dt);
sec_cntdn = (sec_cntdn > dt) ? sec_cntdn - dt : 1000 - dt;
if (bTick)
{
seconds_left --;
switch (attribs)
{
case TA_SELF_TIMER:
me->OnSelfTimerProgress(seconds_left);
break;
case TA_INTR_TIMER:
me->OnIntrTimerProgress(seconds_left);
break;
} // switch
} // if (--sec_cntdn == 0)
} // if (attribs & 1)
if (!timeout)
{
me->qpEvt.sig = TIMEOUT_SIG;
me->theQueue.Push(&me->qpEvt);
}
return Q_HANDLED();
} // switch
return Q_SUPER(&HDRCapture::Active);
}
 
/C-OSD/arducam-osd/libraries/PTPCamera/examples/EOSHDRCapture/hdrcapture.h
0,0 → 1,130
#if !defined(__HDRCAPTURE_H__)
#define __HDRCAPTURE_H__
 
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <qep_port.h>
#include <ptp.h>
#include <canoneos.h>
#include <simplefifo.h>
#include <valuelist.h>
 
#define PTP_TIMEOUT 250
 
#define TA_PTP_TIMEOUT 0x00
#define TA_SELF_TIMER 0x03
#define TA_INTR_TIMER 0x05
#define TA_BULB_TIMER 0x07
 
enum HDRCaptureSignals
{
TICK_MILLIS_SIG = Q_USER_SIG,
SET_FRAMES_SIG,
SET_SELF_TIMEOUT_SIG,
SET_FRAME_TIMEOUT_SIG,
SET_BRACKETING_SIG,
RUN_SIG,
ABORT_SIG,
TIMEOUT_SIG,
SET_TIMEOUT_SIG,
PTP_RC_SIG,
PTP_RC_OK_SIG
};
 
struct SetTimeoutEvt : public QEvent
{
uint32_t timeout;
uint8_t attribs;
};
 
struct SetEvt : public QEvent
{
uint32_t value;
};
 
struct SetBktEvt : public QEvent
{
uint8_t step;
uint8_t negative;
uint8_t positive;
};
 
struct PTP_RC_Evt : public QEvent
{
uint16_t rc;
};
 
class HDRCapture : public QHsm
{
uint16_t frmCntdn;
uint16_t frmCount;
uint32_t selfTimeout;
uint32_t frameTimeout;
uint8_t bktStep;
uint8_t bktNegative;
uint8_t bktPositive;
uint8_t bktCntdn;
uint8_t bktPos;
uint8_t bktOldVal;
CanonEOS &Eos;
SetTimeoutEvt toEvt;
PTP_RC_Evt rcEvt;
QEvent qpEvt;
QStateHandler activeHistory;
 
SimpleFIFO<QEvent*, 4> theQueue;
public:
HDRCapture(CanonEOS &eos) :
QHsm((QStateHandler)&HDRCapture::Initial),
frmCount(0),
frmCntdn(0),
selfTimeout(0),
frameTimeout(0),
bktStep(0),
bktNegative(0),
bktPositive(0),
bktCntdn(0),
bktPos(0),
bktOldVal(0),
Eos(eos),
activeHistory(NULL)
{
toEvt.sig = SET_TIMEOUT_SIG;
rcEvt.sig = PTP_RC_SIG;
};
void PostEvent(QEvent *e)
{
theQueue.Push(e);
};
void Run()
{
QEvent *e = NULL;
while ( (e = theQueue.Pop()) )
dispatch(e);
};
 
protected:
static QState Initial(HDRCapture *me, QEvent const *e);
static QState Inactive(HDRCapture *me, QEvent const *e);
static QState Active(HDRCapture *me, QEvent const *e);
static QState SelfTimer(HDRCapture *me, QEvent const *e);
static QState PreCapture(HDRCapture *me, QEvent const *e);
static QState Capture(HDRCapture *me, QEvent const *e);
static QState PostCapture(HDRCapture *me, QEvent const *e);
static QState ExpCompSet(HDRCapture *me, QEvent const *e);
static QState SaveSettings(HDRCapture *me, QEvent const *e);
static QState RestoreSettings(HDRCapture *me, QEvent const *e);
static QState Timeout(HDRCapture *me, QEvent const *e);
virtual void OnFrameCaptured(uint16_t left) {};
virtual void OnBktFrameCaptured(uint16_t left) {};
virtual void OnSelfTimerProgress(uint32_t left) {};
virtual void OnIntrTimerProgress(uint32_t left) {};
};
 
#endif // __HDRCAPTURE_H__