Subversion Repositories Projects

/* Digital camera controller board test sketch */

//#include <Spi.h>

#include <Max3421e.h>

#include <Usb.h>

#include <Max_LCD.h>

#include <simpletimer.h>

#include <valuelist.h>

#include <canoneos.h>

#include <qep_port.h>

#include "camcontroller.h"

#include "controls.h"

#include "eoseventparser.h"

#include "dataitem.h"

#include "screenitem.h"

#include "screen.h"

#include "menu.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

#define EEP_APERTURE_LIST_OFFSET    0

#define EEP_APERTURE_LIST_SIZE      32

#define EEP_SHTSPEED_LIST_OFFSET    (EEP_APERTURE_LIST_OFFSET + EEP_APERTURE_LIST_SIZE)

#define EEP_SHTSPEED_LIST_SIZE      64

#define EEP_WBALANCE_LIST_OFFSET    (EEP_SHTSPEED_LIST_OFFSET + EEP_SHTSPEED_LIST_SIZE)

#define EEP_WBALANCE_LIST_SIZE      12

#define EEP_PICSTYLE_LIST_OFFSET    (EEP_WBALANCE_LIST_OFFSET + EEP_WBALANCE_LIST_SIZE)

#define EEP_PICSTYLE_LIST_SIZE      12

#define EEP_EXPOCOR_LIST_OFFSET     (EEP_PICSTYLE_LIST_OFFSET + EEP_PICSTYLE_LIST_SIZE)

#define EEP_EXPOCOR_LIST_SIZE       48

#define EEP_ISO_LIST_OFFSET         (EEP_EXPOCOR_LIST_OFFSET + EEP_EXPOCOR_LIST_SIZE)

#define EEP_ISO_LIST_SIZE           8

EEPROMByteList          vlAperture(EEP_APERTURE_LIST_OFFSET, EEP_APERTURE_LIST_SIZE);

EEPROMByteList          vlShutterSpeed(EEP_SHTSPEED_LIST_OFFSET, EEP_SHTSPEED_LIST_SIZE);

EEPROMByteList          vlWhiteBalance(EEP_WBALANCE_LIST_OFFSET, EEP_WBALANCE_LIST_SIZE);

EEPROMByteList          vlPictureStyle(EEP_PICSTYLE_LIST_OFFSET, EEP_PICSTYLE_LIST_SIZE);

EEPROMByteList          vlIso(EEP_ISO_LIST_OFFSET, EEP_ISO_LIST_SIZE);

EEPROMByteList          vlExpCompensation(EEP_EXPOCOR_LIST_OFFSET, EEP_EXPOCOR_LIST_SIZE);

class CamStateHandlers : public EOSStateHandlers

{

      bool stateConnected;

public:

      CamStateHandlers() : stateConnected(false) {};

      virtual void OnDeviceDisconnectedState(PTP *ptp);

      virtual void OnDeviceInitializedState(PTP *ptp);

};

class CamHDRCapture : public HDRCapture

{

public:

    CamHDRCapture(CanonEOS &eos) : HDRCapture(eos) {};

protected:

    virtual void OnFrameCaptured(uint16_t left);

    virtual void OnSelfTimerProgress(uint32_t left);

    virtual void OnIntrTimerProgress(uint32_t left);

};

CamStateHandlers  CamStates;

Max_LCD               LCD;

SimpleTimer           ControlTimer, PTPPollTimer;

CanonEOS              Eos(DEV_ADDR, DATA_IN_EP, DATA_OUT_EP, INTERRUPT_EP, CONFIG_NUM, &CamStates);

CamHDRCapture         hdrCapture(Eos);

GPInRegister          ExtControls(Eos.GetMax());

QEvent                evtTick, evtAbort;

//--- (0) Message Screen ----------------------------------------------------------------------

PgmStringDataItem     diFirst(msgCamera);

PgmStringDataItem     diSecond(msgDisconnected);

ScreenItem            siFirst     (5, 0, 16, false, &diFirst);

ScreenItem            siSecond    (2, 1, 16, false, &diSecond);

ScreenItem            *messageScreenItems[]  PROGMEM = { &siFirst, &siSecond };

Screen                messageScreen(2, (ScreenItem*)messageScreenItems);

//--- (1) Main Menu Screen --------------------------------------------------------------------

ScreenItem            siIntervalometer (1,  0, 8, true,  (const char*)&msgIntervalometer);

