Buton magic 4k: telecomanda wireless 20USD BMPCC 4k (sau 6k): 4 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Mulți oameni mi-au cerut să împărtășesc câteva detalii despre controlerul meu wireless pentru BMPCC4k. Cele mai multe întrebări au fost despre controlul Bluetooth, așa că voi menționa câteva detalii despre asta. Presupun că sunteți familiarizați cu mediul ESP32 Arduino.

Această versiune a telecomenzii poate controla înregistrarea, focalizarea și diafragma camerei prin Bluetooth. Aruncați o privire la videoclip. Este destul de ușor să adăugați mai multe funcții de control conform manualului de control Bluetooth al BMPCC4k. Practic, orice din cameră poate fi controlat, din câte am văzut.

Ar fi un pas ușor să adăugați un modul LIDAR pentru a măsura distanța unui subiect, astfel încât să puteți obține un fel de sistem de focalizare automată … Deși este îndoielnic dacă puteți obține o concentrare suficient de precisă asupra unor zone specifice, cum ar fi ochii etc.

ACTUALIZARE 2020: am făcut versiunea 3.0. Se bazează pe o roată rotativă liberă utilizând un codor magnetic. Se conectează, de asemenea, la motorul meu de focus focus, care devine practic un al doilea dispozitiv bluetooth (ESP32 acceptă mai multe conexiuni bluetooth). Noul videoclip demonstrează acest lucru.

Dacă doriți să comandați versiunea 3, vă rugăm să aruncați o privire pe site-ul MagicButton

Provizii

Orice modul ESP32 cu wifi și bluetooth. Am folosit TTGO micro32 pentru că este mic:

O roată de focalizare, ar face orice potențiometru. Am folosit următoarele pentru că este mic: https://www.aliexpress.com/item/32963061806.html? S … Acest tip are opriri grele la limita superioară și inferioară. Într-o versiune viitoare voi folosi un codificator rotativ. În acest fel, focalizarea sau diafragma nu „sare” la setarea curentă a roții atunci când intru într-un mod.

Un buton rec / mode. Am folosit următoarele: https://www.aliexpress.com/item/32806223591.html? S …

Alte componente standard, cum ar fi rezistențe, capace, … (vezi schema)

Pasul 1: Codul

Folosesc capacitatea wifi a ESP32 pentru a mă conecta la o rețea cunoscută în modul AP sau, atunci când sunt pe teren, devine o stație (STA) la care mă pot conecta. În acest fel pot configura modulul. Nu voi intra în detaliile secțiunii wifi / pagină web, aș putea adăuga acest lucru într-o etapă ulterioară.

ESP32 se conectează la cameră și devine client Bluetooth LE. Codul bluetooth inclus în cadrul ESP32 al Arduino nu funcționează cu BMPCC4k. Wakwak-koba a reparat-o pentru noi. Mulțumesc Wakwak-koba! Am folosit biblioteca BLE de aici:

github.com/wakwak-koba/arduino-esp32

Cu toate acestea, acea versiune a lib BLE este încă în curs de dezvoltare și cea mai recentă versiune a BLEUUID.cpp nu pare să funcționeze în acest moment, deci luați versiunea anterioară „verificată” a acestui fișier.

În rest, cea mai mare parte a codului meu bluetooth este mult conform exemplelor BLE incluse în cadrul Arduino:

Unele BLE UUID și variabile definesc:

static BLEUUID BlackMagic ("00001800-0000-1000-8000-00805f9b34fb");

static BLEUUID ControlserviceUUID ("291D567A-6D75-11E6-8B77-86F30CA893D3"); static BLEUUID DevInfoServiceControlUUID ("180A"); static BLEUUID ControlcharUUID ("5DD3465F-1AEE-4299-8493-D2ECA2F8E1BB"); static BLEUUID NotifcharUUID ("B864E140-76A0-416A-BF30-5876504537D9"); static BLEUUID ClientNamecharUUID ("FFAC0C52-C9FB-41A0-B063-CC76282EB89C"); static BLEUUID CamModelcharUUID ("2A24"); static BLEScan * pBLEScan = BLEDevice:: getScan (); static BLEAddress * pServerAddress; static BLEAdvertisedDevice * myDevice; static BLERemoteCharacteristic * pControlCharacteristic; static BLERemoteCharacteristic * pNotifCharacteristic; static boolean doConnect = 0; static boolean conectat = 0; scanare volatilebool = 0; volatileuint32_t pinCode;

Scanarea și bucla principală:

clasa MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {

void onResult (BLEAdvertisedDevice advertisedDevice) {Serial.print ("BLE Advertised Device found:"); Serial.println (advertisedDevice.toString (). C_str ()); if (advertisedDevice.haveServiceUUID () && advertisedDevice.getServiceUUID (). este egal cu (BlackMagic)) {Serial.print ("Am găsit dispozitivul nostru!"); advertisedDevice.getScan () -> stop (); myDevice = nou BLEAdvertisedDevice (advertisedDevice); doConnect = adevărat; }}}; static void scanCompleteCB (BLEScanResults scanResults) {Serial.println ("scanarea a fost făcută"); scanare = false; } void loop (void) {if (! connected && ((uint32_t) (millis () - Timer)> BLE_RESCAN_TIME || (! scanare))) {Serial.println ("scanare …"); scanare = adevărat; pBLEScan-> start (BLE_SCAN_TIME, scanCompleteCB); Temporizator = milis (); } if (doConnect == true) {if (connectToServer ()) {Serial.println ("Acum suntem conectați la serverul BLE."); conectat = adevărat; } else {Serial.println ("Nu am reușit să ne conectăm la server; nu vom mai face nimic."); } doConnect = false; }}

Conectarea la cameră:

bool connectToServer () {

Serial.print („Formarea unei conexiuni la”); Serial.println (myDevice-> getAddress (). ToString (). C_str ()); BLEDevice:: setEncryptionLevel (ESP_BLE_SEC_ENCRYPT); BLEDevice:: setSecurityCallbacks (new MySecurity ()); BLESecurity * pSecurity = BLESecurity nou (); pSecuritate-> setKeySize (); pSecurity-> setAuthenticationMode (ESP_LE_AUTH_REQ_SC_MITM_BOND); pSecuritate-> setCapability (ESP_IO_CAP_IN); pSecurity-> setRespEncryptionKey (ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK); BLEClient * pClient = BLEDevice:: createClient (); pClient-> setClientCallbacks (new MyClientCallback ()); pClient-> connect (myDevice); Serial.println ("- Conectat la server"); BLEDevice:: setMTU (BLEDevice:: getMTU ()); // OBȚINERE MODEL CAMERĂ BLERemoteService * pRemoteService = pClient-> getService (DevInfoServiceControlUUID); if (pRemoteService == nullptr) {Serial.print ("- Nu s-a putut obține serviciul de informații despre dispozitiv"); Serial.println (DevInfoServiceControlUUID.toString (). C_str ()); go go; } Serial.println ("- Citirea informațiilor dispozitivului"); // Obțineți o referință la caracteristica din serviciul serverului BLE la distanță. BLERemoteCharacteristic * pRemoteCamModelCharacteristic = pRemoteService-> getCharacteristic (CamModelcharUUID); if (pRemoteCamModelCharacteristic == nullptr) {Serial.print ("- Nu s-a găsit modelul camerei"); Serial.println (CamModelcharUUID.toString (). C_str ()); go go; } // Citiți valoarea caracteristicii. std:: string value = pRemoteCamModelCharacteristic-> readValue (); Serial.print („Camera este”); Serial.println (value.c_str ()); if (CamModel! = value.c_str ()) {Serial.print ("- Camera nu este BMPCC4k"); go go; } // OBȚINE CONTROL pRemoteService = pClient-> getService (ControlserviceUUID); if (pRemoteService == nullptr) {Serial.print ("- Nu s-a putut obține serviciul camerei"); Serial.println (ControlserviceUUID.toString (). C_str ()); go go; } BLERemoteCharacteristic * pRemoteClientNameCharacteristic = pRemoteService-> getCharacteristic (ClientNamecharUUID); if (pRemoteClientNameCharacteristic! = nullptr) {pRemoteClientNameCharacteristic-> writeValue (MyName.c_str (), MyName.length ()); } pControlCharacteristic = pRemoteService-> getCharacteristic (ControlcharUUID); if (pControlCharacteristic == nullptr) {Serial.print ("- Nu s-a obținut caracteristica de control"); Serial.println (ControlcharUUID.toString (). C_str ()); go go; } pNotifCharacteristic = pRemoteService-> getCharacteristic (NotifcharUUID); if (pNotifCharacteristic! = nullptr) // && pNotifCharacteristic-> canIndicate ()) {Serial.println ("- subscrierea la notificare"); const uint8_t indicationOn = {0x2, 0x0}; pNotifCharacteristic-> registerForNotify (notificationCallback, false); pNotifCharacteristic-> getDescriptor (BLEUUID ((uint16_t) 0x2902)) -> writeValue ((uint8_t *) indicationOn, 2, true); } returnează adevărat; fail: pClient-> disconnect (); returnează fals; }

Apelarea conectată / deconectată:

clasa MyClientCallback: public BLEClientCallbacks {

void onConnect (BLEClient * pclient) {Serial.println ("Suntem conectați."); } void onDisconnect (BLEClient * pclient) {conectat = fals; pclient-> disconnect (); Serial.println ("Ne-am deconectat."); }};

Partea codului PIN:

În versiunea mea actuală pot introduce codul PIN prin interfața web, dar acestea sunt detalii despre wifi / pagină web pe care le-aș putea adăuga mai târziu.

clasa MySecurity: public BLESecurityCallbacks

{uint32_t onPassKeyRequest () {Serial.println ("- PLEASE ENTER 6 DIGIT PIN (end with ENTER):"); pinCode = 0; char ch; face {while (! Serial.available ()) {delay (1); } ch = Serial.read (); if (ch> = '0' && ch <= '9') {pinCode = pinCode * 10 + (ch -'0 '); Serial.print (ch); }} while ((ch! = '\ n')); returnează PinCode; } void onPassKeyNotify (uint32_t pass_key) {ESP_LOGE (LOG_TAG, "The passkey Notify number:% d", pass_key); } bool onConfirmPIN (uint32_t pass_key) {ESP_LOGI (LOG_TAG, "Parola YES / NO number:% d", pass_key); vTaskDelay (5000); returntrue; } bool onSecurityRequest () {ESP_LOGI (LOG_TAG, „Cerere de securitate”); returntrue; } void onAuthenticationComplete (esp_ble_auth_cmpl_t auth_cmpl) {Serial.print ("pair status ="); Serial.println (auth_cmpl.success); }};

Notificare BLE:

Camera își notifică clienții BLE despre orice modificare a camerei, inclusiv atunci când camera pornește și oprește înregistrarea. Acest cod îmi comută LED-ul când pornește / oprește înregistrarea.

static nul notificationCallback (BLERemoteCharacteristic * pBLERemoteCharacteristic, uint8_t * pData, size_t length, bool isNotify) {// BMPCC4k Format mesaj BLE: // rec on is 255 9 0 0 10 1 1 2 2 0 64 0 2 // rec off is 255 9 0 0 10 1 1 2 0 0 64 0 2if (lungime == 13 && pData [0] == 255 && pData [1] == 9 && pData [4] == 10 && pData [5] == 1) {if (pData [8] == 0) { recstatus = 0; } if (pData [8] == 2) {recstatus = 1; }}}

Pasul 2: Codul partea 2

Aceasta este partea care de fapt trimite comenzile către cameră.

Înregistrare:

uint8_t record = {255, 9, 0, 0, 10, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // 0 = OFF, 2 = ON, [8] void Record (boolean RecOn) {if (! RecOn) record [8] = 0; else record [8] = 2; pControlCharacteristic-> writeValue ((uint8_t *) record, 16, adevărat); }

Concentrare:

Camera se așteaptă la un număr de 11 biți, variind de la focalizare aproape la distanță. Vă sfătuiesc să puneți un filtru pe valoarea dvs. ADC, altfel focalizarea ar putea fi nervoasă.

uint8_t focus = {255, 6, 0, 0, 0, 0, 128, 0, 0, 0, 0, 0}; // 0,0 … 1,0, 11 biți, [8] = LSB, [9] = MSBvoid Focus (uint16_t val) {// trecând de la o valoare ADC de 12 biți la o valoare de focalizare de 11 biți focus [8] = (uint8_t) (((val> > 1) & 0xFF)); focus [9] = (uint8_t) (((val >> 1) & 0xFF00) >> 8); pControlCharacteristic-> writeValue ((uint8_t *) focus, 12, adevărat); }

Deschidere:

Camera se așteaptă la un număr de 11 biți, variind de la o valoare de diafragmă scăzută la o valoare ridicată. Vă sfătuiesc să puneți un filtru pe valoarea dvs. ADC, altfel valoarea diafragmei ar putea fi nervoasă.

uint8_t diafragmă = {255, 6, 0, 0, 0, 3, 128, 0, 0, 0, 0, 0}; // 0.0 … 1.0, [8] = LSB, [9] = MSBvoid Aperture (uint16_t val) {// trecând de la o valoare ADC de 12 biți la o valoare de deschidere de 11 biți aperture [8] = (uint8_t) (((val >> 1) & 0xFF)); diafragmă [9] = (uint8_t) (((val >> 1) & 0xFF00) >> 8); pControlCharacteristic-> writeValue ((uint8_t *) diafragmă, 12, adevărat); }

Pasul 3: Circuitul

Am atașat PDF-ul circuitului meu. Unele poze ale PCB-ului sunt, de asemenea, atașate.

Placa este alimentată cu micro USB.

După ce am primit PCB-ul, am decis că vreau să conduc un LED RGB, așa că am conectat două WS2812B în serie la ieșirea "Button Led" (care avea nevoie de niște patch-uri de sârmă pe PCB). PCB-urile erau 8USD cu OSHPark.com.

Puteți vedea mai multe conexiuni pe PCB, cum ar fi „adc” pe care nu le folosesc și care au fost eliminate din schemele atașate. Planul era să folosesc în trecut o roată de focalizare externă, dar în prezent sunt perfect mulțumit de roata mică.

Pasul 4: Concluzie

Sper că acest lucru a ajutat.

Am în minte câteva actualizări viitoare, cum ar fi utilizarea unui codificator rotativ fără opriri grele. Acest lucru va necesita controlerului să obțină valoarea curentă a focalizării sau diafragmei de pe cameră și să continue de acolo. Funcția „notificationCallback” trebuie să fie actualizată pentru asta probabil.

PCB-ul are nevoie de o actualizare pentru a furniza corect semnalele pentru LED-urile RGB WS2812B.

Mi-am petrecut mult timp (o descărcare) de timp făcând acest lucru, în special partea BLE. Dacă acest lucru te-a ajutat și vrei să-mi cumperi o băutură, asta e foarte apreciat:) Acesta este un link de donație Paypal: