DIY Photographic Lightmeter: 5 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Ang Instructable na ito ay nagbabahagi ng ilang mga ideya sa pagbuo ng isang simpleng maliit at murang insidente na lightmeter.

Dahil hindi ako papayagan ng Mga Tagubilin na ipasok ang aking sariling mga video, subukan ang link na ito:

www.youtube.com/embed/avQD10fd52s

Ang layunin para sa akin ay isang light-meter upang samahan ang aking medium na film format na film na Bronica ETRSi.

Mga bagay na nais kong itampok:

• solong ASA (100) dahil halos ASA 100 lang ang ginagamit kong pelikula
• kasing liit hangga't maaari
• bigyan mo lang ako ng mga kombinasyon na maaaring magparami ng aking Bronica, na nangangahulugang f2.8-f22 at 1sec hanggang 1 / 500th sec
• walang mga tampok na walang kapararakan, maliban sa mga simpleng oras at mga halaga ng aperture

Mga bagay na ginamit ko:

• Adafruit (Vishay) VEML 7700 digital Lux-meter (humigit-kumulang 5 $)
• Adafruit Trinket M0 micro controller (bandang 9 $)
• 128x32 OLED display (humigit-kumulang 10 $)
• isang pushbutton upang pansamantalang buksan ito (ilang sentimo)
• isang maliit na piraso ng strip-board, dahil sinusubukan kong hindi gumamit ng mga cable, ngunit tiyak na maaari mo ring gamitin ang mga cable

Hakbang 1: Pangunahing Pagkalkula | Lux kay EV

Ang sensor na binili ko ay gumagamit ng dalawang tampok na hinayaan akong magpasya dito:

• naglalabas ng 16bit na mga halaga ng lux sa halip na mga halagang magaan na "dimensyon"
• output ng mga halaga sa pamamagitan ng I2C

Gumagamit ang isang photographic light meter ng Exposure Values (EV) na binili ng sensor na binili ko na may halaga na Lux, na kung saan ay kumpletong iba't ibang sukat. Kaya ang unang hakbang ay upang makakuha ng mga EV mula sa mga halagang Lux na ibinigay ng sensor.

Isang mabilis na sulyap sa wikipedia at makakahanap ka ng isang pormula para sa pagsukat ng insidente at i-convert ang EV sa Lux:

E = 2.5 * 2 ^ EV

kung saan sinusukat ang E sa Lux.

Tulad ng nakuha na namin ang halagang Lux mula sa sensor at nais ang halagang EV, kailangan naming muling buuin ang formula, na makakakuha sa amin sa:

EV = log2 (E / 2.5)

Kaya't iyon ang unang pagkalkula na dapat gawin upang makuha ang mga halaga ng potograpiya mula sa lightmeter.

Sa nakalakip na talahanayan ng paghahanap maaari mong makita ang lahat ng mga halagang gagamitin sa lightmeter na ito, kasama ang naaayon sa mga halagang Lux at EV.

Hakbang 2: Paglalahad ng Mga Halaga sa Display | Adafruit GFX Library

Sinubukan ko munang ipakita ang mga halaga sa buong mga hakbang, dahil iyon ang maitatakda ko sa aking Bronica, ngunit hahantong ako sa isang problema:

Ipagpalagay natin na ang sensor ng Lux ay naglalabas ng isang halaga ng eksaktong 20480, nangangahulugan ito ng eksaktong EV 13 upang maaari kong halimbawa itakda ang aking camera sa f4 at 1 / 500th ng isang segundo at magiging mabuti upang pumunta

Susunod, ipagpalagay natin na ang sensor ng Lux ay maglalabas ng 20479 Lux, 1 Lux sa ilalim ng EV13, na maglalabas ng isang halagang EV na 12, ngunit isang Lux lamang ang layo mula sa EV13

Kaya't itatakda ko ang aking camera sa f2.8 at 1 / 500th ng isang segundo na magpapalabas ng labis na 1 paghinto nang hindi ko alam kung gaano ako kalapit sa EV13.

Konklusyon: kailangan namin ng isang uri ng pagpapakita ng analog ng mga halaga upang makita man lamang kung gaano kalapit o malayo ang metro mula sa susunod o nakaraang hakbang na EV.

Matapos subukang gamitin ang built in na mga titik at font ng GFX library nagpasya akong gumamit ng dalawang pasadyang graphics na lilipat sa OLED screen.

