25 refactor canon eos support (#26)

* Refactor Canon EOS support.

Implement a Canon EOS base class and derive the M6 and RP from it.
Whilst here, refactor the focus button handling such that there is are
separate 'focusPress' and 'focusRelease' methods.

* Attempt to implement focus support for Canon EOS.

* Update readme for newly supported cameras.

* fix typo in #define (#27)

Co-authored-by: wolcano <martin.karas@gmail.com>

README.md

@@ -14,11 +14,13 @@ furble is developed as a PlatformIO project for the M5StickC and M5StickC Plus
 ## Supported Cameras
 
 The following devices have actually been tested and confirmed to work:
+- Fujifilm GFX100S ([@adrianuseless](https://github.com/adrianuseless))
 - Fujifilm X-S10 ([@dimitrij2k](https://github.com/dimitrij2k))
 - Fujifilm X-T200 ([@Cronkan](https://github.com/Cronkan))
 - Fujifilm X-T30
 - Fujifilm X100V
-- Canon EOS M6
+- Canon EOS M6 ([@tardisx](https://github.com/tardisx))
+- Canon EOS RP ([@wolcano](https://github.com/wolcano))
 
 ## Motivation
 
@@ -49,6 +51,7 @@ Reports of further confirmed working Fujifilm cameras are welcome.
 With access to a Canon EOS M6, I was able to implement support for it. Other
 Canon cameras might work, but I suspect the shutter control protocol will be
 different.
+@wolcano kindly implemented support for the Canon EOS RP.
 
 #### Protocol Reverse Engineering
 

lib/furble/CanonEOS.cpp

@@ -0,0 +1,185 @@
+#include <NimBLEAddress.h>
+#include <NimBLEAdvertisedDevice.h>
+#include <NimBLEDevice.h>
+#include <NimBLERemoteCharacteristic.h>
+#include <NimBLERemoteService.h>
+
+#include "Furble.h"
+
+namespace Furble {
+
+CanonEOS::CanonEOS(const void *data, size_t len) {
+ if (len != sizeof(eos_t))
+ throw;
+
+ const eos_t *eos = (eos_t *)data;
+ m_Name = std::string(eos->name);
+ m_Address = NimBLEAddress(eos->address, eos->type);
+ memcpy(&m_Uuid, &eos->uuid, sizeof(uuid128_t));
+}
+
+CanonEOS::CanonEOS(NimBLEAdvertisedDevice *pDevice) {
+ m_Name = pDevice->getName();
+ m_Address = pDevice->getAddress();
+ Serial.println("Name = " + String(m_Name.c_str()));
+ Serial.println("Address = " + String(m_Address.toString().c_str()));
+ Device::getUUID128(&m_Uuid);
+}
+
+CanonEOS::~CanonEOS(void) {
+ NimBLEDevice::deleteClient(m_Client);
+ m_Client = nullptr;
+}
+
+bool CanonEOS::write_value(NimBLEClient *pClient,
+ const char *serviceUUID,
+ const char *characteristicUUID,
+ uint8_t *data,
+ size_t length) {
+ NimBLERemoteService *pSvc = pClient->getService(serviceUUID);
+ if (pSvc) {
+ NimBLERemoteCharacteristic *pChr = pSvc->getCharacteristic(characteristicUUID);
+ return ((pChr != nullptr) && pChr->canWrite() && pChr->writeValue(data, length, true));
+ }
+
+ return false;
+}
+
+bool CanonEOS::write_prefix(NimBLEClient *pClient,
+ const char *serviceUUID,
+ const char *characteristicUUID,
+ uint8_t prefix,
+ uint8_t *data,
+ size_t length) {
+ uint8_t buffer[length + 1] = {0};
+ buffer[0] = prefix;
+ memcpy(&buffer[1], data, length);
+ return write_value(pClient, serviceUUID, characteristicUUID, buffer, length + 1);
+}
+
+/**
+ * Connect to a Canon EOS.
+ *
+ * The EOS uses the 'just works' BLE bonding to pair, all bond management is
+ * handled by the underlying NimBLE and ESP32 libraries.
+ */
+bool CanonEOS::connect(NimBLEClient *pClient, ezProgressBar &progress_bar, uint32_t pair_delay) {
+ m_Client = pClient;
+
+ Serial.println("Connecting");
+ if (!m_Client->connect(m_Address)) {
+ Serial.println("Connection failed!!!");
+ return false;
+ }
+
+ Serial.println("Connected");
+ progress_bar.value(10.0f);
+
+ Serial.println("Securing");
+ if (!m_Client->secureConnection()) {
+ return false;
+ }
+ Serial.println("Secured!");
+ progress_bar.value(20.0f);
+
+ Serial.println("Identifying 1!");
+ if (!write_prefix(m_Client, CANON_EOS_SVC_IDEN_UUID, CANON_EOS_CHR_NAME_UUID, 0x01,
+ (uint8_t *)FURBLE_STR, strlen(FURBLE_STR)))
+ return false;
+
+ progress_bar.value(30.0f);
+
+ Serial.println("Identifying 2!");
+ if (!write_prefix(m_Client, CANON_EOS_SVC_IDEN_UUID, CANON_EOS_CHR_IDEN_UUID, 0x03, m_Uuid.uint8,
+ UUID128_LEN))
+ return false;
+
+ progress_bar.value(40.0f);
+
+ Serial.println("Identifying 3!");
+ if (!write_prefix(m_Client, CANON_EOS_SVC_IDEN_UUID, CANON_EOS_CHR_IDEN_UUID, 0x04,
+ (uint8_t *)FURBLE_STR, strlen(FURBLE_STR)))
+ return false;
+
+ progress_bar.value(50.0f);
+
+ Serial.println("Identifying 4!");
+
+ uint8_t x = 0x02;
+ if (!write_prefix(m_Client, CANON_EOS_SVC_IDEN_UUID, CANON_EOS_CHR_IDEN_UUID, 0x05, &x, 1))
+ return false;
+
+ progress_bar.value(60.0f);
+
+ Serial.println("Identifying 5!");
+
+ /* write to 0xf204 */
+ x = 0x0a;
+ if (!write_value(m_Client, CANON_EOS_SVC_UNK0_UUID, CANON_EOS_CHR_UNK0_UUID, &x, 1))
+ return false;
+
+ progress_bar.value(70.0f);
+ delay(pair_delay); // give camera user time to confirm pairing
+
+ /* write to 0xf104 */
+ x = 0x01;
+ if (!write_value(m_Client, CANON_EOS_SVC_IDEN_UUID, CANON_EOS_CHR_IDEN_UUID, &x, 1))
+ return false;
+
+ progress_bar.value(80.0f);
+
+ Serial.println("Identifying 6!");
+
+ /* write to 0xf307 */
+ x = 0x03;
+ if (!write_value(m_Client, CANON_EOS_SVC_UNK1_UUID, CANON_EOS_CHR_UNK1_UUID, &x, 1))
+ return false;
+
+ Serial.println("Paired!");
+ progress_bar.value(100.0f);
+
+ return true;
+}
+
+void CanonEOS::shutterPress(void) {
+ uint8_t x[2] = {0x00, 0x01};
+ write_value(m_Client, CANON_EOS_SVC_SHUTTER_UUID, CANON_EOS_CHR_SHUTTER_UUID, &x[0], 2);
+}
+
+void CanonEOS::shutterRelease(void) {
+ uint8_t x[2] = {0x00, 0x02};
+ write_value(m_Client, CANON_EOS_SVC_SHUTTER_UUID, CANON_EOS_CHR_SHUTTER_UUID, &x[0], 2);
+}
+
+void CanonEOS::focusPress(void) {
+ shutterPress();
+ return;
+}
+
+void CanonEOS::focusRelease(void) {
+ // do nothing
+ return;
+}
+
+void CanonEOS::disconnect(void) {
+ m_Client->disconnect();
+}
+
+size_t CanonEOS::getSerialisedBytes(void) {
+ return sizeof(eos_t);
+}
+
+bool CanonEOS::serialise(void *buffer, size_t bytes) {
+ if (bytes != sizeof(eos_t)) {
+ return false;
+ }
+ eos_t *x = (eos_t *)buffer;
+ strncpy(x->name, m_Name.c_str(), MAX_NAME);
+ x->address = (uint64_t)m_Address;
+ x->type = m_Address.getType();
+ memcpy(&x->uuid, &m_Uuid, sizeof(uuid128_t));
+
+ return true;
+}
+
+} // namespace Furble

lib/furble/CanonEOS.h

@@ -0,0 +1,68 @@
+#ifndef CANONEOS_H
+#define CANONEOS_H
+
+#include "Device.h"
+
+namespace Furble {
+/**
+ * Canon EOS Partial Abstract Base.
+ */
+class CanonEOS: public Device {
+ public:
+ CanonEOS(const void *data, size_t len);
+ CanonEOS(NimBLEAdvertisedDevice *pDevice);
+ ~CanonEOS(void);
+
+ protected:
+ typedef struct _eos_t {
+ char name[MAX_NAME]; /** Human readable device name. */
+ uint64_t address; /** Device MAC address. */
+ uint8_t type; /** Address type. */
+ uuid128_t uuid; /** Our UUID. */
+ } eos_t;
+
+ const char *CANON_EOS_SVC_IDEN_UUID = "00010000-0000-1000-0000-d8492fffa821";
+ /** 0xf108 */
+ const char *CANON_EOS_CHR_NAME_UUID = "00010006-0000-1000-0000-d8492fffa821";
+ /** 0xf104 */
+ const char *CANON_EOS_CHR_IDEN_UUID = "0001000a-0000-1000-0000-d8492fffa821";
+
+ const char *CANON_EOS_SVC_UNK0_UUID = "00020000-0000-1000-0000-d8492fffa821";
+ /** 0xf204 */
+ const char *CANON_EOS_CHR_UNK0_UUID = "00020002-0000-1000-0000-d8492fffa821";
+
+ const char *CANON_EOS_SVC_UNK1_UUID = "00030000-0000-1000-0000-d8492fffa821";
+ /** 0xf307 */
+ const char *CANON_EOS_CHR_UNK1_UUID = "00030010-0000-1000-0000-d8492fffa821";
+
+ const char *CANON_EOS_SVC_SHUTTER_UUID = "00030000-0000-1000-0000-d8492fffa821";
+ /** 0xf311 */
+ const char *CANON_EOS_CHR_SHUTTER_UUID = "00030030-0000-1000-0000-d8492fffa821";
+
+ bool write_value(NimBLEClient *pClient,
+ const char *serviceUUID,
+ const char *characteristicUUID,
+ uint8_t *data,
+ size_t length);
+
+ bool write_prefix(NimBLEClient *pClient,
+ const char *serviceUUID,
+ const char *characteristicUUID,
+ uint8_t prefix,
+ uint8_t *data,
+ size_t length);
+
+ bool connect(NimBLEClient *pClient, ezProgressBar &progress_bar, uint32_t pair_delay = 0);
+ void shutterPress(void);
+ void shutterRelease(void);
+ void focusPress(void);
+ void focusRelease(void);
+ void disconnect(void);
+ size_t getSerialisedBytes(void);
+ bool serialise(void *buffer, size_t bytes);
+
+ uuid128_t m_Uuid;
+};
+
+} // namespace Furble
+#endif