ScreenItem            siSettings       (1,  1, 8, false, (const char*)&msgSettings);

ScreenItem            *mainMenuScreenItems[]  PROGMEM = { &siIntervalometer, &siSettings };

Screen                scrMainMenu(2, (ScreenItem*)mainMenuScreenItems);

//--- (2) Timer Menu Screen -------------------------------------------------------------------

ScreenItem            siSelf     (1,  0, 4, true,  (const char*)&msgSetSelf);

ScreenItem            siFrames   (1,  1, 4, false, (const char*)&msgSetFrames);

ScreenItem            siBkt      (6,  0, 3, false, (const char*)&msgSetBkt);

ScreenItem            siInterval (6,  1, 3, false, (const char*)&msgSetInterval);

ScreenItem            siRun      (10, 0, 4, false, (const char*)&msgSetRun);

ScreenItem            siExit     (10, 1, 4, false, (const char*)&msgExit);

ScreenItem            *timerSettingsScreenItems[]  PROGMEM = { &siSelf, &siFrames, &siBkt, &siInterval, &siRun, &siExit };

Screen                timerSettingsScreen(6, (ScreenItem*)timerSettingsScreenItems);

//--- (3) Self Timer Screen -------------------------------------------------------------------

DIT_TIMER_DIGIT_PAIR  diHourSelf(0),  diHourInt(0),

                      diMinSelf(0),   diMinInt(0),

                      diSecSelf(0),   diSecInt(0);

ScreenItem            siSelfTimer(0, 0, 16, false,  (const char*)&msgSelfTimer);

ScreenItem            siHourSelf(3, 1, 2, false, &diHourSelf);

ScreenItem            siMinSelf (6, 1, 2, false, &diMinSelf);

ScreenItem            siSecSelf (9, 1, 2, false, &diSecSelf);

ScreenItem            *scitmSelfTimerSet[]  PROGMEM = { &siSelfTimer, &siHourSelf, &siMinSelf, &siSecSelf };

Screen                scrSelfTimerSet(4, (ScreenItem*)scitmSelfTimerSet);

//--- (4) Number of Frames Screen -------------------------------------------------------------

IntDataItem<uint16_t, 5>         diFramesCount(0);

IntDataItem<uint16_t, 5>         diFramesLeft(0);

ScreenItem            siFramesText  (5, 0,  6, false, (const char*)&msgCntFrames);

ScreenItem            siFramesCount (6, 1,  4, false, &diFramesCount);

ScreenItem            *scitmFramesSet[]  PROGMEM = { &siFramesText, &siFramesCount };

Screen                scrFramesSet(2, (ScreenItem*)scitmFramesSet);

//--- (5) Bracketing Screen -------------------------------------------------------------------

KeyValuePairDataItem<uint8_t, 37, 7>      diBktEV(0, ExpCompTitles);

KeyValuePairDataItem<uint8_t, 37, 7>      diBktStep(0, ExpCompTitles);

uint8_t                                   nBktStep;

uint8_t                                   nBktNegativeIndex;

uint8_t                                   nBktPositiveIndex;

ScreenItem            siBracketing(0, 0, 15, false,  (const char*)&msgBracketing);

ScreenItem            siBktEV     (1, 1,  6, false,  &diBktEV);

ScreenItem            siBktStep   (9, 1,  6, false,  &diBktStep);

ScreenItem            *scitmBkt[]  PROGMEM = { &siBracketing, &siBktEV, &siBktStep };

Screen                scrBktSet(3, (ScreenItem*)scitmBkt);

//--- (6) Interval Timer Screen ---------------------------------------------------------------

ScreenItem            siIntTimer(0, 0, 16, false,  (const char*)&msgIntTimer);

ScreenItem            siHourInt(3, 1, 2, false, &diHourInt);

ScreenItem            siMinInt (6, 1, 2, false, &diMinInt);

ScreenItem            siSecInt (9, 1, 2, false, &diSecInt);

ScreenItem            *scitmIntTimerSet[]  PROGMEM = { &siIntTimer, &siHourInt, &siMinInt, &siSecInt };

Screen                scrIntTimerSet(4, (ScreenItem*)scitmIntTimerSet);

//--- (7) Run Screen ---------------------------------------------------------------------------

TimeSpanDataItem         diLeftTimer(0);

TimeSpanDataItem         diIntTimer(0);

