Cara membangun sistem penumpukan fokus beragampengetahuan sederhana – Beragampengetahuan

Setiap tahun instrumentasi fotografi saya, siswa membangun sistem penumpukan fokus yang sangat sederhana. Setelah beberapa tahun, memutuskan untuk membangun versi pengembangan yang lebih banyak yang dapat memindahkan tahap stepper, yang digerakkan oleh motor ke posisi yang tepat, secara otomatis memilih serangkaian gambar, dan pengembang menggunakan di lapangan.

Focus Stacking adalah teknis pencitraan digital yang kuat untuk mencapai kedalaman lapangan yang lebih besar (DOF) dalam gambar, gambar makro, dan mikroskop. Ini melibatkan konsep banyak gambar ke titik fokus yang berbeda dan menggabungkannya dalam satu gambar tajam. Teknik ini sangat penting untuk kondisi di mana satu paparan dapat membuat seluruh subjek tetap fokus, seperti gambar suhu.

Saya akan selalu terkejut menemukan banyak fotografer, saya tidak tahu apa fokus yang ditumpuk dan bagaimana digunakan. Dalam yang paling sederhana untuk diterapkan pada gambar makro, fokus penumpukan adalah teknik yang mengumpulkan gambar, menggerakkan fraksi subjek dari kedalaman lapangan, dan gambar lain ke wilayah yang diminati. Setiap gambar dikumpulkan oleh resolusi tertinggi dan lensa untuk dikumpulkan. Gambar tumpukan yang dihasilkan dari kombinasi menggunakan alat khusus dalam program sebagai Photoshop, Helicon Focus atau Zerenen Stacker. Program favorit saya untuk aplikasi ini adalah Helicon Coat, yang disetel aplikasi ini dengan baik.

Mereka memfokuskan sistem penumpukan di pasar, tetapi keduanya memiliki keterbatasan, stabilitas badai rel di atas ruang panjang, label harga atau tidak fitur yang diinginkan yang hilang. Saat Anda membangun akun Anda, Anda dapat mendesainnya dengan cara yang Anda inginkan.

Sistem saya dirancang untuk sekitar Canonp-E 65mm f / 2.8 1-5x lensa foto makro dan mencakup perbesaran 1 hingga 5 x. Lensa ini adalah dokumen yang sangat baik dalam pembuatan, dan informasi yang disediakan dalam panduan pengguna yang perlahan.

Data ini berasal dari manual lensa Canon dan diformat ulang di Photoshop. Area hijau area resolusi tertinggi dan sisa bagan tidak digunakan untuk penumpukan fokus resolusi tinggi. Seorang fotografer dapat digunakan untuk nomor F yang lebih tinggi untuk kedalaman lapangan yang lebih besar, tetapi saya melakukan resolusi kerusakan. Ada saat -saat dengan seorang fotografer bergerak ke angka F yang lebih tinggi untuk mengurangi angka yang diperlukan gambar menutupi lantai dan dengan demikian mengurangi periode resep dan beberapa angka memori komputer.

Untuk kedalaman tahap penumpukan fokus – jempol aturan umum adalah ke bidang kedalaman (DOF) dan memotong jarak menjadi dua. Salah satu salinan dari pengaturan 2x, f / 2.8 adalah untuk memfokuskan langkah stacking rail pada 0,074 mm.

Penumpukan fokus dapat memberikan hasil terbaik dengan subjek yang tepat. Misalnya, subjek fuzzy dengan begitu banyak rambut yang tumpang tindih sering menghasilkan gambar yang membingungkan, dengan objek halus sebagai serangga di mata pencampuran dengan bersih dalam perangkat lunak untuk membuat hasil yang tajam.

Penggunaan penumpukan seringkali merupakan keseimbangan antara waktu investasi dan dimaksudkan untuk mengakhiri gambar. Mudah menghabiskan terlalu banyak waktu untuk menyelesaikan gambar untuk akhirnya dikurangi ke ukuran prangko.

Membangun Sistem Penumpukan Fokus beragampengetahuan

