/C-OSD/arducam-osd/libraries/PTPCamera/examples/PSRemoteSA/PSRemoteSA.pde |
---|
0,0 → 1,114 |
/* 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() |
{ |
pinMode(6, OUTPUT); //OSD CS |
digitalWrite(6, HIGH); //Disablibg OSD CS |
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/PSRemoteSA/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/PSRemoteSA/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/PSRemoteSA/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/PSRemoteSA/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/PSRemoteSA/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/PSRemoteSA/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__ |