Tahıl zararlıları, dünya genelinde olduğu gibi Türkiye'de de önemli ürün kayıplarına neden olmaktadır. Phorbia securis (Diptera: Anthomyiidae), özellikle Trakya Bölgesi'nde buğday üretimini tehdit eden bir zararlı olup, larvaları bitkilerin sap dokusunda beslenirken "göbek kurusu" denilen karakteristik zararı meydana getirmektedir. Zararlının gizli yaşam tarzı, geleneksel mücadele yöntemlerinin etkinliğini ciddi oranda sınırlandırmaktadır. Son yıllarda tarımsal üretimde dijital teknolojilerin kullanımı hızla artmaktadır. Özellikle zararlı popülasyonlarının izlenmesi, risk tahminleri ve karar destek sistemlerinin geliştirilmesinde veri analizi ve yapay zekâ uygulamaları öne çıkmaktadır.
Zararlının Biyolojisi ve Ekolojisi
Morfolojik Özellikler
Ergin: P. securis erginleri genellikle siyah renkte olup, vücut uzunluğu 3.5-5.0 mm arasında değişmektedir. Kanat uzunluğu 3.0-4.5 mm olup, istirahat halinde abdomeni yaklaşık 1.0-1.5 mm geçmektedir. Kanatlar gri renkli olup, kanat damarları karakteristik kahverengi renktedir. Bu morfolojik özellikler, sahada teşhis için kritik öneme sahiptir.
Yumurta: Yeni bırakılmış yumurtalar beyaz renktedir ve zaman içinde sarımsı bir renk alır. Ortalama uzunlukları 1.2 mm olup, silindirik bir yapıya sahiptir. Yumurtalar genellikle koleoptile, yaprak kını altı veya yakacık (ligula) civarına bırakılır.
Larva: Toplam üç larva dönemi mevcuttur. Birinci dönem larvalar yumurtadan çıktığında beyaz renkte ve yaklaşık 1.0 mm boyundadır. İkinci dönem larva boyu yaklaşık 3.0 mm'ye ulaşır. Üçüncü dönem larvalar sarımsı-beyaz renkte ve ortalama 7 mm uzunluğundadır. Larvanın anterior kısmı sivrimsi, posterior kısmı ise küt biçimdedir. Bu morfoloji, larvanın sap dokusunda hareket etmesini kolaylaştırır.
Pupa: Pupalar kırmızımsı kahve renkte, fıçı şeklinde olup ortalama 4 mm uzunluğundadır. Anal bölgede karakteristik olarak 2 adet stigma bulunur.
Yaşam Döngüsü
P. securis, Trakya Bölgesi'nde yılda iki döl vermektedir: ilkbahar dölü ve sonbahar dölü. Bu bivoltinizm, zararlının popülasyon dinamiğini ve zarar potansiyelini önemli ölçüde etkiler.
Kışlama: Sonbahar dölünün bireyleri, kışı toprakta pupa olarak geçirir. Pupalar genellikle zarar verdikleri bitkiden maksimum 4 cm uzaklıkta, 1-3 cm toprak derinliğinde, nadiren 5 cm derinliğe kadar olan kökler arasında bulunur.
İlkbahar Dönemi (Birinci Döl): Pupalardan ergin çıkışı nisan ayında, toprak sıcaklığının 8-10°C'yi aştığı dönemde başlar. Dişi erginler, yazlık ekim yapılan buğdayın ilk çıkış döneminde yumurtalarını bırakırlar. Bir dişi günde 2-7 adet olmak üzere toplam 20-45 yumurta üretir. Yumurtadan çıkan larvalar, mayıs sonu haziran başlarında olgun larva haline gelir ve yazı diyapoz durumunda geçirirler.
Sonbahar Dönemi (İkinci Döl): Birinci dölün ergin çıkışı eylül-ekim aylarında gerçekleşir. Bu dönemde hava sıcaklıklarının henüz düşük olduğu süreçte, erginler ikinci dölü oluşturacak yumurtaları bırakırlar. Yumurtadan çıkan larvalar, erken ekilen kışlık buğdaylarda, özellikle tarlaların kenar kısımlarında yoğunlaşarak, toprağa yakın sap kısmında beslenirler. Larvalar yaklaşık 5 cm uzunluğunda galeriler açarak zarar yaparlar. İkinci döl larva süresi daha kısa olup, maksimum 1.5 aydır.
Zarar Şekli ve Ekonomik Önemi
Buğday karasineği larvalarının zararı, bitkinin kardeşlenme döneminde, özellikle erken ekilen tahıllarda görülür. Larva, ana sapın genellikle 5 cm yukarısından girerek beslenir ve sapın kurumasına yol açar. Bu durum "göbek kurusu" olarak bilinir ve bitkilerin tamamen ölmesine neden olabilir. Bazı yıllarda, iklim koşullarına bağlı olarak zarar seviyesi dramatik şekilde artabilmektedir. Özellikle ılık geçen kışlar ve erken ekim yapılan alanlarda zararlı popülasyonu yüksek seviyelere ulaşabilir. Bitkilerde büyümede gerileme, kardeş sayısında azalma ve şiddetli enfestasyonlarda tam ölüm gözlenir.
Coğrafi Yayılış ve Konukçular
Yayılış: Türkiye'de P. securis'in zararı, Trakya Bölgesi'nde Edirne, Kırklareli ve Tekirdağ illerinde tespit edilmiştir. Bu bölge, zararlının biyolojisi için uygun ekolojik koşullara sahiptir.
Konukçular: Zararlının ana konukçuları arasında buğday, arpa, çavdar, yulaf ve bazı yabani gramineler bulunmaktadır. Yabani konukçular arasında ayrık (Agropyron repens), püsküllü çayır otu (Bromus spp.) ve itkuyruğu (Phleum pratense) öne çıkmaktadır. Özellikle kışlık buğday ve yazlık arpada zarar seviyesi oldukça yüksektir. İlginç bir şekilde, makarnalık buğday çeşitlerinin zararlı tarafından daha az tercih edildiği gözlemlenmiştir.
Geleneksel Mücadele Yöntemlerinin Sınırlılıkları
Kültürel Önlemler
Buğday karasineğine karşı önerilen kültürel tedbirler şunlardır:
- Anızların yakılmadan mekanik yöntemlerle yok edilmesi
- Ekim nöbeti uygulanması
- İyi toprak işleme ve özellikle derin sürüm (≥20-25 cm)
- Makarnalık buğday ekimine ağırlık verilmesi
- Ekim tarihinin geciktirilmesi (özellikle kışlık buğdayda)
Bu önlemler, zararlıyla mücadelede en güvenilir ve sürdürülebilir yöntemlerdir. Ancak uygulanma zamanı ve yöntemi kritik önem taşır ve her tarla için optimum koşullar farklılık gösterebilir.
Biyolojik Mücadelenin Yetersizliği
Doğal Düşmanlar: Zararlının bazı doğal düşmanları olmakla birlikte, bunların etkinliği son derece sınırlıdır. Toprakta yaşayan polifag yırtıcılar (Carabidae, Staphylinidae ve bazı örümcekler) larva ve pupaları tüketebilir, ancak bu türler zararlıya spesifik değildir ve popülasyonları iklim ve tarımsal uygulamalara çok bağımlıdır.
Parazitoitler: Literatürde Anthomyiidae familyasına saldıran bazı Braconidae ve Ichneumonidae parazitoitleri bildirilmesine rağmen, P. securis için tanımlanmış, yaygın ve etkili bir parazitoit türü bulunmamaktadır. Türkiye koşullarında saha etkinliği gösterilmiş bir tür de yoktur.
Entomopatojen Funguslar: Beauveria bassiana ve Metarhizium anisopliae gibi entomopatojen funguslar teorik olarak etkili olabilir. Ancak larva ve pupaların toprak içinde ve galerilerde bulunması nedeniyle, fungusun hedefe ulaşması son derece zordur. Tarla koşullarında ekonomik ve istikrarlı başarı sağlanamamıştır.
Bakteriyel Ajanlar: Bacillus thuringiensis (Bt) gibi bakteriyel insektisitler bu zararlıya karşı etkisizdir, çünkü larvalar yaprak yemez, sap içinde ve toprak yakınında beslenir.
Biyolojik Mücadelenin Başarısız Olmasının Nedenleri:
- Larvaların gizli yaşam döngüsü (sap içinde ve toprakta)
- Kısa ve düzensiz larva dönemleri
- Popülasyon yoğunluğunun yıllara göre çok değişken olması
- Doğal düşmanların zararlıyla zamanlama uyumsuzluğu
Kimyasal Mücadelenin Zorlukları
Buğday karasineği, yapısal özellikleri nedeniyle kimyasal mücadeleye son derece elverişsizdir:
a) Larvanın Gizli Yaşamı: Larva sap içinde, toprak yüzeyine çok yakın bölgede beslenir. Temas ve mide etkili insektisitler larvaya ulaşamaz.
b) Geç Teşhis: "Göbek kurusu" fark edildiğinde, larva zaten ana sapı tahrip etmiştir ve kimyasal uygulama ekonomik fayda sağlamaz.
c) Kritik Zamanlama: Ergin uçuşu kısa ve düzensizdir. Yumurtlama dönemi net ve yaygın şekilde izlenemez. Yanlış zamanlama, tamamen etkisiz uygulamalara yol açar.
d) Tohum İlaçlarının Sınırlılığı: Sistemik tohum ilaçları yaprak ve kök dokusunda etkili olsa da, sap içindeki larvaya yeterli doz ulaşmaz. Ayrıca Anthomyiidae türlerine özel ruhsatlı tohum ilacı bulunmamaktadır.
Modern Yaklaşım: Veri Tabanlı Risk Yönetimi
Paradigma Değişimi
Buğday karasineğinde başarılı mücadelenin anahtarı, reaktif değil proaktif olmaktır:
Geleneksel Yaklaşım: Zarar oluştuktan sonra müdahale → Başarısızlık
Modern Yaklaşım: Zarar oluşmadan risk yönetimi → Başarı
Bu yaklaşım değişimi, veri analitiği ve yapay zekâ teknolojileriyle mümkün hale gelmiştir.
Veri Analizinin Rolü
Veri analizi, buğday karasineği yönetiminde üç temel alanda kritik değer sağlar: - Erken Uyarı ve Risk Tahmini: Zarar oluşmadan önce "risk var mı?" sorusuna doğru cevap vermek, en güçlü müdahale stratejisidir.
- Kültürel Önlemlerin Optimizasyonu: Hangi kültürel önlemin hangi koşullarda ne kadar etkili olduğunu sayısal olarak gösterir.
- Kaynak Tahsisinin Etkinleştirilmesi: Sınırlı kaynakların (işgücü, zaman, girdi) en riskli alanlara yönlendirilmesini sağlar.
Gerekli Veri Katmanları
Etkili bir risk yönetim sistemi için dört temel veri katmanı gereklidir:
Meteorolojik Veriler (En Kritik)
- Toprak sıcaklığı (0-5 cm derinlik)
- Günlük ortalama, minimum ve maksimum hava sıcaklığı
- Toprak nemi
- Donlu gün sayısı
- İlkbahar ısı birikimi (Growing Degree Days - GDD)
Kritik Biyolojik Eşikler:
- Ergin çıkışı: Toprak sıcaklığı ≥ 8-10°C
- Yumurtlama riski: Gündüz sıcaklığı ≥ 15°C, rüzgarsız günler
- Aktivasyon: Yaklaşık 150-200 GDD birikimi
Tarımsal Uygulama Verileri
- Ekim tarihi (en güçlü risk faktörü)
- Buğday çeşidi (makarnalık/ekmeklik)
- Ön bitki
- Toprak işleme derinliği
- Anız yönetimi
- Tarla kenarı özellikleri
Önemli Bulgu: Erken ekim, en güçlü risk faktörüdür. Analizler, 10-20 gün gecikmenin riskte %40-70 düşüş sağladığını göstermektedir.
Tarihsel Zarar Verisi
- Önceki yıllarda göbek kurusu görülen parseller
- Zarar yoğunluğu ve dağılımı
- Tarla kenarı-merkez fark analizi
Bu veri yoksa sistem yaklaşık %40 etkinlik kaybeder.
Uzaktan Algılama Verileri
Sentinel-2 uydu görüntülerinden elde edilen:
- NDVI (Normalized Difference Vegetation Index): Bitki sağlığı
- NDRE (Normalized Difference Red Edge): Erken stres tespiti
- Tarla kenarı-merkez karşılaştırma analizi
Amaç: Erken gelişim yavaşlamasını tespit etmek ve kenar yoğunluğunu sayısallaştırmak.
Yapay Zekâ Destekli Erken Uyarı Sistemi
Sistem Mimarisi
TOPRAK & HAVA KOŞULLARI
↓
VERİ TOPLAMA
(Sensörler + İstasyonlar)
↓
VERİ ÖNİŞLEME
(Temizleme + Dönüştürme)
↓
ÖZELLİK MÜHENDİSLİĞİ
(GDD, Trendler, Etkileşimler)
↓
YAPAY ZEKÂ MODELİ
(Risk Sınıflandırması)
↓
KARAR DESTEK SİSTEMİ
(Düşük/Orta/Yüksek Risk)
↓
SAHA UYGULAMASI
(Kültürel Önlemler)
Model Seçimi ve Gerekçelendirme
Logistic Regression (Lojistik Regresyon)
Avantajlar:
- Az veriyle çalışabilir
- Şeffaf ve yorumlanabilir
- Hesaplama maliyeti düşük
- Ziraat mühendisleri için ideal
Kullanım Alanı: Küçük ölçekli sistemler, pilot çalışmalar
Python Implementasyonu:
python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
Veri yükleme
data = pd.read_csv("phorbia_veri.csv")
data = data.dropna()
Özellik ve hedef ayrımı
X = data[[
'ekim_gunu',
'ort_kis_sic',
'mart_ort_sic',
'gdd',
'onceki_yil_zarar'
]]
y = data['risk']
Veri bölme
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42, stratify=y
)
Model eğitimi
model = LogisticRegression(max_iter=1000, random_state=42)
model.fit(X_train, y_train)
Tahmin ve değerlendirme
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))
Değişken önemlerini görüntüleme
for col, coef in zip(X.columns, model.coef_[0]):
print(f"{col}: {round(coef, 3)}")
Risk olasılığı hesaplama
risk_prob = model.predict_proba(X_test)
Kabul Edilebilir Performans Metrikleri:
- Accuracy ≥ 70%
- Recall (risk=1) ≥ 65%
- Precision (risk=1) ≥ 60%
Random Forest (Rastgele Orman)
Avantajlar:
- Doğrusal olmayan ilişkileri yakalar
- Değişken önemini doğrudan verir
- Overfitting'e dirençli
- Orta büyüklükte veri setleri için ideal
Kullanım Alanı: İl/ilçe düzeyinde operasyonel sistemler
Python Implementasyonu:
python
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt
Model oluşturma
rf_model = RandomForestClassifier(
n_estimators=300,
max_depth=6,
min_samples_split=10,
min_samples_leaf=5,
random_state=42,
class_weight='balanced'
)
Eğitim
rf_model.fit(X_train, y_train)
Değişken önemleri
feature_importance = pd.DataFrame({
'feature': X.columns,
'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)
print(feature_importance)
Görselleştirme
plt.figure(figsize=(10, 6))
plt.barh(feature_importance['feature'], feature_importance['importance'])
plt.xlabel('Önem Skoru')
plt.title('Değişken Önem Sıralaması')
plt.tight_layout()
plt.savefig('feature_importance.png', dpi=300)
Gradient Boosting
Avantajlar:
- En yüksek doğruluk potansiyeli
- Karmaşık etkileşimleri öğrenir
- Büyük veri setlerinde üstün performans
Kullanım Alanı: Bölgesel ve ulusal ölçekli sistemler
Python Implementasyonu:
python
from sklearn.ensemble import GradientBoostingClassifier
gb_model = GradientBoostingClassifier(
n_estimators=200,
learning_rate=0.1,
max_depth=5,
min_samples_split=20,
min_samples_leaf=10,
subsample=0.8,
random_state=42
)
gb_model.fit(X_train, y_train)
Özellik Mühendisliği
Ham veriden anlamlı özellikler türetmek, model performansını ciddi oranda artırır:
python
def feature_engineering(df):
GDD hesaplama
df['gdd'] = ((df['max_temp'] + df['min_temp']) / 2 - 5).clip(lower=0)
Ekim kategorisi
df['ekim_kategori'] = pd.cut(df['ekim_gunu'],
bins=[0, 290, 310, 365],
labels=['erken', 'normal', 'gec'])
Sıcaklık trendi
df['sicaklik_trendi'] = df.groupby('parsel_id')['toprak_sic'].diff()
Kış şiddeti indeksi
df['kis_siddeti'] = (df['donlu_gun_sayisi'] *
(5 - df['ort_kis_sic'])).clip(lower=0)
Etkileşim değişkenleri
df['ekim_x_kis'] = df['ekim_gunu'] * df['ort_kis_sic']
df['gdd_x_onceki_zarar'] = df['gdd'] * df['onceki_yil_zarar']
return df
Model Değerlendirme ve Validasyon
python
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.metrics import roc_auc_score, roc_curve
Çapraz doğrulama
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = cross_val_score(model, X, y, cv=cv, scoring='roc_auc')
print(f"Ortalama AUC: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")
ROC eğrisi
y_prob = model.predict_proba(X_test)[:, 1]
fpr, tpr, thresholds = roc_curve(y_test, y_prob)
auc = roc_auc_score(y_test, y_prob)
plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, label=f'AUC = {auc:.3f}')
plt.plot([0, 1], [0, 1], 'k--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Eğrisi')
plt.legend()
plt.savefig('roc_curve.png', dpi=300)
Risk Sınıflandırması ve Karar Eşikleri
Model çıktılarını uygulanabilir kararlara dönüştürmek için risk eşikleri tanımlanmalıdır:
| Risk Olasılığı | Risk Seviyesi | Önerilen Aksiyon |
|----------------|---------------|------------------|
| < 0.30 | Düşük Risk | Standart ekim uygulamaları |
| 0.30 - 0.60 | Orta Risk | Ekim geciktirme + tarla kenarı kontrolü |
| > 0.60 | Yüksek Risk | Ekim geciktirme + derin sürüm + ekim nöbeti |
Örnek Karar Algoritması:
python
def risk_recommendation(probability):
if probability < 0.30:
return {
'risk_level': 'Düşük',
'actions': [
'Standart ekim tarihi uygulanabilir',
'Rutin tarla kontrolleri yeterli'
]
}
elif probability < 0.60:
return {
'risk_level': 'Orta',
'actions': [
'Ekim tarihini 10-15 gün geciktir',
'Tarla kenarlarını daha sık kontrol et',
'Makarnalık buğday tercih et'
]
}
else:
return {
'risk_level': 'Yüksek',
'actions': [
'Ekim tarihini 15-20 gün geciktir',
'En az 25 cm derin sürüm yap',
'Ekim nöbeti uygula',
'Alternatif ürün değerlendir',
'Tarla kenarlarını yoğun izle'
]
}
Mikrodenetleyici Tabanlı Saha Sensör Sistemi
Neden Mikrodenetleyici Gereklidir?
Buğday karasineğinin biyolojisi mikroiklimle doğrudan ilişkilidir. Meteoroloji istasyonları ilçe ortalaması verirken, tarlanın gerçek koşullarını yansıtmaz. 1-2°C'lik fark bile risk seviyesini değiştirebilir.
Mikrodenetleyicinin Avantajları:
- Ergin Çıkış Eşiğini Doğru Yakalar
- İlçe istasyonu: 7.5°C
- Tarla kenarı gerçek: 9.2°C
- Bu fark, erken alarm üretiminde kritiktir - Tarla Kenarı-Merkez Farkını Gösterir
- Zararlı her zaman kenarlardan başlar
- İki sensör ile bu fark sayısallaştırılır - GDD Hesabını Gerçekçi Yapar
- Klasik GDD hava sıcaklığına dayanır
- Toprak GDD bu zararlı için çok daha değerlidir - Yapay Zekâ ile Entegrasyon
- Ham veri → Anlam üretimi
- Yanlış alarmları ciddi biçimde azaltır
Donanım Bileşenleri
Mikrodenetleyici
Önerilen: ESP32
Teknik Özellikler:
- Dual-core işlemci (240 MHz)
- Wi-Fi ve Bluetooth entegre
- Düşük güç tüketimi (deep sleep: 10 µA)
- Geniş sıcaklık aralığı (-40°C ile +85°C)
- Yeterli GPIO pini
- Fiyat/performans dengesi mükemmel
Alternatif: Arduino Nano
- Daha basit projeler için
- Kablosuz bağlantı yoktur
- Harici modül gerektirir
Sensörler
| Sensör | Amaç | Derinlik/Konum | Kritiklik |
|--------|------|----------------|-----------|
| DS18B20 | Toprak sıcaklığı | 3-5 cm | Zorunlu |
| Kapasitif Nem Sensörü | Toprak nemi | 3-5 cm | Zorunlu |
| DHT22 | Hava sıcaklığı/nem | 1.5 m | Opsiyonel |
| BMP280 | Basınç | 1.5 m | Opsiyonel |
Önemli Not: pH, EC, NPK sensörleri bu zararlı için gereksizdir.
Güç Yönetimi
Pil Sistemi:
- 18650 Li-ion pil (3.7V, 2600-3400 mAh)
- 2-3 adet seri/paralel bağlantı
- TP4056 şarj modülü
- Mini güneş paneli (5-6W) - opsiyonel ama önerilen
Enerji Optimizasyonu:
cpp
// Deep sleep modu
esp_sleep_enable_timer_wakeup(3600 * 1000000); // 1 saat
esp_deep_sleep_start();
Saatlik ölçümle bir şarj 2-3 hafta yeterlidir.
Veri Depolama ve İletişim
Seçenek 1: SD Kart Modülü
- Offline çalışma
- Düşük maliyet
- Manuel veri toplama
Seçenek 2: Wi-Fi
- Gerçek zamanlı veri
- Uzaktan izleme
- Altyapı gerektirir
Seçenek 3: LoRa
- Uzun menzil (2-10 km)
- Düşük enerji
- Gateway maliyeti
Sensör Yerleşimi ve Kurulum
Optimal Yerleşim Stratejisi
İki Nokta Kurulumu (Önerilen): - Tarla Kenarı Sensörü
- Tarlaya giriş noktasından 2-5 m içeride
- Buğday sırası arasına
- Doğrudan güneş görmeyecek şekilde - Tarla Merkez Sensörü
- Tarlanın ortasında
- Benzer koşullarda
Bu yerleşim, zararlının kenar yoğunluğunu sayısal olarak yakalar.
Kurulum Detayları
Sensör Derinliği:
- Toprak sıcaklık sensörü: 3-5 cm (zararlının aktif olduğu zon)
- Nem sensörü: 3-5 cm
- PVC boru ile koruma
Montaj Kutusu:
- IP65 su geçirmez kutu
- Havalandırma delikleri (DHT22 için)
- Güneş paneli üst yüzeye
Koruma Önlemleri:
- Tarım makinelerinden uzak
- Hayvan erişimine kapalı
- Kabloların toprak altında korunması
ESP32 Yazılım Implementasyonu
Temel Veri Toplama Kodu
cpp
#include
#include
#include
#include
#include
// Pin tanımlamaları
#define ONE_WIRE_BUS 4
#define SOIL_MOISTURE_PIN 34
#define SD_CS_PIN 5
// Sensör nesneleri
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
// Değişkenler
float soilTemp = 0;
int soilMoisture = 0;
unsigned long lastMeasurement = 0;
const unsigned long MEASUREMENT_INTERVAL = 3600000; // 1 saat
void setup() {
Serial.begin(115200);
// Sensör başlatma
sensors.begin();
// SD kart başlatma
if (!SD.begin(SD_CS_PIN)) {
Serial.println("SD kart hatası!");
return;
}
Serial.println("Sistem başlatıldı");
}
void loop() {
unsigned long currentTime = millis();
if (currentTime - lastMeasurement >= MEASUREMENT_INTERVAL) {
// Sensör okuma
sensors.requestTemperatures();
soilTemp = sensors.getTempCByIndex(0);
soilMoisture = analogRead(SOIL_MOISTURE_PIN);
// Nem kalibrasyonu (0-100% arası)
int moisturePercent = map(soilMoisture, 0, 4095, 0, 100);
// Veri kaydetme
saveToSD(soilTemp, moisturePercent);
// Konsola yazdırma
Serial.print("Toprak Sıcaklığı: ");
Serial.print(soilTemp);
Serial.print("°C | Nem: ");
Serial.print(moisturePercent);
Serial.println("%");
lastMeasurement = currentTime;
// Enerji tasarrufu için deep sleep
goToSleep();
}
}
void saveToSD(float temp, int moisture) {
File dataFile = SD.open("/veri.csv", FILE_APPEND);
if (dataFile) {
// Zaman damgası (RTC gerektirir, basitleştirilmiş versiyon)
dataFile.print(millis());
dataFile.print(",");
dataFile.print(temp);
dataFile.print(",");
dataFile.println(moisture);
dataFile.close();
} else {
Serial.println("Dosya açma hatası!");
}
}
void goToSleep() {
Serial.println("Deep sleep moduna geçiliyor...");
esp_sleep_enable_timer_wakeup(MEASUREMENT_INTERVAL * 1000);
esp_deep_sleep_start();
}
Wi-Fi ile Veri Gönderimi
cpp
#include
const char* ssid = "TarlaWiFi";
const char* password = "sifresi";
const char* serverURL = "http://sunucu.com/api/veri";
void setup() {
Serial.begin(115200);
sensors.begin();
// Wi-Fi bağlantısı
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWi-Fi bağlandı");
}
void sendDataToServer(float temp, int moisture) {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
http.begin(serverURL);
http.addHeader("Content-Type", "application/json");
// JSON veri hazırlama
String jsonData = "{";
jsonData += "\"tarla_id\":\"A1\",";
jsonData += "\"toprak_sic\":" + String(temp) + ",";
jsonData += "\"nem\":" + String(moisture) + ",";
jsonData += "\"timestamp\":" + String(millis());
jsonData += "}";
int httpResponseCode = http.POST(jsonData);
if (httpResponseCode > 0) {
Serial.print("Veri gönderildi: ");
Serial.println(httpResponseCode);
} else {
Serial.print("Hata: ");
Serial.println(httpResponseCode);
}
http.end();
}
}
Veri İşleme ve Analiz
Ham Veriden Anlamlı Bilgi Üretme
python
import pandas as pd
import numpy as np
def process_sensor_data(csv_file):
Veri okuma
df = pd.read_csv(csv_file, names=['timestamp', 'toprak_sic', 'nem'])
Zaman damgasını datetime'a çevirme
df['tarih'] = pd.to_datetime(df['timestamp'], unit='ms')
Günlük istatistikler
daily_stats = df.groupby(df['tarih'].dt.date).agg({
'toprak_sic': ['mean', 'min', 'max'],
'nem': ['mean']
}).reset_index()
Sıcaklık trendi (3 günlük hareketli ortalama)
df['sic_trend'] = df['toprak_sic'].rolling(window=72).mean() # 3 gün * 24 saat
return df, daily_stats
Toprak GDD hesaplama
def calculate_soil_gdd(df, base_temp=5):
"""
Toprak sıcaklığı bazlı GDD hesaplama
Base temp: 5°C (zararlı için biyolojik eşik)
"""
df['daily_date'] = df['tarih'].dt.date
daily_temps = df.groupby('daily_date')['toprak_sic'].agg(['max', 'min'])
daily_temps['gdd'] = ((daily_temps['max'] + daily_temps['min']) / 2 - base_temp).clip(lower=0)
daily_temps['cumulative_gdd'] = daily_temps['gdd'].cumsum()
return daily_temps
Erken Uyarı Kuralları
python
def early_warning_system(sensor_df):
"""
Mikrodenetleyici verilerinden erken uyarı sinyali üretme
"""
latest_data = sensor_df.tail(72) # Son 3 gün
warnings = []
Kural 1: Toprak sıcaklığı eşiği
if latest_data['toprak_sic'].mean() >= 8.5:
warnings.append("Toprak sıcaklığı ergin çıkış eşiğinin üzerinde")
Kural 2: Sıcaklık artış trendi
temp_trend = latest_data['toprak_sic'].diff().mean()
if temp_trend > 0.3: # Günde 0.3°C artış
warnings.append("Sürekli sıcaklık artış trendi var")
Kural 3: Nem durumu
if 40 <= latest_data['nem'].mean() <= 70:
warnings.append("Toprak nemi zararlı aktivitesi için uygun")
Risk seviyesi belirleme
risk_score = len(warnings)
if risk_score >= 3:
return {"risk": "YÜKSEK", "warnings": warnings}
elif risk_score == 2:
return {"risk": "ORTA", "warnings": warnings}
else:
return {"risk": "DÜŞÜK", "warnings": warnings}
Yapay Zekâ ile Entegrasyon
Sensör Verilerinin Modele Entegrasyonu
python
def integrate_sensor_to_ml_model(sensor_file, model, farm_data):
"""
Mikrodenetleyici verilerini yapay zekâ modeline entegre etme
"""
Sensör verilerini işle
sensor_df, daily_stats = process_sensor_data(sensor_file)
gdd_data = calculate_soil_gdd(sensor_df)
Model için özellik vektörü oluştur
latest_gdd = gdd_data['cumulative_gdd'].iloc[-1]
avg_soil_temp = sensor_df.tail(168)['toprak_sic'].mean() # Son 7 gün
temp_trend = sensor_df.tail(72)['toprak_sic'].diff().mean()
Tarla verilerini birleştir
feature_vector = pd.DataFrame({
'ekim_gunu': [farm_data['ekim_gunu']],
'ort_kis_sic': [farm_data['kis_ortalama']],
'mart_ort_sic': [avg_soil_temp], # Sensör verisi
'gdd': [latest_gdd], # Sensör bazlı GDD
'onceki_yil_zarar': [farm_data['onceki_zarar']],
'toprak_sic_trendi': [temp_trend] # Yeni özellik
})
Tahmin
risk_prob = model.predict_proba(feature_vector)[0][1]
risk_class = "YÜKSEK" if risk_prob > 0.6 else "ORTA" if risk_prob > 0.3 else "DÜŞÜK"
return {
'risk_olasilik': risk_prob,
'risk_sinif': risk_class,
'gdd': latest_gdd,
'ortalama_toprak_sic': avg_soil_temp
}
Gerçek Zamanlı Karar Sistemi
python
class RealTimeDecisionSystem:
def __init__(self, model, sensor_data_path):
self.model = model
self.sensor_data_path = sensor_data_path
self.alert_history = []
def check_and_alert(self, farm_info):
"""
Düzenli kontrol ve uyarı sistemi
"""
Sensör verilerini güncelle
result = integrate_sensor_to_ml_model(
self.sensor_data_path,
self.model,
farm_info
)
Uyarı kaydı
alert = {
'tarih': pd.Timestamp.now(),
'risk_olasilik': result['risk_olasilik'],
'risk_sinif': result['risk_sinif'],
'gdd': result['gdd']
}
self.alert_history.append(alert)
Aksiyon önerisi
if result['risk_sinif'] == "YÜKSEK" and result['gdd'] > 150:
return {
'aciliyet': 'YÜKSEK',
'mesaj': 'ERGİN ÇIKIŞ RİSKİ ÇOK YÜKSEK!',
'aksiyonlar': [
'Tarla kenarlarını günlük kontrol et',
'Ekim yapmayı 2-3 hafta ertele',
'Derin sürüm planla'
]
}
elif result['risk_sinif'] == "ORTA":
return {
'aciliyet': 'ORTA',
'mesaj': 'Dikkatli takip gerekli',
'aksiyonlar': [
'Tarla kenarlarını haftalık kontrol et',
'Ekim tarihini gözden geçir'
]
}
else:
return {
'aciliyet': 'DÜŞÜK',
'mesaj': 'Standart uygulama',
'aksiyonlar': ['Rutin kontroller yeterli']
}
Kenar-Merkez Karşılaştırma Analizi
python
def edge_center_analysis(edge_file, center_file):
"""
Tarla kenarı ve merkez sensör verilerini karşılaştırma
Buğay karasineği kenar yoğunluğunu sayısallaştırma
"""
edge_df = process_sensor_data(edge_file)[0]
center_df = process_sensor_data(center_file)[0]
Zaman hizalama
edge_df = edge_df.set_index('tarih')
center_df = center_df.set_index('tarih')
comparison = pd.DataFrame({
'kenar_sic': edge_df['toprak_sic'],
'merkez_sic': center_df['toprak_sic'],
'fark': edge_df['toprak_sic'] - center_df['toprak_sic']
})
İstatistikler
stats = {
'ortalama_fark': comparison['fark'].mean(),
'max_fark': comparison['fark'].max(),
'kenar_daha_sicak_gun_sayisi': (comparison['fark'] > 0).sum()
}
Kenar risk faktörü
if stats['ortalama_fark'] > 1.5:
stats['kenar_risk'] = 'YÜKSEK'
stats['yorum'] = 'Kenar bölgesi merkeze göre önemli ölçüde daha sıcak - yüksek zararlı riski'
elif stats['ortalama_fark'] > 0.5:
stats['kenar_risk'] = 'ORTA'
stats['yorum'] = 'Kenar-merkez farkı mevcut - dikkatli takip gerekli'
else:
stats['kenar_risk'] = 'DÜŞÜK'
stats['yorum'] = 'Homojen sıcaklık dağılımı'
return stats, comparison
Entegre Sistem Uygulaması
Çiftçi ve Mühendis İçin Sezonluk Karar Takvimi
| Dönem | Aksiyon | Veri Kaynağı | Sorumlu |
|-------|---------|--------------|---------|
| Eylül | Risk modeli çalıştır, geçmiş yıl verilerini analiz et | Tarihsel kayıtlar, meteoroloji | Mühendis |
| Ekim (Erken) | Ekim tarihi optimizasyonu için model tahmini al | Model + sensör | Mühendis/Çiftçi |
| Ekim (Geç) | Ekim kararı ver, sensörleri kur | Karar destek sistemi | Çiftçi |
| Kasım | Tarla kenarı ilk kontrol, sensör verilerini izle | Sensörler | Çiftçi |
| Aralık-Şubat | Kış verilerini kaydet (GDD takibi) | Sensörler + meteoroloji | Otomatik sistem |
| Mart | GDD eşik takibi, erken uyarı sistemi aktif | Sensörler + model | Mühendis |
| Nisan | Ergin çıkış riski analizi, tarla kontrolleri yoğunlaştır | Sensörler + model + gözlem | Mühendis/Çiftçi |
| Mayıs | Zarar değerlendirmesi, kayıt tutma | Gözlem | Çiftçi |
| Haziran-Ağustos | Hasat sonrası analiz, gelecek sezon planlaması | Tüm veriler | Mühendis |
Operasyonel İş Akışı
python
class BugdayKarasinegiYonetimSistemi:
def __init__(self):
self.model = self.load_ml_model()
self.sensor_manager = SensorDataManager()
self.decision_engine = RealTimeDecisionSystem(self.model, 'sensor_data.csv')
def seasonal_workflow(self, tarla_bilgileri):
"""
Sezonluk entegre iş akışı
"""
workflow = {}
Eylül: Risk Değerlendirme
workflow['eylul'] = self.initial_risk_assessment(tarla_bilgileri)
Ekim: Ekim Tarihi Optimizasyonu
workflow['ekim'] = self.optimize_sowing_date(tarla_bilgileri)
Kasım-Mart: Sürekli İzleme
workflow['izleme'] = self.continuous_monitoring()
Nisan: Kritik Dönem
workflow['nisan'] = self.critical_period_management()
return workflow
def initial_risk_assessment(self, tarla_bilgileri):
"""
İlk risk değerlendirmesi (Eylül)
"""
Geçmiş yıl zarar kaydı
onceki_zarar = tarla_bilgileri.get('onceki_yil_zarar', 0)
Meteorolojik tahmin
kis_tahmini = self.get_winter_forecast()
İlk risk skoru
risk_score = 0
if onceki_zarar == 1:
risk_score += 3
if kis_tahmini['ortalama_sic'] > 3:
risk_score += 2
return {
'risk_skoru': risk_score,
'oneri': 'Yüksek dikkat' if risk_score >= 4 else 'Normal takip'
}
def optimize_sowing_date(self, tarla_bilgileri):
"""
Ekim tarihi optimizasyonu (Ekim)
"""
Model tahminlerini farklı tarihler için çalıştır
dates = range(290, 320, 5) # Julian day: 17 Ekim - 16 Kasım
predictions = []
for ekim_gunu in dates:
tarla_bilgileri_copy = tarla_bilgileri.copy()
tarla_bilgileri_copy['ekim_gunu'] = ekim_gunu
risk_prob = self.model.predict_proba(
self.prepare_features(tarla_bilgileri_copy)
)[0][1]
predictions.append({
'ekim_gunu': ekim_gunu,
'tarih': self.julian_to_date(ekim_gunu),
'risk_olasilik': risk_prob
})
En düşük riskli tarihi bul
optimal = min(predictions, key=lambda x: x['risk_olasilik'])
return {
'optimal_tarih': optimal['tarih'],
'risk_olasilik': optimal['risk_olasilik'],
'tum_tahminler': predictions
}
def continuous_monitoring(self):
"""
Sürekli izleme sistemi (Kasım-Mart)
"""
sensor_data = self.sensor_manager.get_latest_data()
gdd = calculate_soil_gdd(sensor_data)
alerts = []
GDD eşik kontrolü
if gdd['cumulative_gdd'].iloc[-1] > 100:
alerts.append({
'tip': 'GDD_ESIK',
'mesaj': 'GDD 100 eşiğini aştı, ergin çıkışa dikkat'
})
Sıcaklık trendi kontrolü
temp_trend = sensor_data.tail(72)['toprak_sic'].diff().mean()
if temp_trend > 0.5:
alerts.append({
'tip': 'SICAKLIK_ARTIS',
'mesaj': 'Hızlı sıcaklık artışı tespit edildi'
})
return {
'gdd_toplam': gdd['cumulative_gdd'].iloc[-1],
'uyarilar': alerts,
'sonraki_kontrol': 'Haftalık takip devam'
}
def critical_period_management(self):
"""
Kritik dönem yönetimi (Nisan)
"""
farm_data = {
'ekim_gunu': 305,
'kis_ortalama': 4.5,
'onceki_zarar': 1
}
decision = self.decision_engine.check_and_alert(farm_data)
Kenar-merkez analizi
edge_center_stats, _ = edge_center_analysis(
'edge_sensor.csv',
'center_sensor.csv'
)
return {
'risk_karari': decision,
'kenar_analizi': edge_center_stats,
'oneri': self.generate_action_plan(decision, edge_center_stats)
}
def generate_action_plan(self, decision, edge_analysis):
"""
Detaylı aksiyon planı oluşturma
"""
plan = {
'aciliyet': decision['aciliyet'],
'aksiyonlar': decision['aksiyonlar'],
'kenar_ozel_onlemler': []
}
if edge_analysis['kenar_risk'] == 'YÜKSEK':
plan['kenar_ozel_onlemler'] = [
'Kenar bölgelerinde günlük gözlem yap',
'İlk 20 metre şeridi özel olarak izle',
'Kenar bölge için alternatif ekim düşün'
]
return plan
Kullanıcı Arayüzü ve Raporlama
python
def generate_weekly_report(sistem, tarla_id):
"""
Haftalık izleme raporu oluşturma
"""
report = {
'tarla_id': tarla_id,
'rapor_tarihi': pd.Timestamp.now(),
'sensor_data': {},
'model_prediction': {},
'recommendations': []
}
Sensör özeti
sensor_df = process_sensor_data('sensor_data.csv')[0]
report['sensor_data'] = {
'ortalama_toprak_sic': sensor_df.tail(168)['toprak_sic'].mean(),
'min_toprak_sic': sensor_df.tail(168)['toprak_sic'].min(),
'max_toprak_sic': sensor_df.tail(168)['toprak_sic'].max(),
'ortalama_nem': sensor_df.tail(168)['nem'].mean()
}
GDD durumu
gdd_data = calculate_soil_gdd(sensor_df)
report['gdd_toplam'] = gdd_data['cumulative_gdd'].iloc[-1]
report['gdd_son_hafta'] = gdd_data['gdd'].tail(7).sum()
Model tahmini
farm_data = {'ekim_gunu': 305, 'kis_ortalama': 4.5, 'onceki_zarar': 1}
prediction = sistem.decision_engine.check_and_alert(farm_data)
report['model_prediction'] = prediction
Görselleştirme
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
Sıcaklık trendi
axes[0, 0].plot(sensor_df.tail(336)['tarih'],
sensor_df.tail(336)['toprak_sic'])
axes[0, 0].axhline(y=8.5, color='r', linestyle='--', label='Kritik eşik')
axes[0, 0].set_title('Son 2 Hafta Toprak Sıcaklığı')
axes[0, 0].set_ylabel('Sıcaklık (°C)')
axes[0, 0].legend()
GDD birikimi
axes[0, 1].plot(gdd_data.index, gdd_data['cumulative_gdd'])
axes[0, 1].axhline(y=150, color='r', linestyle='--', label='Ergin çıkış eşiği')
axes[0, 1].set_title('GDD Birikimi')
axes[0, 1].set_ylabel('Kümülatif GDD')
axes[0, 1].legend()
Nem durumu
axes[1, 0].plot(sensor_df.tail(336)['tarih'],
sensor_df.tail(336)['nem'])
axes[1, 0].set_title('Toprak Nemi')
axes[1, 0].set_ylabel('Nem (%)')
Risk olasılığı
risk_history = pd.DataFrame(sistem.decision_engine.alert_history)
axes[1, 1].plot(risk_history['tarih'], risk_history['risk_olasilik'])
axes[1, 1].axhline(y=0.6, color='r', linestyle='--', label='Yüksek risk')
axes[1, 1].axhline(y=0.3, color='y', linestyle='--', label='Orta risk')
axes[1, 1].set_title('Risk Olasılığı Trendi')
axes[1, 1].set_ylabel('Olasılık')
axes[1, 1].legend()
plt.tight_layout()
plt.savefig(f'haftalik_rapor_{tarla_id}.png', dpi=300)
return report
Sistem Performans Değerlendirmesi ve Validasyon
Model Performans Metrikleri
python
from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score
import seaborn as sns
def comprehensive_model_evaluation(model, X_test, y_test):
"""
Kapsamlı model değerlendirme
"""
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]
Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("=== CONFUSION MATRIX ===")
print(cm)
print("\n=== CLASSIFICATION REPORT ===")
print(classification_report(y_test, y_pred, target_names=['Düşük Risk', 'Yüksek Risk']))
ROC-AUC
auc = roc_auc_score(y_test, y_prob)
print(f"\nROC-AUC Skoru: {auc:.3f}")
Görselleştirme
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.ylabel('Gerçek Değer')
plt.xlabel('Tahmin')
plt.savefig('confusion_matrix.png', dpi=300)
Yanlış sınıflandırmaların analizi
errors = X_test[y_test != y_pred]
print(f"\nYanlış Sınıflandırma Sayısı: {len(errors)}")
print("Yanlış sınıflandırılan örneklerin özellikleri:")
print(errors.describe())
return {
'accuracy': (y_test == y_pred).mean(),
'auc': auc,
'confusion_matrix': cm,
'error_cases': errors
}
Sensör Doğruluğu ve Kalibrasyon
python
def sensor_calibration_protocol():
"""
Sensör kalibrasyon protokolü
"""
protocol = {
'sicaklik_sensoru': {
'yontem': 'Referans termometre ile karşılaştırma',
'siklik': 'Yılda 2 kez (İlkbahar ve Sonbahar)',
'kabul_edilebilir_sapma': '± 0.5°C',
'prosedur': [
'1. Sensörü ve referans termometreyi aynı ortama yerleştir',
'2. 30 dakika bekle (termal denge)',
'3. 10 ölçüm al (5 dakika arayla)',
'4. Ortalama farkı hesapla',
'5. Gerekirse offset ayarı yap'
]
},
'nem_sensoru': {
'yontem': 'Tuz solüsyonu yöntemi',
'siklik': 'Yılda 1 kez',
'referans_noktalar': {
'NaCl doymuş': '%75 RH',
'MgCl2 doymuş': '%33 RH'
},
'kabul_edilebilir_sapma': '± 3%',
'prosedur': [
'1. Kapalı kapta tuz solüsyonu hazırla',
'2. Sensörü kaba yerleştir',
'3. 12 saat bekle',
'4. Ölçüm al ve referansla karşılaştır',
'5. Kalibrasyon katsayısını güncelle'
]
}
}
return protocol
Sensör drift analizi
def analyze_sensor_drift(historical_data, reference_data):
"""
Sensör sapma (drift) analizi
"""
Zaman serisi oluştur
sensor_df = pd.DataFrame({
'tarih': historical_data['tarih'],
'sensor_okuma': historical_data['toprak_sic'],
'referans_okuma': reference_data['toprak_sic']
})
sensor_df['fark'] = sensor_df['sensor_okuma'] - sensor_df['referans_okuma']
Trend analizi
from scipy import stats
slope, intercept, r_value, p_value, std_err = stats.linregress(
range(len(sensor_df)), sensor_df['fark']
)
drift_analysis = {
'ortalama_sapma': sensor_df['fark'].mean(),
'maksimum_sapma': sensor_df['fark'].max(),
'drift_trendi': slope,
'kalibrasyon_gerekli': abs(sensor_df['fark'].mean()) > 0.5
}
if drift_analysis['kalibrasyon_gerekli']:
print(" UYARI: Sensör kalibrasyonu gerekli!")
return drift_analysis
Sistem Güvenilirliği ve Hata Yönetimi
python
class SystemReliabilityMonitor:
def __init__(self):
self.error_log = []
self.uptime_tracker = []
def log_system_status(self):
"""
Sistem durumu günlüğü
"""
status = {
'timestamp': pd.Timestamp.now(),
'sensor_status': self.check_sensor_health(),
'data_quality': self.check_data_quality(),
'model_status': self.check_model_performance(),
'communication': self.check_communication()
}
self.uptime_tracker.append(status)
return status
def check_sensor_health(self):
"""
Sensör sağlık kontrolü
"""
try:
latest_data = pd.read_csv('sensor_data.csv').tail(1)
Son veri ne kadar eski?
last_timestamp = pd.to_datetime(latest_data['timestamp'].iloc[0], unit='ms')
age = (pd.Timestamp.now() - last_timestamp).total_seconds() / 3600
if age > 2: # 2 saatten eski
return {'status': 'HATA', 'mesaj': 'Sensör veri göndermemiş'}
Değer aralığı kontrolü
temp = latest_data['toprak_sic'].iloc[0]
if temp < -10 or temp > 50:
return {'status': 'UYARI', 'mesaj': 'Anormal sıcaklık değeri'}
return {'status': 'NORMAL', 'mesaj': 'Sensör çalışıyor'}
except Exception as e:
self.error_log.append({'type': 'sensor_read_error', 'error': str(e)})
return {'status': 'HATA', 'mesaj': str(e)}
def check_data_quality(self):
"""
Veri kalitesi kontrolü
"""
try:
df = pd.read_csv('sensor_data.csv').tail(72) # Son 3 gün
quality_metrics = {
'eksik_veri_orani': df.isnull().sum().sum() / len(df),
'anormal_degisim': (df['toprak_sic'].diff().abs() > 5).sum(),
'tekrar_eden_deger': df.duplicated().sum()
}
if quality_metrics['eksik_veri_orani'] > 0.1:
return {'status': 'UYARI', 'metrik': quality_metrics}
return {'status': 'NORMAL', 'metrik': quality_metrics}
except Exception as e:
return {'status': 'HATA', 'mesaj': str(e)}
def generate_reliability_report(self):
"""
Güvenilirlik raporu oluştur
"""
if not self.uptime_tracker:
return "Henüz yeterli veri yok"
df = pd.DataFrame(self.uptime_tracker)
report = {
'toplam_kontrol': len(df),
'basarili_okuma': (df['sensor_status'].apply(lambda x: x['status']) == 'NORMAL').sum(),
'uptime_yuzdesi': (df['sensor_status'].apply(lambda x: x['status']) == 'NORMAL').sum() / len(df) * 100,
'toplam_hata': len(self.error_log),
'hata_tipleri': pd.Series([e['type'] for e in self.error_log]).value_counts().to_dict()
}
return report
Gelecek Geliştirmeler ve Araştırma Yönleri
İleri Düzey Özellikler
Derin Öğrenme Modelleri
python
import tensorflow as tf
from tensorflow import keras
def build_lstm_model(input_shape):
"""
Zaman serisi tahmini için LSTM modeli
Sensör verilerinin zamansal desenlerini öğrenir
"""
model = keras.Sequential([
keras.layers.LSTM(64, return_sequences=True, input_shape=input_shape),
keras.layers.Dropout(0.2),
keras.layers.LSTM(32, return_sequences=False),
keras.layers.Dropout(0.2),
keras.layers.Dense(16, activation='relu'),
keras.layers.Dense(1, activation='sigmoid')
])
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy', tf.keras.metrics.AUC()]
)
return model
Zaman serisi veri hazırlama
def prepare_time_series_data(sensor_df, window_size=168):
"""
Son 7 günlük (168 saat) veriyi kullanarak tahmin
"""
X, y = [], []
for i in range(window_size, len(sensor_df)):
X.append(sensor_df.iloc[i-window_size:i'toprak_sic', 'nem']].values)
y.append(sensor_df.iloc[i]['risk'])
return np.array(X), np.array(y)
Uydu Görüntü Entegrasyonu
python
def integrate_sentinel_data(tarla_koordinatlari, tarih_araligi):
"""
Sentinel-2 uydu görüntülerinden NDVI ve NDRE hesaplama
"""
Pseudo-kod (gerçek implementasyon için Sentinel API gerekir)
ndvi_timeseries = []
ndre_timeseries = []
Her görüntü için
for tarih in tarih_araligi:
Sentinel-2 bandları al
red = get_sentinel_band(tarla_koordinatlari, tarih, band='B4')
nir = get_sentinel_band(tarla_koordinatlari, tarih, band='B8')
red_edge = get_sentinel_band(tarla_koordinatlari, tarih, band='B5')
NDVI hesapla
ndvi = (nir - red) / (nir + red)
ndvi_timeseries.append({'tarih': tarih, 'ndvi': ndvi.mean()})
NDRE hesapla
ndre = (nir - red_edge) / (nir + red_edge)
ndre_timeseries.append({'tarih': tarih, 'ndre': ndre.mean()})
Erken stres tespiti
ndvi_df = pd.DataFrame(ndvi_timeseries)
ndvi_df['ndvi_degisim'] = ndvi_df['ndvi'].diff()
Ani düşüş = potansiyel zararlı zararı
stress_detected = (ndvi_df['ndvi_degisim'] < -0.05).any()
return {
'ndvi_serisi': ndvi_timeseries,
'ndre_serisi': ndre_timeseries,
'stres_tespit': stress_detected
}
Mobil Uygulama Entegrasyonu
python
Backend API (Flask örneği)
from flask import Flask, jsonify, request
app = Flask(__name__)
@app.route('/api/risk-sorgula', methods=['POST'])
def risk_sorgula():
"""
Mobil uygulamadan risk sorgusu
"""
data = request.json
tarla_id = data['tarla_id']
Güncel sensör verilerini al
sensor_data = get_latest_sensor_data(tarla_id)
Model tahmini
risk_prediction = model.predict_proba(sensor_data)[0][1]
Aksiyon önerileri
actions = generate_action_plan(risk_prediction)
return jsonify({
'tarla_id': tarla_id,
'risk_olasilik': float(risk_prediction),
'risk_seviye': 'YÜKSEK' if risk_prediction > 0.6 else 'ORTA' if risk_prediction > 0.3 else 'DÜŞÜK',
'aksiyonlar': actions,
'son_guncelleme': pd.Timestamp.now().isoformat()
})
@app.route('/api/sensor-durum', methods=['GET'])
def sensor_durum():
"""
Sensör sağlık durumu
"""
tarla_id = request.args.get('tarla_id')
health_status = check_sensor_health(tarla_id)
return jsonify(health_status)
@app.route('/api/haftalik-rapor', methods=['GET'])
def haftalik_rapor():
"""
Haftalık özet rapor
"""
tarla_id = request.args.get('tarla_id')
report = generate_weekly_report(sistem, tarla_id)
return jsonify(report)
Araştırma ve Geliştirme Alanları
Popülasyon Genetiği Çalışmaları
Farklı bölgelerdeki P. securis popülasyonlarının genetik çeşitliliğinin ve adaptasyon potansiyelinin belirlenmesi, uzun vadeli risk yönetimi için kritik öneme sahiptir.
Önerilen Çalışmalar:
- Mitokondriyal DNA (mtDNA) analizi
- Mikrosatelit belirteç geliştirme
- Bölgelerarası gen akışı analizi
- Pestisit direnci genetik taraması
İklim Değişikliği Senaryoları
python
def climate_change_impact_model(baseline_data, climate_scenario):
"""
İklim değişikliği senaryolarında zararlı risk projeksiyonu
"""
scenarios = {
'RCP2.6': {'temp_increase': 1.5, 'winter_shortening': 5}, # Hafif
'RCP4.5': {'temp_increase': 2.5, 'winter_shortening': 10}, # Orta
'RCP8.5': {'temp_increase': 4.0, 'winter_shortening': 15} # Şiddetli
}
scenario_params = scenarios[climate_scenario]
Gelecek projeksiyonu
future_risk = []
for year in range(2025, 2051):
adjusted_temp = baseline_data['kis_ortalama'] + (
scenario_params['temp_increase'] * (year - 2025) / 25
)
Daha ılık kışlar = daha fazla pupa hayatta kalır
survival_rate = 0.7 + (adjusted_temp / 10) * 0.2
Erken ilkbahar = daha uzun aktivite dönemi
activity_extension = scenario_params['winter_shortening']
Risk artışı
risk_multiplier = survival_rate * (1 + activity_extension / 100)
future_risk.append({
'yil': year,
'risk_carpani': risk_multiplier,
'ortalama_kis_sic': adjusted_temp
})
return pd.DataFrame(future_risk)
Görselleştirme
def plot_climate_scenarios():
baseline = {'kis_ortalama': 3.5}
plt.figure(figsize=(12, 6))
for scenario in ['RCP2.6', 'RCP4.5', 'RCP8.5']:
projection = climate_change_impact_model(baseline, scenario)
plt.plot(projection['yil'], projection['risk_carpani'],
label=scenario, linewidth=2)
plt.axhline(y=1.0, color='k', linestyle='--', label='Mevcut risk')
plt.xlabel('Yıl')
plt.ylabel('Risk Çarpanı')
plt.title('İklim Değişikliği Senaryolarında Buğday Karasineği Risk Projeksiyonu')
plt.legend()
plt.grid(True, alpha=0.3)
plt.savefig('climate_scenarios.png', dpi=300)
Biyolojik Kontrol Ajanlarının Keşfi
python
def biocontrol_screening_protocol():
"""
Biyolojik kontrol ajanları tarama protokolü
"""
protocol = {
'hedef_gruplar': [
'Entomopatojen nematodlar (Steinernema, Heterorhabditis)',
'Yerel Braconidae parazitoitleri',
'Toprak fungiları (Metarhizium, Beauveria yerel izolatları)'
],
'tarama_asamalari': [
{
'asama': 'Laboratuvar Taraması',
'yontem': 'In vitro virülans testleri',
'basari_kriteri': '>60% mortalite (48 saat)'
},
{
'asama': 'Sera Denemeleri',
'yontem': 'Saksı denemelerinde etkililik',
'basari_kriteri': '>50% zarar azaltımı'
},
{
'asama': 'Küçük Ölçekli Tarla Denemeleri',
'yontem': 'Parseller arası karşılaştırma',
'basari_kriteri': '>40% ekonomik etki'
},
{
'asama': 'Çok Lokasyonlu Validasyon',
'yontem': 'Farklı bölgelerde tekrar',
'basari_kriteri': 'Tutarlı performans'
}
],
'veri_toplama': [
'Mortalite oranları',
'Parazitizasyon yüzdesi',
'Zarar azaltım düzeyi',
'Çevresel etki değerlendirmesi',
'Maliyet-etkinlik analizi'
]
}
return protocol
Entegre Zararlı Yönetimi (IPM) Çerçevesi
class IntegratedPestManagementSystem:
"""
Buğday karasineği için kapsamlı IPM yaklaşımı
"""
def __init__(self):
self.monitoring_system = RealTimeDecisionSystem()
self.cultural_practices = CulturalPracticeOptimizer()
self.economic_threshold = 0.05 # %5 zarar eşiği
def ipm_decision_tree(self, current_situation):
"""
IPM karar ağacı
"""
decision_path = []
Seviye 1: Önleme (En düşük maliyet, en yüksek öncelik)
prevention = self.evaluate_prevention(current_situation)
decision_path.append(('Önleme', prevention))
if prevention['risk_level'] == 'DÜŞÜK':
return {'karar': 'Standart uygulama', 'yol': decision_path}
Seviye 2: Kültürel Kontrol
cultural = self.evaluate_cultural_controls(current_situation)
decision_path.append(('Kültürel', cultural))
if cultural['effectiveness'] >= 0.7:
return {'karar': 'Kültürel önlemler yeterli', 'yol': decision_path}
Seviye 3: Biyolojik Kontrol (eğer mevcutsa)
biological = self.evaluate_biological_controls(current_situation)
decision_path.append(('Biyolojik', biological))
if biological['available'] and biological['effectiveness'] >= 0.5:
return {'karar': 'Biyolojik ajan uygula', 'yol': decision_path}
Seviye 4: Ekonomik Eşik Değerlendirmesi
economic_assessment = self.assess_economic_threshold(current_situation)
decision_path.append(('Ekonomik Eşik', economic_assessment))
if economic_assessment['expected_loss'] < self.economic_threshold:
return {'karar': 'Zarar kabul edilebilir seviyede', 'yol': decision_path}
Seviye 5: Kimyasal Kontrol (son çare)
chemical = self.evaluate_chemical_options(current_situation)
decision_path.append(('Kimyasal', chemical))
if chemical['feasible']:
return {'karar': 'Kimyasal müdahale değerlendir', 'yol': decision_path}
else:
return {'karar': 'Ürün değişikliği düşün', 'yol': decision_path}
def evaluate_prevention(self, situation):
"""
Önleyici tedbirlerin değerlendirilmesi
"""
risk_factors = []
if situation['ekim_tarihi'] < 300: # Erken ekim
risk_factors.append('Erken ekim riski')
if situation['onceki_yil_zarar'] == 1:
risk_factors.append('Geçmiş yıl zarar kaydı')
if situation['toprak_isleme'] < 20: # cm
risk_factors.append('Yetersiz toprak işleme')
risk_level = 'YÜKSEK' if len(risk_factors) >= 2 else 'ORTA' if len(risk_factors) == 1 else 'DÜŞÜK'
return {
'risk_level': risk_level,
'risk_factors': risk_factors,
'recommendations': self.generate_prevention_recommendations(risk_factors)
}
def generate_prevention_recommendations(self, risk_factors):
"""
Risk faktörlerine göre önleyici öneri oluşturma
"""
recommendations = []
if 'Erken ekim riski' in risk_factors:
recommendations.append('Ekim tarihini 10-15 gün geciktir')
if 'Geçmiş yıl zarar kaydı' in risk_factors:
recommendations.append('Ekim nöbeti uygula (tahıl dışı ürün)')
recommendations.append('Makarnalık buğday tercih et')
if 'Yetersiz toprak işleme' in risk_factors:
recommendations.append('Minimum 25 cm derin sürüm yap')
recommendations.append('Anızları mekanik olarak yok et')
recommendations.append('Tarla kenarlarında yabani graminer kontrolü yap')
return recommendations