Proyek dimulai dengan mendapatkan posisi yang ditentukan. Saya merekomendasikan membeli penistaan ​​bekas dan baru-baru ini saya menemukan mesin pipet otomatis mengandung rel berkualitas tinggi serta dua motor stepper yang sangat baik. Mesin -mesin ini sering diperbarui, sehingga komponennya saat ini membanjiri eBay. Petunjuk yang disediakan di sini dirancang tentang motor stepper 12-volt Adafruit, yang murah, tersedia secara luas dan pilihan terbaik untuk beasiswa.

Resolusi tingkat linier adalah kombinasi dari jejak revolusi pengemudi dalam proses motor. Panggung saya memiliki pitch sekitar 20 utas dalam inci sebagai string harus berubah 20 kali untuk bergerak 1 inci. Masukkan motor membutuhkan 200 langkah untuk dicabut satu digit (4) derajat atau dalam derajat .0005 inci dan 6,35um per kelas. Sistem ini dirancang untuk menjadi foto di mana lensa F # dan pembesaran menentukan kedalaman lapangan. Resolusi panggung ini akan bekerja dengan baik untuk aplikasi saya.

Keuntungan dari 12VDC menganggap motor yang disediakan oleh Adafruit adalah model kabel yang diketahui, dan eksperimen tidak akan menghancurkan banyak waktu mencoba mencari tahu string string. Motor adalah ukuran bingkai hibrida motor bipolar motor 17 200.0 derajat oleh revolusi dan menggunakan 350 mA hingga 12vdc dan setuju sekitar 14 dolar AS.

Masukkan kejutan modern pengontrol motor. Bagian dari pengontrol memiliki banyak batang dan mengatakan langkah pengontrol oleh revolusi motor serta persyaratan saat ini. Mati hari membuat pengontrol sendiri. Moderator menerima perintah dan segera gerakkan level motor ke depan atau ke belakang.

Pasokan 12 VDC VDC yang digunakan adalah unit umum yang dijual ke pengaturan LED dan dengan harga yang sangat tepat. Tombol tekan untuk mengontrol ke depan, membalikkan dan memulai komponen Arduino standar.

Persyaratan proyek ini adalah untuk membuat sistem penumpukan fokus sederhana yang dapat dibangun oleh setiap siswa. Untuk antarmuka dengan Arduino, saya ingin menggunakan beberapa tombol mungkin.

Tepat di antara setiap gambar, jeda waktu untuk menangkap kedua foto, dan jumlah total gambar harus dimasukkan langsung dalam kode Arduino. Setelah urutan selesai di level secara otomatis kembali ke rumah. Program Arduino yang disediakan di bawah ini berfungsi sebagai titik awal yang baik untuk merancang kode kontrol yang lebih kompleks.

Dalam alur kerja pikirannya adalah nama pengguna langsung menggerakkan tahap awal posisi fokus, menekan tombol start dan mari arduino menangani istirahat. Panggung menggerakkan kamera ke gambar penumpukan fokus berikut yang dikumpulkan.

Tombolnya:

• 1 Tombol Mulai → Menyimpan Beranda dan Mengatur, Mulai Urutan Kelas. Stepper memindahkan stepdistance ke banyak langkah → mengharapkan waktu dalam detik setiap gambar. Setelah penyelesaian berikut → secara otomatis kembali ke rumah (posisi asli).
• 2 tombol manual bekerja secara mandiri dengan urutan berjalan.
• 3 Tombol Penghasilan Manual Bekerja Secara Mandiri Saat Seri Tidak Berjalan.
• Dan LED mundur menunjukkan arah di atas panggung.

Sirkuit memicu lorem kamera.

Pemicu kamera menggunakan dua solenoida.

Untuk membuat umpan balik visual di sekitar untuk melakukan apa yang seharusnya menggunakan beberapa lead. Tanda-tanda-tanda gerakan ke depan dan program penumpukan fokus sedang berjalan.

Program ke Arduino