Isa para sa mga halaga ng siwang, isa para sa mga oras.

Gumagamit ang GFX Library ng mga halagang 8bit upang ipakita ang mga graphic, kaya gumawa ako ng isang sheet ng xls (tingnan ang imahe sa itaas).

• ang bawat halaga ay may eksaktong eksaktong dami ng mga pixel bawat halaga
• ang mga oras at aperture ay may eksaktong eksaktong halaga ng mga halaga bawat hilera
• Idinagdag ko ang kinakailangang "B" sa simula ng bawat byte at ang "," sa dulo
• Pagkatapos ay na-export ko ito sa isang simpleng teksto at voila: Nakuha ko ang pangatlong nakakabit na graphic

Ang mga halaga ng oras ay nagsisimula sa ika-1 / ika-isang segundo at ang mga halaga ng aperture ay nagsisimula sa pamamagitan ng f2.8

Gamit ang talahanayan ng paghahanap ng nakaraang hakbang alam namin na kumakatawan ito sa 160 Lux o EV6.

Ang pinakamadilim na halaga ay magiging f22 at ika-1/500 ng isang segundo

Muli sa pamamagitan ng talahanayan ng pagtingin maaari naming makita na nangangahulugang 655360 Lux o EV18

Sa ngayon napakahusay.

Kaya sa EV6 ang graphic ng aperture ay dapat na nasa kaliwang kaliwa, ang mga oras sa kanang kanan, at kabaliktaran sa EV18

Hakbang 3: Pagbasa at Pagbabayad ng mga Halagang Halaga ng Lux | VEML7700

Habang nag-scroll sa datasheet ng Vishay VEML7700 na ginagamit ng Adafruit para sa kanilang board, natagpuan ko ang isang medyo nakakagambalang abiso:

Gumagawa lamang ang sensor ng linear sa pagitan ng 0 at 1000Lux (!)

tingnan ang screenshot gamit ang linya ng orange (linear) at ang asul (aktwal na output ng sensor) na linya

Ang Sunlight (EV15) ay nasa paligid ng 80.000 Lux, na nangangahulugang walang kabayaran ng di-linear na bahagi ng sensor ay kumpleto itong walang silbi bilang isang light meter.

Alam ni Vishay iyon, kaya't binigyan nila ang kanilang mga customer ng isa pang pdf na tinatawag na Pagdidisenyo ng VEML7700 Sa isang Application.

Sa pdf na ito maaari kang makahanap ng isang pormula upang mabayaran ang mga sensor na hindi linearity:

LUX_Corr = 6.0135e-13 * pow (LUX, 4) -9.3924e-9 * pow (LUX, 3) + 8.1488e-5 * pow (LUX, 2) + 1.0023 * LUX

Kung saan ang LUX_CORR ay ang naitama na Lux-Value at ang LUX ay ang halaga na output ng sensor.

Iyon ang mga variable na ginamit ko, ang iba't ibang ginamit sa kanilang sheet.

Ang medyo nag-bug sa akin ay hindi ito binabanggit ng Adafruit na may isang solong salita sa kanilang pahina, ang kanilang dokumentasyon, kanilang silid aklatan o kung saan man.

Kaya't sa mga unang araw ay nagtataka ako kung bakit ang aking lightmeter ay naglalabas lamang ng 20000 Lux maximum kahit sa direktang sikat ng araw.

Kung titingnan mo ang graph na may pula at asul na linya maaari mong makita kung bakit: dahil hindi ito maaaring mas mataas nang walang formula sa kabayaran.

Ngunit may isa pang pahiwatig na nakatago sa dokumentasyon ng sensor:

Gumagana lamang ang formula sa pagbabayad na ito kung itinakda mo ang sensor sa 25ms at isang ratio na makakuha ng 1/8.

Iyon ay tapos na medyo madali sa Adafruits library sa pamamagitan ng pagdaragdag:

veml.setGain (VEML7700_GAIN_1_8); veml.setIntegrationTime (VEML7700_IT_25MS);

sa iyong void setup ()

Kaya pagkatapos itakda ito sa 1/8 at 25ms at idagdag ang formula sa pagbabayad maaari mong sukatin ang hanggang sa 120000 lux, sapat na paraan upang masakop ang sikat ng araw sa 80-100k Lux

Hakbang 4: Arduino / C-code