ScreenItem            siRunLeftTime( 0, 0, 8, false,  &diLeftTimer);

ScreenItem            siRunIntTime( 0, 1, 8, false,  &diIntTimer);

ScreenItem            siRunFramesLeft ( 10, 0, 4, false,  &diFramesLeft);

ScreenItem            siAbort(10, 1, 5, false,  (const char*)&msgAbort);

ScreenItem            *scitmRun[]  PROGMEM = { &siRunLeftTime, &siRunIntTime, &siRunFramesLeft, &siAbort };

Screen                scrRun(4, (ScreenItem*)scitmRun);

//--- (8) Camera Settings Screen ---------------------------------------------------------------

DIT_MODE              diMode(0, ModeTitles);

DIT_APERTURE          diAperture(0, ApertureTitles);

DIT_WB                diWb(0, WbTitles);

DIT_SHUTTER_SPEED     diShutterSpeed(0, ShutterSpeedTitles);

DIT_PSTYLE            diPStyle(0, PStyleTitles);

DIT_ISO               diIso(0, IsoTitles);

DIT_EXPCOMP           diExpComp(0, ExpCompTitles);

ScreenItem            siMode        ( 0, 0, 3, false,  &diMode);

ScreenItem            siAperture    ( 0, 1, 3, false,  &diAperture);

ScreenItem            siWb          ( 4, 0, 3, false,  &diWb);

ScreenItem            siShutterSpeed( 4, 1, 4, false,  &diShutterSpeed);

ScreenItem            siPStyle      ( 8, 0, 3, false,  &diPStyle);

ScreenItem            siIso         (12, 0, 4, false,  &diIso);

ScreenItem            siExpComp     ( 9, 1, 6, false,  &diExpComp);

ScreenItem            *scitmSettings[]  PROGMEM = { &siMode, &siAperture, &siWb, &siShutterSpeed, &siPStyle, &siIso, &siExpComp };

Screen                scrSettings(7, (ScreenItem*)scitmSettings);

IntSpin<DIT_TIMER_DIGIT_PAIR, uint8_t>    hourSpinSelf(0, 99, 1, &diHourSelf, NULL);

IntSpin<DIT_TIMER_DIGIT_PAIR, uint8_t>    minSpinSelf(0, 99, 1, &diMinSelf, NULL);

IntSpin<DIT_TIMER_DIGIT_PAIR, uint8_t>    secSpinSelf(0, 99, 1, &diSecSelf, NULL);

IntSpin<DIT_TIMER_DIGIT_PAIR, uint8_t>    hourSpinInt(0, 99, 1, &diHourInt, NULL);

IntSpin<DIT_TIMER_DIGIT_PAIR, uint8_t>    minSpinInt(0, 99, 1, &diMinInt, NULL);

IntSpin<DIT_TIMER_DIGIT_PAIR, uint8_t>    secSpinInt(0, 99, 1, &diSecInt, NULL);

void SpinSetAperture(DataItemBase *data_item)

{

    Eos.SetProperty(EOS_DPC_Aperture, ((DIT_APERTURE*)data_item)->Get());

};

void SpinSetShutterSpeed(DataItemBase *data_item)

{

    Eos.SetProperty(EOS_DPC_ShutterSpeed, ((DIT_SHUTTER_SPEED*)data_item)->Get());

};

void SpinSetWb(DataItemBase *data_item)

{

    Eos.SetProperty(EOS_DPC_WhiteBalance, ((DIT_WB*)data_item)->Get());

};

void SpinSetPStyle(DataItemBase *data_item)

{

    Eos.SetProperty(EOS_DPC_PictureStyle, ((DIT_PSTYLE*)data_item)->Get());

};

void SpinSetIso(DataItemBase *data_item)

{

    Eos.SetProperty(EOS_DPC_Iso, ((DIT_ISO*)data_item)->Get());

};

void SpinSetExpComp(DataItemBase *data_item)

{

    Eos.SetProperty(EOS_DPC_ExposureCompensation, ((DIT_EXPCOMP*)data_item)->Get());

};

void SpinUpdateBktStepValues(DataItemBase *data_item);

void SpinUpdateBktStep(DataItemBase *data_item);

EEPROMListIntSpin<DIT_APERTURE, VT_APERTURE>         spinAperture(&vlAperture, &diAperture, &SpinSetAperture);

EEPROMListIntSpin<DIT_SHUTTER_SPEED, VT_SHSPEED>     spinShutterSpeed(&vlShutterSpeed, &diShutterSpeed, &SpinSetShutterSpeed);

EEPROMListIntSpin<DIT_WB, VT_WB>                     spinWb(&vlWhiteBalance, &diWb, &SpinSetWb);

EEPROMListIntSpin<DIT_PSTYLE, VT_PSTYLE>             spinPStyle(&vlPictureStyle, &diPStyle, &SpinSetPStyle);

EEPROMListIntSpin<DIT_ISO, VT_ISO>                   spinIso(&vlIso, &diIso, &SpinSetIso);

EEPROMListIntSpin<EXP_COMP_DATA_ITEM, VT_EXPCOMP>    spinExpComp(&vlExpCompensation, &diExpComp, &SpinSetExpComp);

EEPROMListIntSpin<EXP_COMP_DATA_ITEM, VT_EXPCOMP>    spinBktEV  (&vlExpCompensation, &diBktEV, &SpinUpdateBktStepValues);

BKT_STEP_VALUE_LIST  vlExpCompStep;

SRAMListIntSpin<EXP_COMP_DATA_ITEM, VT_EXPCOMP, BKT_STEP_VALUE_LIST>      spinBktStep(&vlExpCompStep, &diBktStep, &SpinUpdateBktStep);

void SpinUpdateBktStepValues(DataItemBase *data_item)

{

    uint8_t cur_value = ((EXP_COMP_DATA_ITEM*)data_item)->Get();

    vlExpCompStep.SetSize(0);

    // Check value for zerro. Exit on zerro.

    if (cur_value == 0)

        return;

    // Calculate negative and positive values of expo compensation

    uint8_t negative_value = (cur_value & 0x80) ? cur_value : ~(cur_value - 1);

    uint8_t positive_value = (cur_value & 0x80) ? ~(cur_value - 1) : cur_value;

    // Get indices of negative and positive expo compensation values

    uint16_t negative_index = vlExpCompensation.GetValueIndex(negative_value);

    uint16_t positive_index = vlExpCompensation.GetValueIndex(positive_value);

    nBktNegativeIndex = negative_index;

    nBktPositiveIndex = positive_index;

    // Calculate interval length

    uint16_t len = positive_index - negative_index;

    // Calculate zerro value index

    uint16_t zerro_index = vlExpCompensation.GetValueIndex(0);

    // Calculate positive index offset

    uint16_t zerro_based_offset = positive_index - zerro_index;

   // Calculate all possible interval indices

    for (uint16_t i = zerro_based_offset, j = positive_index; i>0; i--, j--)

    {

        // Insert values into the list

        if (len % i == 0)

            vlExpCompStep.Append(vlExpCompensation.Get(j));

    }

    diBktStep.Set(cur_value);

    diBktStep.SetUpdated(true);

};

void SpinUpdateBktStep(DataItemBase *data_item)

{

    uint8_t cur_value = ((EXP_COMP_DATA_ITEM*)data_item)->Get();

    nBktStep = vlExpCompensation.GetValueIndex(cur_value) - vlExpCompensation.GetValueIndex(0);

};

void MenuExit();

void MenuSetAperture();

void MenuSetShutterSpeed();

void MenuSetWb();

void MenuSetPStyle();

void MenuSetIso();

void MenuSetExpComp();

extern Menu mainMenu;

//--- Camera Settings Menu -----------------------------------------------------------------

MenuItem              settingsMenuItems[] = { {&siMode, &MenuExit}, {&siAperture, &MenuSetAperture}, {&siWb, &MenuSetWb}, {&siShutterSpeed, &MenuSetShutterSpeed}, {&siPStyle, &MenuSetPStyle}, {&siIso, &MenuSetIso}, {&siExpComp, &MenuSetExpComp} };

Menu                  settingsMenu(8, 7, settingsMenuItems, 0, &mainMenu);

void MenuSetAperture() { spinAperture.SetReturnState(&settingsMenu); StateMachine::SetState(&spinAperture); };

void MenuSetShutterSpeed() { spinShutterSpeed.SetReturnState(&settingsMenu); StateMachine::SetState(&spinShutterSpeed); };

void MenuSetWb(){ spinWb.SetReturnState(&settingsMenu); StateMachine::SetState(&spinWb); };

void MenuSetPStyle(){ spinPStyle.SetReturnState(&settingsMenu); StateMachine::SetState(&spinPStyle); };