/*
2025FinalFocusStacking.ino
Stepper1 is 200 steps per rev.
Each step is a sequence of 8 pulses controlled by a 
TB6600/TB6660 stepper driver using the AccelStepper library. 
This represents a distance of 6.3um with a standard Adafruit stepping motor.

Modified:
- StartButton triggers a focus stacking sequence.
- Forward and Backward buttons control movement directly.
- Home position is recorded when StartButton is pressed, and the stepper returns to that position after the sequence.

Author: Ted Kinsman (August  2025, emkpph@rit.edu)
*/
// Include the AccelStepper library for smooth motion control
#include <AccelStepper.h>

// Define button pins for manual and automatic control
#define ForwardButton 8   // Button for moving forward on Arduino pin 8
#define BackButton 9      // Button for reversing on Arduino pin 9
#define StartButton 10    // Button to start the focus stacking on Arduino pin 10
#define ShutterTrigger 13 // Camera trigger on Arduino pin 13

// Define LED indicators
#define ForwardLED 11     // LED to indicate forward movement on Arduino pin 11
#define BackLED 12        // LED to indicate reverse movement on Arduino pin 12

// Define stepper motor connections
#define dirPin1 3   // Stepper direction pin on Arduino pin 3
#define stepPin1 2  // Stepper step pin on Arduino pin 2
#define enPin 4     // Enable pin for TB6600 driver on Arduino pin 4

// Motion parameters
const int moveSpeed = 2000;   // Maximum speed (steps per second)
const int accel = 1000;      // Acceleration (steps per second^2)

// Stepper movement variables
int stepDistance = 50;     // Distance the motor moves for each image
int NumberOfPictures = 25;    // Total number of images to capture
bool sequenceRunning = false; // Flag to track if sequence is running
long homePosition = 0;      // Variable to store the dynamic home position

// Create an instance of AccelStepper class
AccelStepper stepper1(AccelStepper::DRIVER, stepPin1, dirPin1);

void setup() {
    // Configure pin modes
    pinMode(enPin, OUTPUT);
    pinMode(ForwardLED, OUTPUT);
    pinMode(BackLED, OUTPUT);
    pinMode(ShutterTrigger, OUTPUT);
    pinMode(ForwardButton, INPUT);
    pinMode(BackButton, INPUT);
    pinMode(StartButton, INPUT);

    // Enable stepper driver (LOW = enabled for most TB6600/TB6660 drivers)
    digitalWrite(enPin, LOW);

    // Configure stepper motor properties
    stepper1.setMaxSpeed(moveSpeed);
    stepper1.setAcceleration(accel);

    // Start serial communication for debugging
    Serial.begin(9600);
    Serial.println("Stepper motor ready. Press Start button to begin sequence.");
}

void loop() {
    // Check if StartButton is pressed and sequence is not running
    if (digitalRead(StartButton) == HIGH && !sequenceRunning) {
        delay(50);  // Debounce delay
        if (digitalRead(StartButton) == HIGH) {  // Double-check if still HIGH
            sequenceRunning = true;  // Mark sequence as running

            // Set the current position as the home position
            homePosition = stepper1.currentPosition();
            Serial.print("Start button pressed. Setting home position to: ");
            Serial.println(homePosition);

            // Ensure button is released before continuing
            while (digitalRead(StartButton) == HIGH);

            // Execute focus stacking sequence
            executeStepSequence();
            
            // Return the stepper to the starting position after sequence is completed
            returnToHome();  

            sequenceRunning = false; // Reset flag after sequence completes
            Serial.println("Focus stacking sequence completed. Returned to start position.");
        }
    }

    // Allow manual movement only when no automated sequence is running
    if (!sequenceRunning) {
        if (digitalRead(ForwardButton) == HIGH) { 
            moveForward(); // Move forward while button is held
        } 
        else if (digitalRead(BackButton) == HIGH) { 
            moveBackward(); // Move backward while button is held
        } 
        else {
            stopMotor(); // Stop motor if no button is pressed
        }
    }
}

