Luckfox Lyra Zero W ile Gelişime Başlangıç Rehberi

IoT ve gömülü yapay zeka projeleriniz için uygun maliyetli, güçlü ve küçük bir çözüm mü arıyorsunuz? Luckfox Lyra Zero W, inovatif fikirlerinizi gerçeğe dönüştürmek için size harika bir başlangıç noktası sunuyor. Bu rehberle, sıfırdan başlayarak Luckfox Lyra Zero W dünyasına adım atacak ve kendi akıllı cihazlarınızı inşa etmenin keyfini yaşayacaksınız.

Günümüzde nesnelerin interneti (IoT) ve yapay zeka (AI) uygulamaları hayatımızın her alanına hızla entegre oluyor. Akıllı ev cihazlarından endüstriyel otomasyona, giyilebilir teknolojilerden akıllı şehirlere kadar geniş bir yelpazede, gömülü sistemlerin önemi her geçen gün artmaktadır. Ancak, bu tür projeler için uygun maliyetli, yüksek performanslı ve kompakt donanımlar bulmak bazen zorlayıcı olabilir. İşte tam da bu noktada, Luckfox Lyra Zero W devreye giriyor ve özellikle bütçe dostu yapısı ve zengin özellikleri ile dikkat çekiyor. Peki, bu küçük kartı bu kadar popüler yapan nedir?

Luckfox Lyra Zero W, Rockchip’in güçlü RV1103 System-on-Chip (SoC) işlemcisi üzerine inşa edilmiş, kredi kartından bile küçük bir geliştirme kartıdır. En büyük avantajı, entegre bir NPU (Neural Processing Unit) yani yapay zeka hızlandırıcısına sahip olmasıdır. Bu sayede, cihaz üzerinde doğrudan yapay zeka çıkarımları yapabilir, nesne tanıma, yüz algılama veya ses işleme gibi görevleri düşük güç tüketimiyle ve yüksek performansla gerçekleştirebilirsiniz. Bu özellik, özellikle kenar bilişim (edge computing) uygulamaları için kritik bir avantaj sunar. Geleneksel olarak bu tür AI görevleri bulut sunucularına bağımlıyken, Luckfox Lyra Zero W gibi kartlar verilerin yerel olarak işlenmesini sağlayarak gecikmeyi azaltır, gizliliği artırır ve bant genişliği maliyetlerinden tasarruf etmenizi sağlar.

Sadece yapay zeka yetenekleriyle değil, aynı zamanda kompakt boyutlarıyla da ön plana çıkar. Küçük boyutu sayesinde, dronlardan giyilebilir cihazlara, akıllı kapı zillerinden güvenlik kameralarına kadar pek çok alanda kolayca entegre edilebilir. Dahili Wi-Fi ve Bluetooth bağlantı özellikleri sayesinde de kablosuz iletişim gerektiren projelerinizde ek modül ihtiyacını ortadan kaldırır. Düşük güç tüketimi ise batarya ile çalışan uygulamalar için ideal bir seçim olmasını sağlar. Tüm bu özellikler bir araya geldiğinde, Luckfox Lyra Zero W, hem hobi amaçlı projeler geliştiren meraklılar hem de profesyonel IoT ürünleri tasarlayan mühendisler için cazip bir seçenek haline gelmektedir. Bu rehber boyunca, bu kartın potansiyelini nasıl ortaya çıkaracağınızı adım adım keşfedeceğiz.

Temel Kavramlar: Luckfox Lyra Zero W Nedir ve Ne Sunar?

Luckfox Lyra Zero W ile derinlemesine bir yolculuğa çıkmadan önce, bu minik ama güçlü kartın temel özelliklerini ve mimarisini anlamak oldukça önemlidir. Bu bilgiler, projenizin gereksinimlerine en uygun çözümleri geliştirmenize yardımcı olacaktır. Temelinde, Rockchip RV1103 adlı entegre bir yonga setini barındırır. Bu SoC (System-on-Chip), tek bir yonga üzerinde bir mikroişlemci, bellek, grafik işlem birimi (varsa), çevre birimleri ve en önemlisi bir NPU’yu bir araya getirir.

RV1103’ün kalbinde, gömülü uygulamalar için optimize edilmiş bir ARM Cortex-A7 işlemci çekirdeği bulunur. Bu çekirdek, işletim sistemi ve genel uygulama mantığını çalıştırmak için yeterli işlem gücünü sunar. Ancak, kartın asıl parladığı nokta, entegre NPU’sudur. Bu yapay zeka hızlandırıcısı, geleneksel CPU’lara kıyasla çok daha verimli bir şekilde yapay zeka çıkarım görevlerini (inference) gerçekleştirebilir. Bu sayede, görüntü işleme, ses tanıma veya anlamsal segmentasyon gibi karmaşık AI algoritmalarını düşük güçle ve gerçek zamanlıya yakın hızlarda çalıştırabilir. Bu durum, özellikle pil ömrünün kritik olduğu mobil veya batarya destekli IoT cihazları için büyük bir avantajdır. Örneğin, bir akıllı kapı zili, gelen ziyaretçiyi hızlıca algılayıp analiz edebilir, bu bilgiyi yerel olarak işleyip sadece gerekli durumlarda bir bildirim gönderebilir.

Bellek tarafında ise Luckfox Lyra Zero W, genellikle dahili bir miktar RAM ile birlikte gelir, bu da işletim sisteminin ve uygulamaların çalışması için gerekli alanı sağlar. Harici depolama için ise bir microSD kart yuvası bulunur, bu da kullanıcılara işletim sistemi imajlarını ve uygulama verilerini depolama esnekliği sunar. Bağlantı seçenekleri de oldukça geniştir. Dahili Wi-Fi modülü sayesinde internete ve diğer ağ cihazlarına kolayca bağlanabilir. Bluetooth desteği ise kablosuz sensörlerle veya diğer düşük güçlü cihazlarla iletişim kurmak için idealdir. Ayrıca, MIPI CSI arayüzü sayesinde yüksek çözünürlüklü kamera modülleri kolayca bağlanabilir; bu da onu yapay zeka destekli görüntü işleme projeleri için mükemmel bir seçenek yapar. GPIO (Genel Amaçlı Giriş/Çıkış) pinleri, I2C, SPI, UART gibi standart çevre birimi arayüzleri de kartın dış dünya ile etkileşim kurmasını ve çeşitli sensörler, aktüatörler veya diğer donanımlarla birleştirilmesini sağlar.

Raspberry Pi Zero W gibi benzer boyutlu kartlarla karşılaştırıldığında, Luckfox Lyra Zero W’nin en belirgin farkı, yukarıda bahsedilen entegre NPU’sudur. Raspberry Pi Zero W genel amaçlı bir bilgisayar olarak daha uygunken, Luckfox Lyra Zero W özellikle yerel AI işleme ve düşük güç tüketimi gerektiren AIoT (Yapay Zeka Nesnelerin İnterneti) ve gömülü görüş (embedded vision) uygulamaları için tasarlanmıştır. Bu özel donanım hızlandırıcısı, belirli AI görevlerinde çok daha üstün performans sergilemesini sağlar. Akıllı ev otomasyonu, endüstriyel izleme sistemleri, giyilebilir yapay zeka cihazları ve akıllı şehir uygulamaları gibi alanlar, Luckfox Lyra Zero W’nin potansiyelini tam anlamıyla ortaya çıkarabileceği başlıca kullanım alanlarıdır.

Başlangıç İçin Gerekli Malzemeler ve İlk Kurulum Adımları Nelerdir?

Luckfox Lyra Zero W ile geliştirme yapmaya başlamak, doğru malzemelerle ve adım adım bir yaklaşımla oldukça kolaydır. Tıpkı herhangi bir mikrodenetleyici veya geliştirme kartında olduğu gibi, ilk kurulum adımları projenizin temelini oluşturur. İşte başlamak için ihtiyacınız olanlar ve ilk kurulum süreci:

Gerekli Malzemeler

• Luckfox Lyra Zero W Geliştirme Kartı: Elbette projenizin kalbi.
• microSD Kart (8GB veya üzeri): İşletim sistemi ve uygulamalarınız için depolama alanı. Hızlı (Class 10 veya üzeri) bir kart tercih etmek performans açısından önemlidir.
• 5V/2A USB-C Güç Kaynağı: Kartı beslemek için güvenilir bir güç kaynağı. Düşük kaliteli veya yetersiz güç kaynakları stabilite sorunlarına yol açabilir.
• USB-C Veri Kablosu: Kartı bilgisayarınıza bağlamak ve ilk kez görüntü yazmak için gereklidir.
• Bilgisayar: İşletim sistemi imajını microSD karta yazmak ve daha sonra kartla etkileşim kurmak için.
• İsteğe Bağlı:
  • TTL Seri Konsol Adaptörü: Başlangıçta hata ayıklama veya ilk önyükleme sorunlarını giderme için çok faydalıdır.
  • MIPI CSI Kamera Modülü: Görüntü işleme veya akıllı kamera projeleri için.
  • Mini HDMI – HDMI Kablosu ve Monitör: Eğer görsel bir arayüze ihtiyaç duyuyorsanız. Ancak çoğunlukla headless (ekransız) modda kullanılabilir.