void MenuSetIso(){ spinIso.SetReturnState(&settingsMenu); StateMachine::SetState(&spinIso); };

void MenuSetExpComp(){ spinExpComp.SetReturnState(&mainMenu); StateMachine::SetState(&spinExpComp); };

//--- Self Timer Menu ----------------------------------------------------------------------

void MenuSelfSetH();

void MenuSelfSetM();

void MenuSelfSetS();

extern Menu timerSettingsMenu;

MenuItem              selfSetMenuItems[] = { {&siHourSelf, &MenuSelfSetH}, {&siMinSelf, &MenuSelfSetM}, {&siSecSelf, &MenuSelfSetS} };

Menu                  selfSetMenu(3, 3, selfSetMenuItems, 0, &timerSettingsMenu);

void MenuSelfSetH() { hourSpinSelf.SetReturnState(&selfSetMenu); StateMachine::SetState(&hourSpinSelf); };

void MenuSelfSetM() { minSpinSelf.SetReturnState(&selfSetMenu); StateMachine::SetState(&minSpinSelf); };

//--- Timer Settings Menu ------------------------------------------------------------------

void MenuSelf();

void MenuBkt();

void MenuFrames();

void MenuInterval();

void MenuExit();

void MenuRun();

MenuItem              timerSettingsMenuItems[] = { {&siSelf, &MenuSelf}, {&siFrames, &MenuFrames}, {&siBkt, &MenuBkt}, {&siInterval, &MenuInterval}, {&siRun, &MenuRun}, {&siExit, &MenuExit} };

Menu                  timerSettingsMenu(2, 6, timerSettingsMenuItems, 0, &mainMenu);

void MenuSelfSetS() { secSpinSelf.SetReturnState(&timerSettingsMenu); StateMachine::SetState(&secSpinSelf); };

void MenuSelf()     { StateMachine::SetState(&selfSetMenu); };

void MenuBktSetStep();

void MenuBktStepExit();

MenuItem              bktSetMenuItems[] = { {&siBktEV, &MenuBktSetStep}, {&siBktStep, &MenuBktStepExit} };

Menu                  bktSetMenu(5, 2, bktSetMenuItems, 0, &timerSettingsMenu);

void MenuBktSetStep()

{

    spinBktEV.SetReturnState(&bktSetMenu);

    if (vlExpCompensation.GetSize())

        StateMachine::SetState(&spinBktEV);

};

void MenuBktStepExit()

{

    spinBktStep.SetReturnState(&timerSettingsMenu);

    if (vlExpCompensation.GetSize())

        StateMachine::SetState(&spinBktStep);

};

void MenuBkt()

{

    if (vlExpCompensation.GetSize())

        StateMachine::SetState(&bktSetMenu);

};

IntSpin<IntDataItem<uint16_t, 5>, int16_t>  framesSpin(0, 9999, 1, &diFramesCount, NULL);

void MenuFrames()   { framesSpin.SetReturnState(&timerSettingsMenu); Screen::Set(4); StateMachine::SetState(&framesSpin); };

void MenuIntSetH();

void MenuIntSetM();

void MenuIntSetS();

MenuItem              intSetMenuItems[] = { {&siHourInt, &MenuIntSetH}, {&siMinInt, &MenuIntSetM}, {&siSecInt, &MenuIntSetS} };

Menu                  intSetMenu(6, 3, intSetMenuItems, 0, &timerSettingsMenu);

void MenuIntSetH() { hourSpinInt.SetReturnState(&intSetMenu); StateMachine::SetState(&hourSpinInt); };

void MenuIntSetM() { minSpinInt.SetReturnState(&intSetMenu); StateMachine::SetState(&minSpinInt); };

void MenuIntSetS() { secSpinInt.SetReturnState(&timerSettingsMenu); StateMachine::SetState(&secSpinInt); };

void MenuInterval() { StateMachine::SetState(&intSetMenu); };

void MenuRunAbort()

{

    hdrCapture.PostEvent(&evtAbort);

    diFramesLeft.Set(0);

    StateMachine::SetState(&timerSettingsMenu);

};

MenuItem              runMenuItems[] = { {&siAbort, &MenuRunAbort} };

Menu                  runMenu(7, 1, runMenuItems, 0);

void MenuRun()

{

    if (!diFramesCount.Get())

        return;

    uint32_t  intr_timeout = ((uint32_t)diHourInt.Get() * 3600 + (uint32_t)diMinInt.Get() * 60 + (uint32_t)diSecInt.Get());

    uint32_t  self_timeout = ((uint32_t)diHourSelf.Get() * 3600 + (uint32_t)diMinSelf.Get() * 60 + (uint32_t)diSecSelf.Get());

    diFramesLeft.Set(diFramesCount.Get());

    diLeftTimer.Set(self_timeout);

    diIntTimer.Set(intr_timeout);

    SetEvt  setEvt;

    setEvt.sig     = SET_FRAMES_SIG;

    setEvt.value   = diFramesCount.Get();

    hdrCapture.dispatch(&setEvt);

    setEvt.sig     = SET_FRAME_TIMEOUT_SIG;

    setEvt.value   = intr_timeout;

    hdrCapture.dispatch(&setEvt);

    setEvt.sig     = SET_SELF_TIMEOUT_SIG;

    setEvt.value   = self_timeout;

    hdrCapture.dispatch(&setEvt);

    SetBktEvt          setBktEvt;

    setBktEvt.sig       = SET_BRACKETING_SIG;

    setBktEvt.step      = nBktStep;

    setBktEvt.negative  = nBktNegativeIndex;

    setBktEvt.positive  = nBktPositiveIndex;

    hdrCapture.dispatch(&setBktEvt);

    StateMachine::SetState(&runMenu);

    setEvt.sig     = RUN_SIG;

    hdrCapture.dispatch(&setEvt);

};

//--- Main Menu ----------------------------------------------------------------------------

void MenuIntervalometer() { StateMachine::SetState(&timerSettingsMenu); };

void MenuSettings()

{

    StateMachine::SetState(&settingsMenu);

};

MenuItem              mainMenuItems[] = { {&siIntervalometer, &MenuIntervalometer}, {&siSettings, &MenuSettings} };

Menu                  mainMenu(1, 2, mainMenuItems, 0);

void MenuExit()     { StateMachine::SetState(&mainMenu); };

class DummyMenu : public StateMachine

{

public:

    virtual bool OnInitialState()

    {

        Screen::Set(0);

        return true;

    };

} DisconnectedState;

void CamStateHandlers::OnDeviceDisconnectedState(PTP *ptp)

{

    if (stateConnected)

    {

        stateConnected = false;

        PTPPollTimer.Disable();

        StateMachine::SetState(&DisconnectedState);

    }

}

void CamStateHandlers::OnDeviceInitializedState(PTP *ptp)

{

    if (!stateConnected)

    {

        stateConnected = true;

        PTPPollTimer.Enable();

        StateMachine::SetState(&mainMenu);

    }

    hdrCapture.Run();

}

void CamHDRCapture::OnFrameCaptured(uint16_t left)

{

    diFramesLeft.Set(left);

    if (!left)

        StateMachine::SetState(&timerSettingsMenu);

}

void CamHDRCapture::OnSelfTimerProgress(uint32_t left)

{

    diLeftTimer.Set(left);

}

void CamHDRCapture::OnIntrTimerProgress(uint32_t left)

{

    diIntTimer.Set(left);

}

void OnControlTimer()

{

    ExtControls.CheckControls();

    hdrCapture.PostEvent(&evtTick);

    Screen::Run(&LCD);

}

void OnPTPPollTimer()

{

    EOSEventParser    prs;

    Eos.EventCheck(&prs);

    diLeftTimer.SetUpdated(true);

    diIntTimer.SetUpdated(true);

}

void setup()

{

    StateMachine::SetState(&DisconnectedState);

#ifdef PTPDEBUG

    Serial.begin(115200);

#endif

    Eos.Setup();

    delay( 200 );

    // set up the LCD's number of rows and columns:

    LCD.begin(16, 2);

    LCD.clear();

    LCD.home();

    LCD.setCursor(0,0);

    PTPPollTimer.Set(OnPTPPollTimer, 300);

    // 1ms is the perfect interval for encoder polling

    ControlTimer.Set(OnControlTimer, 1);

    ControlTimer.Enable();

    evtTick.sig = TICK_MILLIS_SIG;

    evtAbort.sig = ABORT_SIG;

    hdrCapture.init();

#ifdef PTPDEBUG

    Serial.println("Start");

#endif

}

void loop()

{

    Eos.Task();

    PTPPollTimer.Run();

    ControlTimer.Run();

}