// Function to execute the focus stacking step sequence
void executeStepSequence() {
    digitalWrite(enPin, LOW); // Enable motor current
    for (int i = 0; i < NumberOfPictures; i++) {
        Serial.print("Capturing Picture ");
        Serial.println(i + 1);

        // Trigger the camera shutter
        digitalWrite(ShutterTrigger, HIGH);
        delay(10);  // Allow the camera time to respond
        digitalWrite(ShutterTrigger, LOW);

        // Move stepper forward by stepDistance
        stepper1.move(stepDistance);
        digitalWrite(ForwardLED, HIGH);

        // Wait until the stepper completes the movement
        while (stepper1.distanceToGo() != 0) {  
            stepper1.run();
        }

        // Turn off LED after movement is completed
        digitalWrite(ForwardLED, LOW);
        Serial.println("Waiting 3 seconds before next step...");
        delay(3000);  // Wait 3 seconds before next step
    }
}

// **Function to return to the recorded home position**
void returnToHome() {
    Serial.print("Returning to home position: ");
    Serial.println(homePosition);

    // Move stepper back to stored home position
    stepper1.moveTo(homePosition);
    digitalWrite(BackLED, HIGH); // Indicate returning motion

    // Wait until the stepper reaches home position
    while (stepper1.distanceToGo() != 0) {  
        stepper1.run();
    }

    digitalWrite(BackLED, LOW); // Turn off LED after reaching home
    Serial.println("Stepper returned to starting position.");
}

// Function to move forward continuously while button is held
void moveForward() {
    digitalWrite(enPin, LOW); // Enable motor current
    digitalWrite(ForwardLED, HIGH);
    digitalWrite(BackLED, LOW);
    stepper1.setSpeed(moveSpeed);
    stepper1.runSpeed();
}

// Function to move backward continuously while button is held
void moveBackward() {
    digitalWrite(enPin, LOW); // Enable motor current
    digitalWrite(BackLED, HIGH);
    digitalWrite(ForwardLED, LOW);
    stepper1.setSpeed(-moveSpeed);
    stepper1.runSpeed();
}

// Function to stop the motor
void stopMotor() {
    digitalWrite(ForwardLED, LOW);
    digitalWrite(BackLED, LOW);
    stepper1.stop(); // Ensures stepper stops completely
    digitalWrite(enPin, HIGH); // Turn off current to the motor
    Serial.println("Motor Stopped, current disabled.");
}

Catatan dalam program atau sekitar.

Gunakan holding motor bisa sangat kompleks bagi pemula. Masukkan penggerak khas mengambil banyak motor torsi saat ini dan tinggi bisa menjadi sangat panas. Jika motor tidak mengambil beban seperti pada motor aplikasi ini dan dimatikan dan ini membuat motor terlalu panas dan menjaga energi jika aplikasi berjalan pada baterai. Kelanjutan yang benar ketika Anda beralih untuk melanjutkan dan mematikan motor bisa membingungkan.

Logika kode berikut menggunakan nilai tinggi, seperti tombol pot digunakan pin Arduino akan melihat tegangan 5 akhir pekan. Saya melampirkan skema di sekitar sini untuk membantu memahami kabel.

Pemicu kamera selalu tidak pantas untuk siswa. Banyak kamera modern memiliki tiga kabel untuk mengontrol kamera. Dua hal yang terpasang pada kamera akan fokus dan ketiganya di kamera akan menjadi gambar. Sangat mudah untuk mengontrol kabin sirkuit ini menggunakan dua pena yang dirujuk. Satu pulsa menutup dan beralih dan menghubungkan ketiga kabel di pemicu jarak jauh kamera. Restorship juga patuh listrik Arduinoinin dan kamera.

Kesimpulan

Fokus penumpukan adalah teknik penting untuk kedalaman pemenang dari keterbatasan lapangan dalam gambar dan mikroskop. Apakah Anda mengambil struktur mikroskopis atau bidikan tembakan yang rumit, ini hanyalah gambar kecerahan kecerahan dan ketajaman. Dengan bantuan sistem susun otomatis dan perangkat lunak khusus, penumpukan fokus menjadi alat yang dapat diakses dan sangat diperlukan bagi profesional dan penggemar.

Penuh dengan video proyek