İlk Kurulum Adımları

Luckfox Lyra Zero W’yi çalıştırmanın ilk adımı, kart için özel olarak hazırlanmış bir işletim sistemi imajını microSD karta yazmaktır. Bu imajlar genellikle Luckfox’un resmi GitHub sayfasından veya topluluk tarafından sağlanan kaynaklardan temin edilebilir.

1. İşletim Sistemi İmajını İndirin: Luckfox’un resmi sitesinden veya GitHub deposundan RV1103 tabanlı Lyra Zero W için uygun olan işletim sistemi imajını indirin. Genellikle bu bir .img dosyası olacaktır.
2. İmajı microSD Karta Yazın: İndirdiğiniz imaj dosyasını microSD karta yazmak için Balena Etcher veya Rufus gibi bir araç kullanmalısınız. Bu araçlar, imaj dosyasını doğru bir şekilde kartınıza kopyalamanızı ve önyüklenebilir hale getirmenizi sağlar.

   
   # Linux üzerinde dd komutu ile imaj yazma (Dikkatli olun, yanlış disk seçimi veri kaybına neden olabilir!)
   # İlk olarak microSD kartınızın bağlı olduğu diski bulun (örneğin /dev/sdX)
   # sudo fdisk -l
   # Ardından imajı yazın
   # sudo dd if=/path/to/your/image.img of=/dev/sdX bs=4M status=progress && sync
           

   Etcher gibi araçlar grafik arayüzü sunduğu için daha kullanıcı dostudur ve hatalı disk seçimi riskini azaltır.

3. microSD Kartı Luckfox Lyra Zero W'ye Takın: İmajı başarıyla yazdıktan sonra, microSD kartı kart üzerindeki yuvaya nazikçe takın.
4. Kartı Çalıştırın: USB-C güç kablosunu kartın güç girişine takın. Kartın durum ışıklarının yandığını görmelisiniz. İlk önyükleme biraz zaman alabilir, sabırlı olun.
5. İlk Bağlantı ve Yapılandırma (Headless SSH):

   Çoğu durumda, Luckfox Lyra Zero W'yi bir monitöre bağlamak yerine SSH üzerinden headless (ekransız) modda kullanmak tercih edilir.

   1. Ağ Bağlantısı: Eğer imajınız Wi-Fi ağına otomatik bağlanacak şekilde önceden yapılandırılmadıysa, ilk önyüklemede USB-C kablosu üzerinden bilgisayarınıza bağlayarak veya Ethernet adaptörü kullanarak ağa bağlamanız gerekebilir. Bazı imajlar USB üzerinden otomatik olarak bir ağ arayüzü oluşturabilir.
   2. IP Adresini Bulun: Kartınız ağa bağlandığında, yerel ağınızdaki IP adresini bulmanız gerekir. Bunu genellikle router'ınızın arayüzünden veya Nmap gibi ağ tarama araçlarıyla yapabilirsiniz:

      
      # Linux/macOS üzerinde
      # nmap -sn 192.168.1.0/24  # Kendi ağ aralığınıza göre düzenleyin
                      

   3. SSH ile Bağlanın: IP adresini bulduktan sonra, bir terminal emülatörü (Linux/macOS için yerleşik terminal, Windows için PuTTY veya Termius) kullanarak SSH ile kartınıza bağlanabilirsiniz:

      
      # SSH bağlantısı
      # ssh root@
      # Varsayılan şifre genellikle "root" veya "luckfox" gibidir, imajınızın belgelerini kontrol edin.
                      

   4. İlk Yapılandırma: Bağlandıktan sonra, şifrenizi değiştirmek, yerel saat dilimini ayarlamak ve sistem güncellemelerini yapmak gibi temel yapılandırmaları gerçekleştirmeniz önerilir.

      
      # Sistem paketlerini güncelleme
      # apt update
      # apt upgrade
                      