Dahil ito ay nakasalalay sa iyong ginamit na display at ginustong controller ay hindi ko masyadong detalyado, ilang mga saloobin at pahiwatig lamang upang idagdag, lalo na kapag ginagamit ang mga aklatan ng Adafruit at ang 128x32 px OLED:

sa void setup:

itinakda ko ang VEML library-part sa:

veml.setGain (VEML7700_GAIN_1_8);

veml.setIntegrationTime (VEML7700_IT_25MS);

veml.setLowThreshold (10000);

veml.setHighThreshold (20000);

veml.interruptEnable (totoo);

sa void loop:

tiyaking idagdag ang kabayaran:

int LUX_Corr = 6.0135e-13 * pow (LUX, 4) -9.3924e-9 * pow (LUX, 3) + 8.1488e-5 * pow (LUX, 2) + 1.0023 * LUX;

upang makakuha ng mga EV mula sa Lux gamitin ang linyang ito:

float EV = log2 ((LUX_Corr / 2.5));

paglipat ng mga bitmap

upang matiyak na gumagalaw lamang ang mga bitmap kapag ang mga halaga ay nasa pagitan ng 160Lux at 655360Lux tulad ng nakasaad sa isang nakaraang hakbang, balutin ito ng isang sugnay na tulad nito:

kung (LUX_Corr> 159 && LUX_CORR <655361)

Susunod na kailangan naming i-map ang mga halagang EV sa mga coordinate, dahil ang saklaw ng mga EV ay doble na digit at nais naming ilipat ang mga ito mula sa labas ng display sa paglipas ng 128px sa buong display na kailangan namin ng mas malaking mga halaga.

Tulad ng nakakuha na kami ng isang float number multiply lang namin iyon sa 100 at gamitin ang integer na iyon upang mapa ang mga coordinate

int EV_DSPL = EV * 100;

at:

TIME = mapa (EV_DSPL, 600, 1900, -260, 39); APERTURE = mapa (EV_DSPL, 600, 1900, 39, -260);

Tulad ng nakikita mo sa aking kaso ang minimum na posisyon ng bitmap ay magiging -260px at ang maximum ay 39px

Ang nakikita rin dito ay inilipat ko ang mga coordinate upang ang dalawang bitmap ay lumipat sa kabaligtaran na direksyon

Susunod na kailangan namin upang ilipat ang mga bitmap alinsunod sa mga coordinate ng:

display.drawBitmap ((TIME), (0), TIMES_bmp, 352, 16, 1); display.drawBitmap ((APERTURE), (15), APERTURES_bmp, 352, 16, 1);

At iyan ang lahat ng kailangang gawin

Bilang isang bonus ipinapakita ko ang diretso na mga halaga ng EV at Lux kapag ang sensor ay naglalabas ng Mga Halaga sa ilalim ng 160Lux, dahil lamang nais kong makita ang mga bagay-bagay kapag sinusubukan ito.

Hakbang 5: Pagsasama-sama Ito

Tulad ng pareho, ang display at ang sensor ay gumagamit ng I2C upang makipag-usap, ang pagbuo ng aktwal na hardware ay kasing simple ng maaari nitong maging.

Ikonekta lamang ang mga linya ng Data, Clock at 3V sa Arduino at nakatakda kang pumunta.

Nagdagdag ako ng isang graphic kung paano ko ito nagawa sa isang stripboard, ngunit tulad ng sinabi nang mas maaga maaari kang gumamit ng mga kable o kahit na bumuo ng isang pakpak para dito, nakasalalay ang lahat sa aling kontrolado at ipakita ang ginagamit mo.

Sa aking graphic, ang mga puting tuldok ay dapat na konektado sa display at sensor at ang mga dilaw na tuldok ay kumonekta sa Trinket.

Ang tanging pagbubukod ay ang data-pin ng linya ng I2C na kumokonekta sa display, ang pin na iyon ay kumokonekta din sa data ng Trinkets.

Pinili kong hindi gumamit ng isang on / off switch ngunit sa halip ay gumamit ng isang pushbutton at dalawang mga cell ng 3V button upang pansamantalang i-power ito basta pindutin ko ang pindutan. Nagpapatakbo ito sa ilalim ng 1/10 ng isang segundo kaya't sapat na mabilis para sa akin na matitira ang isang pindutan at gawin itong mas maliit.