| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/PSRemote.pde |
|---|
| 0,0 → 1,110 |
| /* Canon Powershot control terminal */ |
| //#include <Spi.h> |
| #include <Max3421e.h> |
| #include <Usb.h> |
| #include <simpletimer.h> |
| #include <ptp.h> |
| #include <canonps.h> |
| #include <qep_port.h> |
| #include <valuelist.h> |
| #include <psvaluetitles.h> |
| #include "ptpdpparser.h" |
| #include "ptpobjinfoparser.h" |
| #include "pseventparser.h" |
| #include "psconsole.h" |
| #define DEV_ADDR 1 |
| // Canon PowerShot S3 IS |
| #define DATA_IN_EP 1 |
| #define DATA_OUT_EP 2 |
| #define INTERRUPT_EP 3 |
| #define CONFIG_NUM 1 |
| class CamStateHandlers : public PSStateHandlers |
| { |
| enum CamStates { stInitial, stDisconnected, stConnected }; |
| CamStates stateConnected; |
| public: |
| CamStateHandlers() : stateConnected(stInitial) |
| { |
| }; |
| virtual void OnDeviceDisconnectedState(PTP *ptp); |
| virtual void OnDeviceInitializedState(PTP *ptp); |
| }; |
| CamStateHandlers CamStates; |
| SimpleTimer ControlTimer, PTPPollTimer; |
| CanonPS Ps(DEV_ADDR, DATA_IN_EP, DATA_OUT_EP, INTERRUPT_EP, CONFIG_NUM, &CamStates); |
| QEvent evtTick, evtAbort; |
| PSConsole psConsole; |
| void CamStateHandlers::OnDeviceDisconnectedState(PTP *ptp) |
| { |
| if (stateConnected == stConnected || stateConnected == stInitial) |
| { |
| stateConnected = stDisconnected; |
| PTPPollTimer.Disable(); |
| Notify(PSTR("Camera disconnected.\r\n")); |
| if (stateConnected == stConnected) |
| psConsole.dispatch(&evtTick); |
| } |
| } |
| void CamStateHandlers::OnDeviceInitializedState(PTP *ptp) |
| { |
| if (stateConnected == stDisconnected || stateConnected == stInitial) |
| { |
| stateConnected = stConnected; |
| PTPPollTimer.Enable(); |
| psConsole.dispatch(&evtTick); |
| } |
| int8_t index = psConsole.MenuSelect(); |
| if (index >= 0) |
| { |
| MenuSelectEvt menu_sel_evt; |
| menu_sel_evt.sig = MENU_SELECT_SIG; |
| menu_sel_evt.item_index = index; |
| psConsole.dispatch(&menu_sel_evt); // dispatch the event |
| } |
| } |
| void OnPTPPollTimer() |
| { |
| PSEventParser prs; |
| Ps.EventCheck(&prs); |
| if (uint32_t handle = prs.GetObjHandle()) |
| { |
| PTPObjInfoParser inf; |
| Ps.GetObjectInfo(handle, &inf); |
| } |
| } |
| void setup() |
| { |
| Serial.begin(115200); |
| Ps.Setup(); |
| delay( 200 ); |
| PTPPollTimer.Set(OnPTPPollTimer, 300); |
| evtTick.sig = TICK_SIG; |
| // evtAbort.sig = ABORT_SIG; |
| psConsole.init(); |
| Serial.println("Start"); |
| } |
| void loop() |
| { |
| Ps.Task(); |
| PTPPollTimer.Run(); |
| } |
| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/psconsole.cpp |
|---|
| 0,0 → 1,475 |
| #include "psconsole.h" |
| #include <psvaluetitles.h> |
| #include <valuelist.h> |
| extern CanonPS Ps; |
| /* fixes avr-gcc incompatibility with virtual destructors */ |
| void operator delete( void *p ) {} |
| const char* menuMain[] = {"Capture", "View Settings", "Change Settings", "Viewfinder On", "Viewfinder Off"}; |
| const char* menuChangeSettings[] = {"Mode", "Aperture", "Shutter Speed", "WB", "ISO", "Exp Comp", "CamOutput", "Zoom"}; |
| const char* menuUpDown[] = {"<<", ">>"}; |
| #define MAIN_MENU_COUNT sizeof(menuMain) / sizeof(const char*) |
| #define CHSET_MENU_COUNT sizeof(menuChangeSettings) / sizeof(const char*) |
| #define UPDWN_MENU_COUNT sizeof(menuUpDown) / sizeof(const char*) |
| void PrintMode() |
| { |
| Notify(PSTR("Mode:")); |
| PrintValueTitle<uint8_t, VT_MODE, VT_MODE_COUNT, VT_MODE_TEXT_LEN>((PTP*)&Ps, PS_DPC_ShootingMode, ModeTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintAperture() |
| { |
| Notify(PSTR("F:")); |
| PrintValueTitle<uint16_t, VT_APERTURE, VT_APT_COUNT, VT_APT_TEXT_LEN>((PTP*)&Ps, PS_DPC_Aperture, ApertureTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintShutterSpeed() |
| { |
| Notify(PSTR("T:")); |
| PrintValueTitle<uint16_t, VT_SHSPEED, VT_SHSPEED_COUNT, VT_SHSPEED_TEXT_LEN>((PTP*)&Ps, PS_DPC_ShutterSpeed, ShutterSpeedTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintWB() |
| { |
| Notify(PSTR("WB:")); |
| PrintValueTitle<uint8_t, VT_WB, VT_WB_COUNT, VT_WB_TEXT_LEN>((PTP*)&Ps, PS_DPC_WhiteBalance, WbTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintIso() |
| { |
| Notify(PSTR("ISO:")); |
| PrintValueTitle<uint16_t, VT_ISO, VT_ISO_COUNT, VT_ISO_TEXT_LEN>((PTP*)&Ps, PS_DPC_ISOSpeed, IsoTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintExpCompensation() |
| { |
| Notify(PSTR("ExpComp:")); |
| PrintValueTitle<uint8_t, VT_EXPCOMP, VT_EXPCOMP_COUNT, VT_EXPCOMP_TEXT_LEN>((PTP*)&Ps, PS_DPC_ExpCompensation, ExpCompTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintCamOutput() |
| { |
| Notify(PSTR("CamOutput:")); |
| PrintValueTitle<uint8_t, VT_CAMOUTPUT, VT_CAMOUTPUT_COUNT, VT_CAMOUTPUT_TEXT_LEN>((PTP*)&Ps, PS_DPC_CameraOutput, CamOutputTitles); |
| Notify(PSTR("\r\n")); |
| } |
| void PrintZoom() |
| { |
| uint16_t val = 0; |
| Notify(PSTR("Zoom:")); |
| if (Ps.GetDevicePropValue(PS_DPC_Zoom, (uint16_t&)val) == PTP_RC_OK) |
| PrintHex<uint16_t>(val); |
| Notify(PSTR("\r\n")); |
| } |
| void PSConsole::ShowParams() |
| { |
| PrintMode(); |
| PrintAperture(); |
| PrintShutterSpeed(); |
| PrintWB(); |
| PrintIso(); |
| PrintExpCompensation(); |
| PrintCamOutput(); |
| PrintZoom(); |
| } |
| QState PSConsole::Initial(PSConsole *me, QEvent const *e) |
| { |
| return Q_TRAN(&PSConsole::Inactive); |
| } |
| QState PSConsole::Inactive(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| Notify(PSTR("Inactive\r\n")); |
| return Q_HANDLED(); |
| case TICK_SIG: |
| return Q_TRAN(&PSConsole::Active); |
| } |
| return Q_SUPER(QHsm::top); |
| } |
| QState PSConsole::Active(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| Notify(PSTR("Active\r\n")); |
| return Q_HANDLED(); |
| case Q_INIT_SIG: |
| return Q_TRAN(&PSConsole::MainMenu); |
| case TICK_SIG: |
| return Q_TRAN(&PSConsole::Inactive); |
| } |
| return Q_SUPER(QHsm::top); |
| } |
| void PSConsole::PrintMenuTitles(uint8_t count, const char **menu) |
| { |
| Serial.println(""); |
| for (uint8_t i=0; i<=count; i++) |
| { |
| Serial.print(i, DEC); |
| Serial.print(". "); |
| if (i == 0) |
| Serial.println("<..>"); |
| else |
| Serial.println(menu[i-1]); |
| } |
| Serial.println(""); |
| } |
| QState PSConsole::MainMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(MAIN_MENU_COUNT, menuMain); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| PrintMenuTitles(MAIN_MENU_COUNT, menuMain); |
| return Q_HANDLED(); |
| case 1: |
| Ps.SetDevicePropValue(PS_DPC_CaptureTransferMode, (uint16_t)0x0D); |
| Ps.Capture(); |
| return Q_HANDLED(); |
| case 2: |
| ShowParams(); |
| PrintMenuTitles(MAIN_MENU_COUNT, menuMain); |
| return Q_HANDLED(); |
| case 3: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 4: |
| Ps.Operation(PS_OC_ViewfinderOn); |
| return Q_HANDLED(); |
| case 5: |
| Ps.Operation(PS_OC_ViewfinderOff); |
| return Q_HANDLED(); |
| } |
| } |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeSettingsMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(CHSET_MENU_COUNT, menuChangeSettings); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::MainMenu); |
| case 1: // Aperture |
| return Q_TRAN(&PSConsole::ChangeModeMenu); |
| case 2: // Aperture |
| return Q_TRAN(&PSConsole::ChangeApertureMenu); |
| case 3: // Shutter Speed |
| return Q_TRAN(&PSConsole::ChangeShutterSpeedMenu); |
| case 4: // White Balance |
| return Q_TRAN(&PSConsole::ChangeWBMenu); |
| case 5: // ISO |
| return Q_TRAN(&PSConsole::ChangeIsoMenu); |
| case 6: // Exposure Compensation |
| return Q_TRAN(&PSConsole::ChangeExpCompMenu); |
| case 7: // Camera Output |
| return Q_TRAN(&PSConsole::ChangeCamOutputMenu); |
| case 8: // Zoom |
| return Q_TRAN(&PSConsole::ChangeZoomMenu); |
| } // switch |
| } |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeModeMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintMode(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| uint8_t new_value; |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint8_t>((PTP*)&Ps, PS_DPC_ShootingMode); |
| PrintMode(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint8_t>((PTP*)&Ps, PS_DPC_ShootingMode); |
| PrintMode(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeApertureMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintAperture(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| uint8_t new_value; |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint16_t>((PTP*)&Ps, PS_DPC_Aperture); |
| PrintAperture(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint16_t>((PTP*)&Ps, PS_DPC_Aperture); |
| PrintAperture(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeShutterSpeedMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintShutterSpeed(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| uint8_t new_value; |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint16_t>((PTP*)&Ps, PS_DPC_ShutterSpeed); |
| PrintShutterSpeed(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint16_t>((PTP*)&Ps, PS_DPC_ShutterSpeed); |
| PrintShutterSpeed(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeWBMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintWB(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| uint8_t new_value; |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint8_t>((PTP*)&Ps, PS_DPC_WhiteBalance); |
| PrintWB(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint8_t>((PTP*)&Ps, PS_DPC_WhiteBalance); |
| PrintWB(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeIsoMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintIso(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| uint8_t new_value; |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint16_t>((PTP*)&Ps, PS_DPC_ISOSpeed); |
| PrintIso(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint16_t>((PTP*)&Ps, PS_DPC_ISOSpeed); |
| PrintIso(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeExpCompMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintExpCompensation(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| uint8_t new_value; |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 1: |
| StepUp<uint8_t>((PTP*)&Ps, PS_DPC_ExpCompensation); |
| PrintExpCompensation(); |
| return Q_HANDLED(); |
| case 2: |
| StepDown<uint8_t>((PTP*)&Ps, PS_DPC_ExpCompensation); |
| PrintExpCompensation(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeCamOutputMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintCamOutput(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint8_t>((PTP*)&Ps, PS_DPC_CameraOutput); |
| PrintCamOutput(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint8_t>((PTP*)&Ps, PS_DPC_CameraOutput); |
| PrintCamOutput(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| QState PSConsole::ChangeZoomMenu(PSConsole *me, QEvent const *e) |
| { |
| switch (e->sig) |
| { |
| case Q_ENTRY_SIG: |
| PrintMenuTitles(UPDWN_MENU_COUNT, menuUpDown); |
| PrintZoom(); |
| return Q_HANDLED(); |
| case MENU_SELECT_SIG: |
| { |
| switch (((MenuSelectEvt*)e)->item_index) |
| { |
| case 0: |
| return Q_TRAN(&PSConsole::ChangeSettingsMenu); |
| case 2: |
| StepUp<uint16_t>((PTP*)&Ps, PS_DPC_Zoom); |
| PrintZoom(); |
| return Q_HANDLED(); |
| case 1: |
| StepDown<uint16_t>((PTP*)&Ps, PS_DPC_Zoom); |
| PrintZoom(); |
| return Q_HANDLED(); |
| } // switch (((MenuSelectEvt*)e)->item_index) |
| } // case MENU_SELECT_SIG: |
| } |
| return Q_SUPER(&PSConsole::Active); |
| } |
| static TickEvt tick_evt; |
| int8_t PSConsole::MenuSelect() |
| { |
| if( !Serial.available()) |
| return -1; |
| uint8_t char_count = 0; |
| uint8_t index = 0; |
| while (Serial.available() > 0 && char_count < 2) |
| { |
| uint8_t key = Serial.read(); |
| key -= '0'; |
| if (index) |
| { |
| uint8_t tmp = index; |
| // index *= 10; |
| index <<= 3; |
| index += tmp; |
| index += tmp; |
| } |
| index += key; |
| char_count ++; |
| } |
| return (char_count) ? (int8_t)index : (int8_t)-1; |
| } |
| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/psconsole.h |
|---|
| 0,0 → 1,56 |
| #if !defined(__PSCONSOLE_H__) |
| #define __PSCONSOLE_H__ |
| #include <inttypes.h> |
| #include <avr/pgmspace.h> |
| #include <qep_port.h> |
| #include <WProgram.h> |
| #include <canonps.h> |
| #include "ptpdpparser.h" |
| enum TextMenuSignals |
| { |
| MENU_SELECT_SIG = Q_USER_SIG, |
| TICK_SIG |
| }; |
| struct TickEvt : public QEvent |
| { |
| uint8_t fine_time; // the fine 1/10 s counter |
| }; |
| struct MenuSelectEvt : public QEvent |
| { |
| uint8_t item_index; |
| }; |
| class PSConsole : public QHsm |
| { |
| static void PrintMenuTitles(uint8_t count, const char **menu); |
| static void ShowParams(); |
| public: |
| PSConsole() |
| : QHsm((QStateHandler)&PSConsole::Initial) |
| {}; |
| int8_t MenuSelect(); |
| protected: |
| static QState Initial(PSConsole *me, QEvent const *e); |
| static QState Inactive(PSConsole *me, QEvent const *e); |
| static QState Active(PSConsole *me, QEvent const *e); |
| static QState MainMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeSettingsMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeModeMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeApertureMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeShutterSpeedMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeWBMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeImageModeMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeExpCompMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeIsoMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeCamOutputMenu(PSConsole *me, QEvent const *e); |
| static QState ChangeZoomMenu(PSConsole *me, QEvent const *e); |
| }; |
| #endif // __PSCONSOLE_H__ |
| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/pseventparser.cpp |
|---|
| 0,0 → 1,85 |
| #include "pseventparser.h" |
| void PSEventParser::Parse(const uint16_t len, const uint8_t *pbuf, const uint32_t &offset) |
| { |
| uint16_t cntdn = (uint16_t)len; |
| uint8_t *p = (uint8_t*)pbuf; |
| switch (nStage) |
| { |
| case 0: |
| p += 12; |
| cntdn -= 12; |
| if (!cntdn) |
| return; |
| nStage ++; |
| case 1: |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 2: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| //PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 3: |
| //Notify(PSTR("\r\nNumber of Fields:\t")); |
| theBuffer.valueSize = 2; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 4: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| //PrintHex<uint16_t>(*((uint16_t*)theBuffer.pValue)); |
| nStage ++; |
| case 5: |
| //Notify(PSTR("\r\nEvent Code:\t")); |
| theBuffer.valueSize = 2; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 6: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| eventCode = *((uint16_t*)theBuffer.pValue); |
| //PrintHex<uint16_t>(*((uint16_t*)theBuffer.pValue)); |
| nStage ++; |
| case 7: |
| //Notify(PSTR("\r\nTransaction ID:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 8: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| //PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 9: |
| if (eventCode == PTP_EC_ObjectAdded) |
| Notify(PSTR("\r\nObject Added:\t\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 10: |
| if (eventCode == PTP_EC_ObjectAdded) |
| { |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| objHandle = *((uint32_t*)theBuffer.pValue); |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| Notify(PSTR("\r\n")); |
| } |
| if (eventCode == PTP_EC_CaptureComplete) |
| Notify(PSTR("\r\nCapture complete.\r\n")); |
| nStage ++; |
| case 11: |
| nStage = 0; |
| } |
| } |
| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/pseventparser.h |
|---|
| 0,0 → 1,29 |
| #ifndef __PSEVENTPARSER_H__ |
| #define __PSEVENTPARSER_H__ |
| #include <inttypes.h> |
| #include <avr/pgmspace.h> |
| #include "ptpcallback.h" |
| #include "ptpdebug.h" |
| #include "canonps.h" |
| class PSEventParser : public PTPReadParser |
| { |
| MultiValueBuffer theBuffer; |
| uint32_t varBuffer; |
| uint8_t nStage; |
| uint16_t eventCode; |
| uint32_t objHandle; |
| MultiByteValueParser valueParser; |
| public: |
| PSEventParser() : nStage(0), varBuffer(0), objHandle(0) |
| { |
| theBuffer.pValue = &varBuffer; |
| }; |
| uint32_t GetObjHandle() { return objHandle; }; |
| virtual void Parse(const uint16_t len, const uint8_t *pbuf, const uint32_t &offset); |
| }; |
| #endif // __PSEVENTPARSER_H__ |
| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/ptpobjinfoparser.cpp |
|---|
| 0,0 → 1,298 |
| #include "ptpobjinfoparser.h" |
| const char* PTPObjInfoParser::acNames[] PROGMEM = |
| { |
| msgUndefined, |
| msgAssociation, |
| msgScript, |
| msgExecutable, |
| msgText, |
| msgHTML, |
| msgDPOF, |
| msgAIFF, |
| msgWAV, |
| msgMP3, |
| msgAVI, |
| msgMPEG, |
| msgASF, |
| msgQT |
| }; |
| const char* PTPObjInfoParser::imNames[] PROGMEM = |
| { |
| msgUndefined, |
| msgEXIF_JPEG, |
| msgTIFF_EP, |
| msgFlashPix, |
| msgBMP, |
| msgCIFF, |
| msgUndefined_0x3806, |
| msgGIF, |
| msgJFIF, |
| msgPCD, |
| msgPICT, |
| msgPNG, |
| msgUndefined_0x380C, |
| msgTIFF, |
| msgTIFF_IT, |
| msgJP2, |
| msgJPX, |
| }; |
| void PTPObjInfoParser::PrintFormat(uint16_t op) |
| { |
| Serial.print(op, HEX); |
| Serial.print("\t"); |
| //Notify(msgTab); |
| if ((((op >> 8) & 0xFF) == 0x30) && ((op & 0xFF) <= (PTP_OFC_QT & 0xFF))) |
| Notify((char*)pgm_read_word(&acNames[(op & 0xFF)])); |
| else |
| if ((((op >> 8) & 0xFF) == 0x38) && ((op & 0xFF) <= (PTP_OFC_JPX & 0xFF))) |
| Notify((char*)pgm_read_word(&imNames[(op & 0xFF)])); |
| else |
| { |
| switch (op) |
| { |
| case MTP_OFC_Undefined_Firmware: |
| Notify(msgUndefined_Firmware); |
| break; |
| case MTP_OFC_Windows_Image_Format: |
| Notify(msgWindows_Image_Format); |
| break; |
| case MTP_OFC_Undefined_Audio: |
| Notify(msgUndefined_Audio); |
| break; |
| case MTP_OFC_WMA: |
| Notify(msgWMA); |
| break; |
| case MTP_OFC_OGG: |
| Notify(msgOGG); |
| break; |
| case MTP_OFC_AAC: |
| Notify(msgAAC); |
| break; |
| case MTP_OFC_Audible: |
| Notify(msgAudible); |
| break; |
| case MTP_OFC_FLAC: |
| Notify(msgFLAC); |
| break; |
| case MTP_OFC_Undefined_Video: |
| Notify(msgUndefined_Video); |
| break; |
| case MTP_OFC_WMV: |
| Notify(msgWMV); |
| break; |
| case MTP_OFC_MP4_Container: |
| Notify(msgMP4_Container); |
| break; |
| case MTP_OFC_MP2: |
| Notify(msgMP2); |
| break; |
| case MTP_OFC_3GP_Container: |
| Notify(msg3GP_Container); |
| break; |
| default: |
| Notify(PSTR("Vendor defined")); |
| } |
| } |
| Notify(PSTR("\r\n")); |
| } |
| void PTPObjInfoParser::Parse(const uint16_t len, const uint8_t *pbuf, const uint32_t &offset) |
| { |
| uint16_t cntdn = (uint16_t)len; |
| uint8_t *p = (uint8_t*)pbuf; |
| switch (nStage) |
| { |
| case 0: |
| p += 12; |
| cntdn -= 12; |
| nStage ++; |
| case 1: |
| Notify(PSTR("Storage ID:\t\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 2: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 3: |
| Notify(PSTR("\r\nObject Format:\t\t")); |
| theBuffer.valueSize = 2; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 4: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintFormat(*((uint16_t*)theBuffer.pValue)); |
| nStage ++; |
| case 5: |
| Notify(PSTR("Protection Status:\t")); |
| theBuffer.valueSize = 2; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 6: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint16_t>(*((uint16_t*)theBuffer.pValue)); |
| nStage ++; |
| case 7: |
| Notify(PSTR("\r\nObject Compressed Size:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 8: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 9: |
| Notify(PSTR("\r\nThumb Format:\t\t")); |
| theBuffer.valueSize = 2; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 10: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintFormat(*((uint16_t*)theBuffer.pValue)); |
| nStage ++; |
| case 11: |
| Notify(PSTR("Thumb Compressed Size:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 12: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 13: |
| Notify(PSTR("\r\nThumb Pix Width:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 14: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 15: |
| Notify(PSTR("\r\nThumb Pix Height:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 16: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 17: |
| Notify(PSTR("\r\nImage Pix Width:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 18: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 19: |
| Notify(PSTR("\r\nImage Pix Height:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 20: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 21: |
| Notify(PSTR("\r\nImage Bit Depth:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 22: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 23: |
| Notify(PSTR("\r\nParent Object:\t\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 24: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 25: |
| Notify(PSTR("\r\nAssociation Type:\t")); |
| theBuffer.valueSize = 2; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 26: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint16_t>(*((uint16_t*)theBuffer.pValue)); |
| nStage ++; |
| case 27: |
| Notify(PSTR("\r\nAssociation Desc:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 28: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 29: |
| Notify(PSTR("\r\nSequence Number:\t")); |
| theBuffer.valueSize = 4; |
| valueParser.Initialize(&theBuffer); |
| nStage ++; |
| case 30: |
| if (!valueParser.Parse(&p, &cntdn)) |
| return; |
| PrintHex<uint32_t>(*((uint32_t*)theBuffer.pValue)); |
| nStage ++; |
| case 31: |
| Notify(PSTR("\r\nFile Name:\t\t")); |
| arrayParser.Initialize(1, 2, &theBuffer); |
| nStage ++; |
| case 32: |
| if (!arrayParser.Parse(&p, &cntdn, (PTP_ARRAY_EL_FUNC)&PrintChar)) |
| return; |
| nStage ++; |
| case 33: |
| Notify(PSTR("\r\nCapture Date:\t\t")); |
| arrayParser.Initialize(1, 2, &theBuffer); |
| nStage ++; |
| case 34: |
| if (!arrayParser.Parse(&p, &cntdn, (PTP_ARRAY_EL_FUNC)&PrintChar)) |
| return; |
| nStage ++; |
| case 35: |
| Notify(PSTR("\r\nModification Date:\t")); |
| arrayParser.Initialize(1, 2, &theBuffer); |
| nStage ++; |
| case 36: |
| if (!arrayParser.Parse(&p, &cntdn, (PTP_ARRAY_EL_FUNC)&PrintChar)) |
| return; |
| nStage ++; |
| case 37: |
| Notify(PSTR("\r\nKeywords:\t")); |
| arrayParser.Initialize(1, 2, &theBuffer); |
| nStage ++; |
| case 38: |
| if (!arrayParser.Parse(&p, &cntdn, (PTP_ARRAY_EL_FUNC)&PrintChar)) |
| return; |
| Notify(PSTR("\r\n")); |
| nStage = 0; |
| } |
| } |
| /C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemote/ptpobjinfoparser.h |
|---|
| 0,0 → 1,83 |
| #ifndef __PTPOBJINFOPARSER_H__ |
| #define __PTPOBJINFOPARSER_H__ |
| #include <ptp.h> |
| #include <mtpconst.h> |
| #include <ptpcallback.h> |
| const char msgUndefined [] PROGMEM = "Undefined"; |
| // Ancillary formats |
| const char msgAssociation [] PROGMEM = "Association"; |
| const char msgScript [] PROGMEM = "Script"; |
| const char msgExecutable [] PROGMEM = "Executable"; |
| const char msgText [] PROGMEM = "Text"; |
| const char msgHTML [] PROGMEM = "HTML"; |
| const char msgDPOF [] PROGMEM = "DPOF"; |
| const char msgAIFF [] PROGMEM = "AIFF"; |
| const char msgWAV [] PROGMEM = "WAV"; |
| const char msgMP3 [] PROGMEM = "MP3"; |
| const char msgAVI [] PROGMEM = "AVI"; |
| const char msgMPEG [] PROGMEM = "MPEG"; |
| const char msgASF [] PROGMEM = "ASF"; |
| const char msgQT [] PROGMEM = "QT"; |
| // Image formats |
| const char msgEXIF_JPEG [] PROGMEM = "EXIF_JPEG"; |
| const char msgTIFF_EP [] PROGMEM = "TIFF_EP"; |
| const char msgFlashPix [] PROGMEM = "FlashPix"; |
| const char msgBMP [] PROGMEM = "BMP"; |
| const char msgCIFF [] PROGMEM = "CIFF"; |
| const char msgUndefined_0x3806 [] PROGMEM = "Undefined_0x3806"; |
| const char msgGIF [] PROGMEM = "GIF"; |
| const char msgJFIF [] PROGMEM = "JFIF"; |
| const char msgPCD [] PROGMEM = "PCD"; |
| const char msgPICT [] PROGMEM = "PICT"; |
| const char msgPNG [] PROGMEM = "PNG"; |
| const char msgUndefined_0x380C [] PROGMEM = "Undefined_0x380C"; |
| const char msgTIFF [] PROGMEM = "TIFF"; |
| const char msgTIFF_IT [] PROGMEM = "TIFF_IT"; |
| const char msgJP2 [] PROGMEM = "JP2"; |
| const char msgJPX [] PROGMEM = "JPX"; |
| // MTP Object Formats |
| const char msgUndefined_Firmware [] PROGMEM = "Undefined_Firmware"; |
| const char msgWindows_Image_Format [] PROGMEM = "Windows_Image_Format"; |
| const char msgUndefined_Audio [] PROGMEM = "Undefined_Audio"; |
| const char msgWMA [] PROGMEM = "WMA"; |
| const char msgOGG [] PROGMEM = "OGG"; |
| const char msgAAC [] PROGMEM = "AAC"; |
| const char msgAudible [] PROGMEM = "Audible"; |
| const char msgFLAC [] PROGMEM = "FLAC"; |
| const char msgUndefined_Video [] PROGMEM = "Undefined_Video"; |
| const char msgWMV [] PROGMEM = "WMV"; |
| const char msgMP4_Container [] PROGMEM = "MP4_Container"; |
| const char msgMP2 [] PROGMEM = "MP2"; |
| const char msg3GP_Container [] PROGMEM = "3GP_Container"; |
| class PTPObjInfoParser : public PTPReadParser |
| { |
| static const char* acNames[]; |
| static const char* imNames[]; |
| MultiValueBuffer theBuffer; |
| uint32_t varBuffer; |
| uint8_t nStage; |
| MultiByteValueParser valueParser; |
| PTPListParser arrayParser; |
| static void PrintChar(MultiValueBuffer *p) |
| { |
| if (((unsigned char*)p->pValue)[0]) |
| Serial.print(((unsigned char*)p->pValue)[0]); |
| }; |
| void PrintFormat(uint16_t op); |
| public: |
| PTPObjInfoParser() : nStage(0) { theBuffer.pValue = (uint8_t*)&varBuffer; }; |
| virtual void Parse(const uint16_t len, const uint8_t *pbuf, const uint32_t &offset); |
| }; |
| #endif // __PTPOBJINFOPARSER_H__ |