Bu adımları tamamladıktan sonra Luckfox Lyra Zero W'niz geliştirme için hazır hale gelecektir. Artık kartınız üzerinde uygulamalarınızı çalıştırmaya, sensörleri bağlamaya ve yapay zeka modellerini denemeye başlayabilirsiniz. Bu süreç, temelleri sağlam bir şekilde atmanızı sağlayarak ileri düzey projelere geçişinizi kolaylaştıracaktır.

Gömülü Yapay Zeka ile Tanışın: NPU Kullanarak Nesne Algılama Nasıl Yapılır?

Luckfox Lyra Zero W'nin en heyecan verici özelliklerinden biri, entegre NPU (Neural Processing Unit) sayesinde doğrudan cihaz üzerinde yapay zeka çıkarımları yapabilme yeteneğidir. Bu, bulut tabanlı AI çözümlerine göre daha hızlı, daha güvenli ve çoğu zaman daha enerji verimli bir yaklaşımdır. Nesne algılama, bu yeteneği sergilemek için harika bir başlangıç noktasıdır. Peki, bu küçük kart üzerinde nesne algılamayı nasıl gerçekleştirebiliriz?

NPU Neden Önemli?

Geleneksel CPU'lar, genel hesaplama görevleri için tasarlanmıştır. Ancak, yapay zeka modellerinin yoğun matris çarpımı ve toplama işlemleri CPU'lar için oldukça maliyetlidir. NPU'lar ise bu tür işlemleri paralel olarak ve özel donanım hızlandırmasıyla gerçekleştirmek üzere optimize edilmiştir. Bu sayede, Luckfox Lyra Zero W'nin NPU'su, örneğin bir YOLO (You Only Look Once) modeli gibi karmaşık bir nesne algılama modelini saniyede kare hızlarında (FPS) çalıştırabilirken, aynı görevi CPU üzerinde çalıştırmak çok daha yavaş ve enerji yoğun olacaktır. Bu durum, gerçek zamanlı video analizi gerektiren uygulamalar için hayati önem taşır.

Nesne Algılama Uygulaması Adım Adım

Bu senaryoda, Luckfox Lyra Zero W'ye bağlı bir kamera modülünden gelen görüntüler üzerinde önceden eğitilmiş bir nesne algılama modeli (örneğin MobileNet-SSD veya küçük bir YOLO versiyonu) kullanarak insanları, araçları veya belirli nesneleri algılayacağız.

1. Gerekli Donanımı Bağlayın:

   Eğer henüz yapmadıysanız, bir MIPI CSI kamera modülünü Luckfox Lyra Zero W'nin kamera portuna bağlayın. Bu bağlantı genellikle bir şerit kablo aracılığıyla yapılır ve doğru yönlendirmeye dikkat etmek önemlidir.

2. Sistemi Hazırlayın:

   Kartınızın güncel olduğundan emin olun ve gerekli kütüphaneleri yükleyin. Luckfox SDK'sı genellikle NPU'ya erişim için özel kütüphaneler (örneğin Rockchip'in RKNPU veya RV1103 özel kütüphaneleri) sağlar. Ayrıca OpenCV gibi görüntü işleme kütüphanelerine de ihtiyacınız olabilir.

   
   # Kütüphane bağımlılıklarını yükleyin (Örnek Python için)
   # sudo apt update
   # sudo apt install python3-pip -y
   # pip3 install opencv-python numpy
   # Luckfox/Rockchip NPU SDK'sına özgü adımlar burada değişebilir, dokümantasyonu kontrol edin.
   # Genellikle SDK, model dönüştürme araçları ve çalışma zamanı kütüphaneleri içerir.
           

3. Önceden Eğitilmiş Modeli İndirin ve Dönüştürün:

   NPU'lar genellikle belirli bir formatta eğitilmiş modelleri (örneğin ONNX, TensorFlow Lite) doğrudan çalıştıramaz. Rockchip NPU'ları için modeller genellikle RKNN (Rockchip Neural Network) formatına dönüştürülmelidir. Rockchip SDK'sı, popüler model formatlarını RKNN'ye dönüştürmek için araçlar sağlar.

   Örneğin, bir MobileNet-SSD modelini ( TensorFlow Lite formatında) indirip RKNN formatına dönüştürebilirsiniz.

   
   # Örnek: Model dönüştürme (genellikle bilgisayarınızda yapılır, kart üzerinde değil)
   # from rknn.api import RKNN
   #
   # rknn = RKNN(verbose=True)
   # rknn.config(mean_values=[128, 128, 128], std_values=[128, 128, 128], channel_mean_value='0 0 0', channel_std_value='1 1 1')
   #
   # # TFLite modelini yükle
   # print('--> Loading model')
   # rknn.load_tflite(model='./model.tflite',
   #                 inputs=['input'],
   #                 outputs=['output'],
   #                 input_size_list=[[1, 300, 300, 3]]) # Modelinize göre boyutları ayarlayın
   # print('done')
   #
   # print('--> Building model')
   # rknn.build(do_quantization=True, dataset='./dataset.txt') # Kuantizasyon için veri kümesi gerekebilir
   # print('done')
   #
   # print('--> Export rknn model')
   # rknn.export_rknn(export_path='./model.rknn')
   # print('done')
   #
   # rknn.release()
           

   Dönüştürülen .rknn dosyasını microSD kartınıza veya Luckfox Lyra Zero W'nin dahili depolama birimine aktarın.

4. Python ile Nesne Algılama Kodu Yazın:

   Şimdi, kamera görüntüsünü alacak, NPU üzerinde çıkarım yapacak ve algılama sonuçlarını gösterecek bir Python betiği yazalım.

   
   import cv2
   import numpy as np
   from rknpu.api import RKNN # Bu kütüphane Luckfox SDK'sından gelir ve NPU ile etkileşimi sağlar
   
   # Modeli yükle
   RKNN_MODEL = './model.rknn'
   rknn = RKNN(verbose=True)
   print('--> Loading rknn model')
   ret = rknn.load_rknn(RKNN_MODEL)
   if ret != 0:
       print('Load rknn model failed!')
       exit(ret)
   print('done')
   
   print('--> Init runtime environment')
   ret = rknn.init_runtime(core_mask=RKNN.NPU_CORE_0) # NPU çekirdeğini belirtin
   if ret != 0:
       print('Init runtime environment failed!')
       exit(ret)
   print('done')
   
   # Kamera akışını başlat
   cap = cv2.VideoCapture(0) # 0, genellikle varsayılan kamera demektir. Luckfox'ta farklı olabilir.
   if not cap.isOpened():
       print("Kamera açılamadı!")
       exit()
   
   while True:
       ret, frame = cap.read()
       if not ret:
           break
   
       # Görüntüyü modele uygun boyuta yeniden boyutlandır ve normalize et
       # Modelinizin beklediği giriş boyutuna ve normalizasyonuna dikkat edin (örn: 300x300, 0-1 veya -1-1 aralığı)
       img_resized = cv2.resize(frame, (300, 300))
       img_normalized = (img_resized / 255.0).astype(np.float32) # Örnek normalizasyon
       img_input = img_normalized[np.newaxis, :, :, :] # Batch boyutu ekle (1, H, W, C)
   
       # NPU üzerinde çıkarım yap
       outputs = rknn.inference(inputs=[img_input])
   
       # Çıkarım sonuçlarını işle (Modelden modele değişir)
       # outputs[0] genellikle algılanan nesne kutularını, etiketlerini ve güven skorlarını içerir.
       # Bu kısım, kullandığınız modelin çıktı formatına göre özelleştirilmelidir.
       # Örnek olarak, basitleştirilmiş bir kutu çizimi:
       for detection in outputs[0]: # Varsayımsal çıktı formatı
           score = detection[4]
           if score > 0.5: # Güven skoru %50'den yüksekse
               x1, y1, x2, y2 = (detection[:4] * np.array([frame.shape[1], frame.shape[0], frame.shape[1], frame.shape[0]])).astype(int)
               cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
               cv2.putText(frame, f'Nesne: {score:.2f}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
   
       # Sonucu ekranda göster (eğer monitör bağlıysa veya bir web akışı ile)
       # cv2.imshow('Nesne Algilama', frame) # Sadece masaüstü ortamında çalışır
   
       # Web akışı için kareleri bir HTTP sunucusuna gönderebilirsiniz
       # veya sadece çıktıları bir dosyaya kaydedebilirsiniz.
   
       if cv2.waitKey(1) & 0xFF == ord('q'):
           break
   
   cap.release()
   cv2.destroyAllWindows()
   rknn.release()
           

   Uzman İpucu: NPU performansını en üst düzeye çıkarmak için, modelinizi kuantizasyon (nicemleme) işlemiyle daha düşük hassasiyetli (örn. INT8) formatlara dönüştürmeyi düşünebilirsiniz. Bu, model boyutunu küçültür ve çıkarım hızını önemli ölçüde artırırken, çoğu durumda doğrulukta kabul edilebilir bir düşüşe neden olur. Luckfox/Rockchip NPU araçları genellikle bu özelliği destekler.

5. Uygulamayı Çalıştırın:

   Betiği Luckfox Lyra Zero W'ye kopyalayın ve SSH üzerinden çalıştırın:

   
   # scp your_script.py root@:/home/
   # ssh root@
   # python3 /home/your_script.py
           

Bu adımları takip ederek, Luckfox Lyra Zero W'nin NPU'sunu kullanarak gerçek zamanlı nesne algılama yapabilen bir sistem kurabilirsiniz. Bu yetenek, akıllı güvenlik kameraları, otonom robotlar veya perakende analizi gibi birçok gerçek dünya uygulamasının temelini oluşturabilir.

Gerçek Dünya Uygulamaları: Bir Akıllı Kamera Sistemi Nasıl Oluşturulur?

Luckfox Lyra Zero W'nin NPU özelliklerini kullanarak nesne algılama temellerini öğrendikten sonra, bu bilgiyi daha kapsamlı bir gerçek dünya uygulamasına dönüştürmenin zamanı geldi: kendi akıllı kamera sisteminizi oluşturmak. Bu tür bir sistem, yalnızca görüntü yakalamakla kalmayacak, aynı zamanda yakalanan verileri analiz edecek ve belirli olaylara tepki verecektir. Hayal edin: evinize yaklaşan bir kişiyi otomatik olarak algılayan, bir bildirim gönderen ve gerekirse görüntüyü kaydeden bir sistem. İşte adım adım böyle bir sistemi nasıl kurabileceğiniz.

Vaka Analizi: Akıllı Güvenlik Kamerası

Hedefimiz, Luckfox Lyra Zero W'yi kullanarak, hareket algıladığında (özellikle bir insan algıladığında) kullanıcıya anlık bildirim gönderen ve olayın kısa bir videosunu kaydeden basit bir güvenlik kamerası oluşturmak.

1. Donanım Hazırlığı:
   • Luckfox Lyra Zero W: Elbette ana işlemcimiz.
   • MIPI CSI Kamera Modülü: Yüksek çözünürlüklü görüntü yakalama için.
   • microSD Kart: İşletim sistemi, model ve kaydedilen videolar için yeterli depolama (minimum 16GB önerilir).
   • Güç Kaynağı: Stabil çalışma için 5V/2A.
   • İnternet Bağlantısı: Bildirim göndermek için Wi-Fi.
2. Yazılım Ortamının Kurulumu:

   Önceki bölümde bahsedildiği gibi, Luckfox Lyra Zero W üzerinde temel işletim sistemini kurun ve SSH bağlantısını sağlayın. Ardından, aşağıdaki kütüphaneleri yükleyin:

   • OpenCV: Görüntü ve video işleme için.
   • Numpy: Sayısal işlemler için.
   • RKNPU API: NPU ile etkileşim için (Luckfox SDK'sı ile birlikte gelir).
   • Python Requests: HTTP istekleri göndererek bildirim göndermek için (isteğe bağlı, farklı bildirim yöntemleri de kullanılabilir).
   • FFmpeg: Video kayıt ve sıkıştırma için (genellikle Linux sistemlerinde mevcuttur).

   
   # Gerekli Python kütüphanelerini yükleyin
   # sudo apt install python3-pip -y
   # pip3 install opencv-python numpy requests
   
   # FFmpeg kurulumu (eğer mevcut değilse)
   # sudo apt install ffmpeg -y
           

3. Nesne Algılama Modelinin Entegrasyonu:

   Önceki bölümde dönüştürdüğümüz .rknn formatındaki nesne algılama modelini (örneğin insan algılaması için eğitilmiş MobileNet-SSD veya YOLO-nano) Luckfox Lyra Zero W'ye aktarın. Modelin algılayabileceği etiketleri içeren bir labels.txt dosyasına da ihtiyacınız olabilir.

4. Python Komut Dosyasının Geliştirilmesi:

   Şimdi, tüm bileşenleri bir araya getiren ana Python komut dosyasını (smart_cam.py) oluşturalım.

   
   import cv2
   import numpy as np
   import time
   import requests
   import subprocess
   from rknpu.api import RKNN # NPU API
   
   # --- Yapılandırma ---
   RKNN_MODEL_PATH = './model.rknn'
   LABELS_PATH = './labels.txt' # Modelinizin algıladığı nesne etiketleri
   CAMERA_INDEX = 0 # Varsayılan kamera indeksi (MIPI CSI için kontrol edin)
   CONF_THRESHOLD = 0.6 # Algılama güven skoru eşiği
   RECORD_DURATION = 10 # Kaydedilecek video süresi (saniye)
   NOTIFICATION_URL = "https://api.telegram.org/bot/sendMessage" # Örnek Telegram Bot API
   CHAT_ID = "" # Telegram sohbet kimliğiniz
   
   # --- Fonksiyonlar ---
   def send_notification(message):
       try:
           data = {"chat_id": CHAT_ID, "text": message}
           requests.post(NOTIFICATION_URL, data=data)
           print(f"Bildirim gönderildi: {message}")
       except Exception as e:
           print(f"Bildirim gönderme hatası: {e}")
   
   def record_video(filename, duration, camera_index):
       print(f"Video kaydı başlatılıyor: {filename}")
       # FFmpeg kullanarak videoyu kaydetme
       # Kamera indeksini ve çözünürlüğü sisteminize göre ayarlayın
       command = [
           'ffmpeg',
           '-f', 'v4l2',          # Video for Linux 2 input
           '-framerate', '30',    # Kare hızı
           '-video_size', '1280x720', # Kamera çözünürlüğü
           '-i', f'/dev/video{camera_index}', # Kamera cihazı (farklı olabilir)
           '-c:v', 'libx264',     # Video codec
           '-preset', 'ultrafast',# Hızlı sıkıştırma
           '-t', str(duration),   # Kayıt süresi
           '-y',                  # Var olan dosyayı üzerine yaz
           filename
       ]
       try:
           subprocess.run(command, check=True)
           print(f"Video kaydı tamamlandı: {filename}")
       except subprocess.CalledProcessError as e:
           print(f"Video kaydı hatası: {e}")
   
   # --- Ana Program ---
   def main():
       # 1. RKNN Modelini Yükle
       rknn = RKNN(verbose=True)
       ret = rknn.load_rknn(RKNN_MODEL_PATH)
       if ret != 0:
           print('RKNN modeli yüklenemedi!')
           return
   
       ret = rknn.init_runtime(core_mask=RKNN.NPU_CORE_0)
       if ret != 0:
           print('RKNN çalışma zamanı başlatılamadı!')
           return
   
       with open(LABELS_PATH, 'r') as f:
           labels = [line.strip() for line in f.readlines()]
   
       # 2. Kamera Akışını Başlat
       cap = cv2.VideoCapture(CAMERA_INDEX)
       if not cap.isOpened():
           print("Kamera açılamadı! Lütfen CAMERA_INDEX veya kamera bağlantısını kontrol edin.")
           return
   
       last_detection_time = 0
       record_active = False
   
       print("Akıllı Kamera Sistemi Başlatıldı...")
       while True:
           ret, frame = cap.read()
           if not ret:
               print("Kareden okuma hatası!")
               break
   
           # Görüntüyü modele uygun boyuta yeniden boyutlandır ve normalize et
           img_resized = cv2.resize(frame, (300, 300)) # Modelinizin beklediği boyut
           img_normalized = (img_resized / 255.0 - 0.5) * 2.0 # Örnek normalizasyon (-1 ile 1 arası)
           img_input = img_normalized.astype(np.float32)[np.newaxis, :, :, :]
   
           # 3. NPU ile Çıkarım Yap
           outputs = rknn.inference(inputs=[img_input])
           detections = outputs[0] # Model çıktınızın formatına göre bu kısmı özelleştirin
   
           human_detected = False
           for detection in detections:
               # Örnek çıktı formatı: [x1, y1, x2, y2, score, class_id]
               score = detection[4]
               class_id = int(detection[5])
               
               if score > CONF_THRESHOLD and labels[class_id] == 'person': # "person" etiketi için kontrol
                   x1, y1, x2, y2 = (detection[:4] * np.array([frame.shape[1], frame.shape[0], frame.shape[1], frame.shape[0]])).astype(int)
                   cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                   cv2.putText(frame, f'{labels[class_id]}: {score:.2f}', (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
                   human_detected = True
   
           # 4. Olay Yönetimi (Bildirim ve Kayıt)
           current_time = time.time()
           if human_detected and not record_active:
               if current_time - last_detection_time > 30: # Son bildirimden 30 saniye sonra tekrar bildirim gönder
                   send_notification("Hareket algılandı! Bir kişi görüldü.")
                   filename = f"detection_{int(current_time)}.mp4"
                   # Video kaydını ayrı bir işlemde başlat
                   import threading
                   record_thread = threading.Thread(target=record_video, args=(filename, RECORD_DURATION, CAMERA_INDEX))
                   record_thread.start()
                   record_active = True
                   last_detection_time = current_time
           elif not human_detected and record_active and not record_thread.is_alive():
                record_active = False # Kayıt tamamlandı ve insan yoksa durumu sıfırla
   
           # Eğer bir monitör bağlıysa görüntüyü göster
           # cv2.imshow('Akıllı Guvenlik Kamerasi', frame)
           # if cv2.waitKey(1) & 0xFF == ord('q'):
           #     break
   
       cap.release()
       # cv2.destroyAllWindows()
       rknn.release()
   
   if __name__ == "__main__":
       main()
           

   Not: Bu kod örneği, varsayımsal bir model çıktısı ve Telegram API kullanımı içerir. Kendi modelinizin çıktı formatına ve tercih ettiğiniz bildirim mekanizmasına (e-posta, diğer anlık mesajlaşma servisleri, MQTT vb.) göre uyarlamanız gerekecektir. Telegram botu için ve kısımlarını kendi bilgilerinizle doldurmanız gerekmektedir. FFmpeg komutundaki /dev/video{camera_index} yolu da sisteminize göre farklılık gösterebilir (örneğin /dev/video0 veya /dev/video1).

5. Uygulamayı Çalıştırma ve Test Etme:

   Komut dosyasını Luckfox Lyra Zero W'ye aktarın ve çalıştırın. Kameranın görüş alanında bir hareket (veya kişi) algılandığında, bildirim almalı ve bir video kaydının başladığını görmelisiniz.

   
   # scp smart_cam.py labels.txt model.rknn root@:/home/smart_cam/
   # ssh root@
   # cd /home/smart_cam/
   # python3 smart_cam.py
           

Bu akıllı kamera sistemi, Luckfox Lyra Zero W'nin AI yeteneklerini gerçek dünya sorunlarını çözmek için nasıl kullanılabileceğinin harika bir örneğidir. Benzer mantıkla, farklı sensör verilerini birleştirerek (örneğin sıcaklık, nem) ve farklı AI modelleri kullanarak (örneğin ses tanıma) çok daha karmaşık ve akıllı IoT cihazları tasarlayabilirsiniz. Bu proje, hem donanım hem de yazılım entegrasyonu becerilerinizi geliştirmeniz için sağlam bir temel sunar.

Mobil Uyumlu Arayüzler Geliştirmek: Basit Bir Web Sunucusu Kurulumu

Akıllı kamera sisteminiz artık olayları algılayıp bildirim gönderebiliyor. Peki ya kamera beslemesini canlı olarak izlemek veya sistem ayarlarını uzaktan değiştirmek isterseniz? İşte burada mobil uyumlu bir web arayüzü devreye giriyor. Luckfox Lyra Zero W üzerinde basit bir web sunucusu kurarak, projenizi bir web tarayıcısı üzerinden kontrol edebilir ve izleyebilirsiniz. Flask gibi hafif bir Python web çerçevesi bu iş için oldukça uygundur.

Flask ile Basit Bir Web Sunucusu Kurulumu

Flask, Python ile web uygulamaları geliştirmek için minimalist ve esnek bir mikro-çerçevedir. Luckfox Lyra Zero W üzerinde de kolayca çalıştırılabilir.

1. Flask'ı Yükleyin:

   Luckfox Lyra Zero W üzerinde SSH ile bağlanıp Flask'ı pip ile yükleyin:

   
   # pip3 install Flask
           

2. Web Sunucusu Kodu (app.py):

   Basit bir Flask uygulaması oluşturalım. Bu uygulama, ana sayfada "Merhaba Luckfox!" yazacak ve bir de kamera durumunu gösterecek bir sayfa içerecek.

   
   from flask import Flask, render_template_string, Response
   import cv2
   import time
   
   app = Flask(__name__)
   
   # Basit bir HTML şablonu
   HTML_TEMPLATE = '''
   
       
   
           
   Luckfox Lyra Zero W Akıllı Kamera Arayüzü
           
   Cihazınızın durumu ve canlı kamera akışı aşağıdadır.
           
           Ayarları Değiştir
           
   Son güncelleme: {{ current_time }}