🧩 MCP ve .NET ile İlk İletişim: Derin Dalış – Bölüm 3

Merhaba teknoloji meraklıları! .NET dünyasıyla gömülü sistemlerin kalbine inmeye devam ettiğimiz “Minha Primeira Comunicação com MCP e .NET” serisinin üçüncü ve en heyecanlı bölümüne hoş geldiniz. Bu bölümde, mikrodenetleyicilerle daha derin ve çeşitli iletişim yöntemlerini keşfedecek, gerçek dünya senaryolarında bu yetenekleri nasıl kullanabileceğimizi adım adım inceleyeceğiz. Eğer ilk iki bölümü kaçırdıysanız endişelenmeyin; bu makale, konuya yeni başlayanlar için temel kavramları özetleyerek sizi hızla güncelleyecek ve daha önce deneyimlemiş olanlar için de ileri düzey ipuçları sunacak. Hadi, .NET’in gücünü kullanarak donanım kontrolünde yeni ufuklara yelken açalım!

Gömülü Sistemlerde .NET’in Yükselişi ve Temel İletişim Protokolleri Nelerdir?

Günümüz akıllı cihazları ve Endüstriyel IoT (IIoT) uygulamaları sayesinde, yazılım ile donanım arasındaki köprü her zamankinden daha önemli hale geldi. .NET ekosistemi, özellikle .NET Core ve güncel .NET sürümleriyle, bu alanda kendine sağlam bir yer edinmiş durumda. Artık sadece masaüstü veya web uygulamaları geliştirmekle kalmıyor, aynı zamanda düşük güçlü cihazlar, sensör ağları ve mikrodenetleyici tabanlı sistemlerle de doğrudan etkileşim kurabiliyoruz. Bu durum, özellikle Raspberry Pi gibi popüler tek kart bilgisayarlar ve Windows IoT Core platformu ile birleştiğinde, C# geliştiricilerine donanım kontrolü konusunda muazzam bir esneklik sunuyor. Peki, bu denli geniş bir yelpazede iletişim kurarken hangi temel protokollere ihtiyaç duyarız?

Mikrodenetleyiciler ve çevresel birimler (sensörler, ekranlar, diğer çipler) arasında veri alışverişi yapmak için çeşitli iletişim protokolleri kullanılır. Her bir protokolün kendine özgü avantajları, dezavantajları ve kullanım alanları bulunur. Serinin önceki bölümlerinde belki de en temel iletişim biçimi olan seri port (UART) iletişimine değinmiş olabiliriz. Ancak gömülü sistemler dünyası, veri aktarım hızı, bağlantı karmaşıklığı ve cihaz adedi gibi faktörlere göre UART’tan çok daha fazlasını sunar. Bu bölümde, özellikle I2C (Inter-Integrated Circuit), SPI (Serial Peripheral Interface) ve GPIO (General Purpose Input/Output) gibi yaygın ve güçlü protokollere odaklanacağız. Bu protokoller, modern gömülü projelerin temel taşlarıdır ve .NET’in System.Device.Gpio kütüphanesi sayesinde C# dilinde kolayca yönetilebilirler.

I2C, genellikle birden fazla cihazı iki kablo (SDA ve SCL) üzerinden bağlamak için kullanılır ve orta hızda veri aktarımı için idealdir. Sensörlerden veri okumak veya küçük ekranları kontrol etmek gibi senaryolarda sıkça karşımıza çıkar. SPI ise, genellikle I2C’den daha hızlıdır ve dört kablo (MOSI, MISO, SCK, CS) kullanır. Daha yüksek bant genişliği gerektiren SD kartlar veya LCD ekranlar gibi cihazlar için tercih edilir. GPIO pinleri ise, doğrudan dijital sinyallerle çalışarak LED’leri açıp kapatmak, buton girişlerini okumak veya röleleri kontrol etmek gibi basit ama temel görevler için kullanılır. Bu protokollerin her biri, farklı ihtiyaçlara yönelik çözümler sunar ve .NET ile bu protokollere hakim olmak, sizi donanım kontrolünde çok yönlü bir geliştirici yapar. Şimdi bu protokollere daha yakından bakalım.

I2C ve SPI: Gömülü Dünyanın Veri Otoyolları Nasıl Kullanılır?

Gömülü sistem geliştirmenin temel taşlarından ikisi olan I2C ve SPI, mikrodenetleyicilerle çevresel cihazlar arasında etkili ve verimli iletişim kurmayı sağlar. Her iki protokol de seri veri iletişimi prensibine dayanır, yani veriler bir bit dizisi halinde, tek bir hat üzerinden sırayla gönderilir veya alınır. Ancak çalışma şekilleri, hızları ve bağlantı mimarileri açısından önemli farklılıklar gösterirler. Bu bölümde, her iki protokolün de derinlemesine incelenmesiyle birlikte, .NET ortamında bu protokollere nasıl hayat verebileceğimizi adım adım göreceğiz.

I2C (Inter-Integrated Circuit) İletişimi: Detaylar ve Uygulamalar

I2C, Philips (şimdi NXP Semiconductors) tarafından geliştirilmiş, iki telli, senkron seri bir iletişim protokolüdür. Adından da anlaşılacağı gibi, entegre devreler arasında iletişim kurmak için tasarlanmıştır. Bu protokolün en büyük avantajı, birden fazla cihazı sadece iki kablo (SDA – Seri Veri Hattı ve SCL – Seri Saat Hattı) üzerinden bağlayabilmesidir. Her I2C cihazının benzersiz bir adresi vardır, bu sayede master (ana) cihaz, slave (köle) cihazlardan hangisiyle iletişim kuracağını adresleyerek belirler.

I2C iletişimi sırasında master cihaz, önce hedef slave cihazın adresini gönderir ve ardından okuma (read) veya yazma (write) işlemi yapacağını belirtir. Slave cihaz, kendi adresini tanırsa, master ile iletişime geçer. Bu adresleme sistemi sayesinde, tek bir I2C veriyoluna onlarca farklı cihaz bağlanabilir. Hızı genellikle SPI’dan daha yavaş olsa da (standart modda 100 kHz, hızlı modda 400 kHz, yüksek hızlı modda 3.4 MHz), çoğu sensör okuma ve düşük bant genişliği gerektiren uygulamalar için fazlasıyla yeterlidir.

.NET ile I2C entegrasyonu, System.Device.Gpio kütüphanesi sayesinde oldukça kolaydır. Özellikle I2cDevice sınıfı, bir I2C cihazıyla etkileşim kurmak için gerekli tüm metotları sağlar.

Vaka Analizi: Dijital Termometre (TMP102) Okuma

Bir TMP102 dijital sıcaklık sensörü, genellikle I2C protokolü üzerinden veri sağlar. Bu sensör, ortam sıcaklığını yüksek hassasiyetle ölçebilir. Amacımız, Raspberry Pi üzerine kurulu bir .NET uygulamasından bu sensörden sıcaklık verisini okumak.

using System.Device.I2c;
using System.Threading;

public class Tmp102Sensor
{
    private const byte Tmp102Address = 0x48; // TMP102'nin I2C adresi
    private const byte TemperatureRegister = 0x00; // Sıcaklık verisi register adresi
    private I2cDevice _tmp102;

    public Tmp102Sensor(int busId)
    {
        var i2cSettings = new I2cConnectionSettings(busId, Tmp102Address);
        _tmp102 = I2cDevice.Create(i2cSettings);
        System.Console.WriteLine($"TMP102 sensör {busId} numaralı I2C veriyolunda, {Tmp102Address:X2} adresinde başlatıldı.");
    }

    public double ReadTemperature()
    {
        // 16 bitlik sıcaklık verisi okuma
        Span readBuffer = stackalloc byte[2];
        _tmp102.Read(readBuffer);

        // Veriyi big-endian'dan little-endian'a çevir (veya sensörün formatına göre ayarla)
        // TMP102 veriyi big-endian olarak gönderir, ama C# little-endian'da çalışır.
        // Genellikle byte sırasını tersine çevirmemiz gerekir.
        // Ancak System.Device.I2c.I2cDevice.Read() zaten doğru byte sırasını alabilir.
        // Burada manuel olarak çevirelim ki anlaşılsın.
        ushort rawTemp = (ushort)((readBuffer[0] << 8) | readBuffer[1]);

        // TMP102 12-bit çözünürlükte çalışır, en düşük 4 bit boştur.
        // Sensör datasheet'ine göre sağa kaydırma yapmak gerekebilir.
        // Genellikle sıcaklık (C) = (rawTemp >> 4) * 0.0625;
        double temperature = (rawTemp >> 4) * 0.0625; 
        
        System.Console.WriteLine($"Ham sıcaklık: {rawTemp:X4}, Okunan Sıcaklık: {temperature:F2}°C");
        return temperature;
    }

    public void Close()
    {
        _tmp102?.Dispose();
        System.Console.WriteLine("TMP102 sensör bağlantısı kapatıldı.");
    }
}

// Main programda kullanımı:
// var sensor = new Tmp102Sensor(1); // Raspberry Pi'de genellikle I2C Bus 1 kullanılır.
// var temp = sensor.ReadTemperature();
// sensor.Close();

Yukarıdaki kod bloğunda, I2cDevice.Create metodu ile sensörümüz için bir bağlantı nesnesi oluşturuyoruz. Ardından Read metodu ile sensörden 2 baytlık sıcaklık verisini okuyoruz. Okunan ham veriyi, sensörün veri sayfasında belirtilen formüle göre işleyerek Celsius cinsinden sıcaklığı elde ediyoruz. Bu, I2C tabanlı bir sensörle .NET uygulamasında temel bir iletişim örneğidir.

SPI (Serial Peripheral Interface) İletişimi: Hız ve Esneklik

SPI, Motorola tarafından geliştirilmiş, dört telli, senkron seri bir iletişim protokolüdür. I2C'den farklı olarak, SPI genellikle daha yüksek hızlarda veri aktarımı sağlar ve full-duplex (aynı anda hem gönderme hem alma) iletişim yapabilir. Dört ana hattı bulunur:

• MOSI (Master Out Slave In): Master'dan Slave'e veri gönderir.
• MISO (Master In Slave Out): Slave'den Master'a veri gönderir.
• SCK (Serial Clock): İletişimi senkronize eden saat sinyalidir.
• CS (Chip Select) veya SS (Slave Select): Hangi slave cihazın seçildiğini belirtir.

SPI'ın en büyük avantajı, yüksek hız ve basit yapısıdır. Her slave cihaz için ayrı bir CS hattı gerektiğinden, birden fazla slave cihaz bağlandığında pin sayısı artabilir. Ancak bu dezavantaj, özellikle hafıza kartları, LCD ekranlar veya AD/DA dönüştürücüler gibi yüksek bant genişliği veya hızlı tepki süresi gerektiren cihazlar için sunduğu performansla fazlasıyla telafi edilir.

.NET ile SPI entegrasyonu da System.Device.Gpio kütüphanesindeki SpiDevice sınıfı aracılığıyla gerçekleştirilir. Bu sınıf, SPI cihazlarıyla etkileşim için benzer kolaylıklar sunar.

Vaka Analizi: OLED Ekran Kontrolü

SSD1306 çipli küçük bir OLED ekranı, genellikle SPI veya I2C üzerinden kontrol edilebilir. Yüksek çözünürlüklü veya hızlı yenileme gerektiren grafikler için SPI tercih edilir. Burada, basit bir mesajı ekrana yazdıran bir örnek üzerinden SPI kullanımını göstereceğiz. (Not: SSD1306 için tam bir sürücü kodu karmaşık olacağı için, burada temel bir SPI yazma işlemi örneklenecektir.)

using System.Device.Spi;
using System.Threading;

public class OledDisplaySpi
{
    private const byte OledCommand = 0x00; // Ekran komutları için genellikle bir Data/Command pini kullanılır,
                                         // ancak System.Device.Spi doğrudan bunu yönetmez.
                                         // Bu örnekte, sadece SPI veri yazma gösterilecek.
    private SpiDevice _oled;
    private int _dataCommandPin; // Ekstra GPIO pini (DC veya A0)

    public OledDisplaySpi(int busId, int chipSelectLine, int dataCommandPin)
    {
        // SPI ayarları: Mode, ClockFrequency gibi parametreler cihazın datasheet'ine göre ayarlanır.
        var spiSettings = new SpiConnectionSettings(busId, chipSelectLine)
        {
            ClockFrequency = 8_000_000, // 8 MHz
            Mode = SpiMode.Mode0 // Genellikle OLED için Mode0 veya Mode3 kullanılır.
        };
        _oled = SpiDevice.Create(spiSettings);
        _dataCommandPin = dataCommandPin; // Ekranın DC pinini kontrol etmek için GPIO pini

        // DC pinini başlat (çıktı modu, genellikle komut göndermeden önce LOW, veri göndermeden önce HIGH)
        // using System.Device.Gpio; // GPIO kullanımı için gerekli
        // GpioController controller = new GpioController();
        // controller.OpenPin(_dataCommandPin, PinMode.Output);
        // controller.Write(_dataCommandPin, PinValue.Low); // Başlangıçta komut modunda
        System.Console.WriteLine($"OLED ekran {busId} numaralı SPI veriyolunda, CS hattı {chipSelectLine} ile başlatıldı.");
    }

    public void WriteData(byte[] data)
    {
        // Gerçek bir OLED sürücüsünde, bu noktada _dataCommandPin HIGH yapılır.
        // controller.Write(_dataCommandPin, PinValue.High); 
        _oled.Write(data);
        System.Console.WriteLine($"SPI üzerinden {data.Length} bayt veri yazıldı.");
    }

    public void WriteCommand(byte[] command)
    {
        // Gerçek bir OLED sürücüsünde, bu noktada _dataCommandPin LOW yapılır.
        // controller.Write(_dataCommandPin, PinValue.Low);
        _oled.Write(command);
        System.Console.WriteLine($"SPI üzerinden {command.Length} bayt komut yazıldı.");
    }

    public void Close()
    {
        _oled?.Dispose();
        // GpioController.Dispose() if created here.
        System.Console.WriteLine("OLED ekran bağlantısı kapatıldı.");
    }
}

// Main programda kullanımı:
// var oled = new OledDisplaySpi(0, 0, 24); // SPI0, CS0, GPIO24 (örnek)
// // OLED'i başlatmak için çeşitli komutlar gönderilir (boyut, kontrast vb.)
// // oled.WriteCommand(new byte[] { 0xAE }); // Ekranı kapat
// // oled.WriteData(new byte[] { ... }); // Ekran piksel verisi
// oled.Close();

SPI iletişimi, I2C'den farklı olarak genellikle bir Data/Command (DC) pini gibi ek GPIO pinleri gerektirebilir, özellikle grafik ekranlar gibi cihazlarda. Bu pin, gönderilen baytların komut mu yoksa veri mi olduğunu belirtmek için kullanılır. Yukarıdaki örnekte, SpiDevice.Create metodu ile SPI bağlantısını yapılandırıyor ve Write metodu ile doğrudan bayt dizilerini gönderiyoruz. Bu, yüksek performanslı cihazlarla .NET tabanlı etkileşimler için güçlü bir temel oluşturur.

GPIO Yönetimi ve .NET ile Çevresel Bileşen Kontrolü Nasıl Yapılır?

GPIO (General Purpose Input/Output) pinleri, herhangi bir mikrodenetleyicinin veya tek kart bilgisayarın en temel ve vazgeçilmez özelliklerinden biridir. Bu pinler, adından da anlaşılacağı gibi, genel amaçlı giriş ve çıkış işlemleri için kullanılır. Yani, bir pini giriş olarak ayarlayarak dışarıdan gelen bir sinyali (örneğin bir buton basımını) okuyabiliriz; veya bir pini çıkış olarak ayarlayarak dışarıya bir sinyal (örneğin bir LED'i açıp kapatmak için) gönderebiliriz. GPIO pinleri, gömülü sistemlerin çevresel bileşenlerle doğrudan etkileşim kurmasını sağlayan ilk ve en basit yoldur.

Her GPIO pini bir dijital değer taşır: ya "HIGH" (mantıksal 1, genellikle 3.3V veya 5V) ya da "LOW" (mantıksal 0, genellikle 0V). Bu basit ikili durumlar sayesinde, karmaşık kontrol mekanizmaları oluşturabiliriz. Örneğin, bir buton basıldığında pini LOW yapıp, basılmadığında HIGH bırakabiliriz. Ya da bir LED'i yakmak için pini HIGH, söndürmek için LOW yapabiliriz. Ayrıca, bazı GPIO pinleri dahili "pull-up" veya "pull-down" dirençlere sahip olabilir. Pull-up dirençler, pini hiçbir şey bağlı değilken HIGH seviyesinde tutarken, pull-down dirençler LOW seviyesinde tutar. Bu, harici dirençlere olan ihtiyacı azaltarak devre tasarımını basitleştirir.

.NET ortamında GPIO pinlerini yönetmek için yine System.Device.Gpio kütüphanesi içindeki GpioController sınıfını kullanırız. Bu sınıf, pinleri açma, kapatma, okuma, yazma ve hatta olaylara tepki verme gibi tüm temel işlemleri gerçekleştirmemizi sağlar.

Vaka Analizi: Akıllı Işık Kontrolü ve Güvenlik Sistemi Entegrasyonu

Bir Raspberry Pi'ye bağlı bir LED'i bir buton aracılığıyla kontrol edelim ve ayrıca bir PIR (Pasif Kızılötesi) sensörü ile hareket algılamayı entegre ederek basit bir güvenlik sistemi oluşturalım.

using System.Device.Gpio;
using System.Threading;

public class SmartLightingAndSecurity
{
    private const int LedPin = 17;     // GPIO17 (çıkış)
    private const int ButtonPin = 27;  // GPIO27 (giriş)
    private const int PirSensorPin = 22; // GPIO22 (giriş)

    private GpioController _gpioController;
    private Timer _ledOffTimer; // LED'i otomatik kapatmak için

    public SmartLightingAndSecurity()
    {
        _gpioController = new GpioController();

        // LED pinini çıkış olarak ayarla
        _gpioController.OpenPin(LedPin, PinMode.Output);
        _gpioController.Write(LedPin, PinValue.Low); // Başlangıçta LED kapalı
        System.Console.WriteLine($"LED (GPIO{LedPin}) çıkış olarak ayarlandı, kapalı.");

        // Buton pinini giriş olarak ayarla (pull-up direnci ile, buton basılınca LOW sinyal verir)
        _gpioController.OpenPin(ButtonPin, PinMode.InputPullUp);
        _gpioController.RegisterCallbackForPinValueChangedEvent(ButtonPin, PinEventTypes.Falling, OnButtonPress);
        System.Console.WriteLine($"Buton (GPIO{ButtonPin}) giriş olarak ayarlandı, düşen kenar olaylarına abone olundu.");

        // PIR sensör pinini giriş olarak ayarla
        _gpioController.OpenPin(PirSensorPin, PinMode.Input);
        _gpioController.RegisterCallbackForPinValueChangedEvent(PirSensorPin, PinEventTypes.Rising | PinEventTypes.Falling, OnPirDetect);
        System.Console.WriteLine($"PIR Sensör (GPIO{PirSensorPin}) giriş olarak ayarlandı, kenar olaylarına abone olundu.");
    }

    private void OnButtonPress(object sender, PinValueChangedEventArgs e)
    {
        // Buton basıldığında (düşen kenar)
        if (e.ChangeType == PinEventTypes.Falling)
        {
            System.Console.WriteLine("Butona basıldı! LED durumunu değiştiriyorum.");
            ToggleLed();
        }
    }

    private void OnPirDetect(object sender, PinValueChangedEventArgs e)
    {
        if (e.ChangeType == PinEventTypes.Rising) // Hareket algılandı
        {
            System.Console.WriteLine("HAREKET ALGILANDI! LED'i açıyorum.");
            _gpioController.Write(LedPin, PinValue.High);
            // LED'i 5 saniye sonra kapatmak için bir zamanlayıcı başlat
            _ledOffTimer?.Dispose(); // Önceki zamanlayıcıyı iptal et
            _ledOffTimer = new Timer(state => 
            {
                _gpioController.Write(LedPin, PinValue.Low);
                System.Console.WriteLine("Hareket algılaması sonrası LED kapatıldı.");
                _ledOffTimer.Dispose();
                _ledOffTimer = null;
            }, null, TimeSpan.FromSeconds(5), Timeout.InfiniteTimeSpan);
        }
        else if (e.ChangeType == PinEventTypes.Falling) // Hareket sona erdi
        {
            System.Console.WriteLine("Hareket sona erdi.");
        }
    }

    private void ToggleLed()
    {
        PinValue currentValue = _gpioController.Read(LedPin);
        PinValue newValue = (currentValue == PinValue.Low) ? PinValue.High : PinValue.Low;
        _gpioController.Write(LedPin, newValue);
        System.Console.WriteLine($"LED durumu: {(newValue == PinValue.High ? "AÇIK" : "KAPALI")}");
    }

    public void KeepRunning()
    {
        System.Console.WriteLine("Uygulama çalışıyor, olayları bekliyor. Çıkmak için 'q' tuşuna basın.");
        while (System.Console.ReadKey().KeyChar != 'q')
        {
            // Beklemede kal
        }
        System.Console.WriteLine("Uygulama kapatılıyor.");
    }

    public void Close()
    {
        _gpioController.ClosePin(LedPin);
        _gpioController.ClosePin(ButtonPin);
        _gpioController.ClosePin(PirSensorPin);
        _gpioController.Dispose();
        _ledOffTimer?.Dispose();
        System.Console.WriteLine("GPIO bağlantıları kapatıldı.");
    }
}

// Main programda kullanımı:
// var system = new SmartLightingAndSecurity();
// system.KeepRunning();
// system.Close();

Bu kodda, üç farklı GPIO pini kullanıyoruz: bir LED için çıkış, bir buton için giriş ve bir PIR sensörü için giriş. GpioController sınıfı, pinleri açma (OpenPin), modlarını belirleme (PinMode.Output, PinMode.InputPullUp) ve değerlerini okuma/yazma (Read, Write) gibi temel işlemleri yapmamızı sağlar.

En kritik özelliklerden biri, RegisterCallbackForPinValueChangedEvent metodudur. Bu metod sayesinde, fiziksel pin üzerinde bir değer değişikliği (örneğin, butona basıldığında voltaj düşüşü veya PIR sensörden hareket algılandığında voltaj yükselişi) olduğunda otomatik olarak tetiklenecek bir olay işleyici (callback) tanımlayabiliriz. Bu, uygulamanın sürekli pini sorgulamasına gerek kalmadan enerji verimli ve tepkisel çalışmasını sağlar. Buton basıldığında veya hareket algılandığında OnButtonPress ve OnPirDetect metotları çalışır ve LED'in durumunu değiştirir veya bir zamanlayıcı başlatır. Bu yaklaşım, gömülü sistemlerde olay tabanlı programlamanın temelini oluşturur.

Gerçek Dünya Senaryosu: Akıllı Çevre Monitörü Projesi Nasıl Geliştirilir?

Artık I2C, SPI ve GPIO'nun temellerini ve .NET ile nasıl kullanılacaklarını anladığımıza göre, bu bilgileri birleştirerek gerçekçi ve pratik bir proje geliştirelim: Akıllı Çevre Monitörü. Bu proje, bir Raspberry Pi üzerinde çalışacak, I2C üzerinden sıcaklık ve nem verilerini okuyacak, SPI üzerinden bir OLED ekranda bu verileri görselleştirecek ve GPIO kullanarak bir hava kalitesi sensöründen (basit bir MQ serisi sensör gibi) bilgi alacak, belirli bir eşiğin üzerinde kirlilik algılandığında bir uyarı LED'i yakacaktır. Bu senaryo, öğrenilen tüm iletişim yöntemlerini tek bir çatı altında birleştirerek entegre bir çözüm sunar.

Proje Tanımı ve Mimari

Amacımız, yaşam alanımızdaki temel çevre koşullarını sürekli olarak izleyen ve bize bilgi sağlayan bir cihaz oluşturmak. Projemizin ana bileşenleri şunlardır:

• Ana İşlemci: Raspberry Pi (Model 3B+ veya 4 tercih edilir, .NET Core/5/6/7/8 destekli).
• Sıcaklık ve Nem Sensörü: DHT11/DHT22 (GPIO tabanlı, ancak biz bu senaryo için I2C tabanlı bir alternatif olan BME280 kullanacağız).
• Ekran: SSD1306 OLED Ekran (SPI bağlantılı).
• Hava Kalitesi Sensörü: MQ-2 Gaz Sensörü (GPIO üzerinden analog değeri okuyabilmek için ADC gerekir veya sensör modülü dijital çıkış veriyorsa doğrudan GPIO). Basit olması adına, dijital çıkışlı bir sensör kullandığımızı varsayalım.
• Uyarı Göstergesi: Bir LED (GPIO ile kontrol edilecek).

Mimari olarak, .NET uygulamamız Raspberry Pi üzerinde çalışacak ve System.Device.Gpio kütüphanesini kullanarak tüm bu donanım birimleriyle doğrudan iletişim kuracak. Uygulama, düzenli aralıklarla sensörlerden veri okuyacak, bu verileri ekranda gösterecek ve belirli koşullar altında uyarı LED'ini aktive edecektir.

Adım Adım Entegrasyon Süreci

1. Gerekli Kütüphaneler: Projenize System.Device.Gpio ve Iot.Device.Bindings (sensörler için hazır sürücüler içerir) NuGet paketlerini ekleyin.
2. I2C Sensör (BME280) Entegrasyonu:
   • BME280 sensörü I2C veriyoluna bağlayın (SDA, SCL, VCC, GND).
   • .NET uygulamanızda I2cDevice sınıfını kullanarak sensörle iletişim kurun veya Iot.Device.Bindings kütüphanesindeki Bme280 sürücüsünü kullanın.
   • Sensörden sıcaklık, nem ve basınç verilerini düzenli olarak okuyun.
3. SPI Ekran (SSD1306 OLED) Entegrasyonu:
   • OLED ekranı SPI veriyoluna bağlayın (MOSI, MISO, SCK, CS, DC, RST, VCC, GND).
   • SpiDevice sınıfını kullanarak ekranla iletişim kurun. Iot.Device.Bindings içerisinde Ssd1306 sürücüsü de bulunabilir.
   • Okunan çevre verilerini ekranda düzenli olarak güncelleyin. Örneğin, ilk satırda sıcaklık, ikinci satırda nem.
4. GPIO Sensör (MQ-2) ve Uyarı LED'i Entegrasyonu:
   • MQ-2 sensörünün dijital çıkışını (eğer varsa) ve uyarı LED'ini ayrı GPIO pinlerine bağlayın.
   • GpioController sınıfını kullanarak MQ-2 pinini giriş, LED pinini çıkış olarak ayarlayın.
   • MQ-2 pininde bir değişiklik olduğunda (örneğin hava kalitesi eşiğin üzerine çıktığında) RegisterCallbackForPinValueChangedEvent ile bir olay tetikleyin.
   • Olay tetiklendiğinde uyarı LED'ini yakın.
5. Ana Uygulama Döngüsü: Tüm bu bileşenleri bir araya getiren bir ana döngü oluşturun. Bu döngü, belirli aralıklarla sensör verilerini okuyacak, ekrana yazacak ve hava kalitesi durumunu kontrol edecektir.

Örnek Kod Yapısı (Soyutlaştırılmış)

Projenin karmaşıklığı nedeniyle tüm kod bloğunu burada vermek yerine, temel yapısal bileşenleri ve iletişim akışını özetleyen bir pseudo-kod veya soyutlaştırılmış bir örnek sunalım:

using System;
using System.Device.Gpio;
using System.Device.I2c;
using System.Device.Spi;
using System.Threading;
using Iot.Device.Bme280; // Iot.Device.Bindings'den
using Iot.Device.Ssd1306; // Iot.Device.Bindings'den
using SixLabors.ImageSharp.PixelFormats; // Grafik kütüphanesi
using SixLabors.ImageSharp;
using SixLabors.Fonts; // Metin için

public class EnvironmentMonitor
{
    private GpioController _gpioController;
    private Bme280 _bme280; // I2C sensör
    private Ssd1306 _oled; // SPI ekran
    private const int WarningLedPin = 21; // GPIO21
    private const int AirQualitySensorPin = 20; // GPIO20 (dijital çıkışlı)

    public EnvironmentMonitor()
    {
        _gpioController = new GpioController();

        // I2C BME280 Sensör Başlatma
        var i2cSettings = new I2cConnectionSettings(1, Bme280.DefaultI2cAddress);
        var i2cDevice = I2cDevice.Create(i2cSettings);
        _bme280 = new Bme280(i2cDevice);

        // SPI SSD1306 OLED Ekran Başlatma
        // Raspberry Pi'de SPI Bus 0, ChipSelectLine 0
        // DC (Data/Command) ve Reset pinleri GPIO'dan kontrol edilir.
        var spiSettings = new SpiConnectionSettings(0, 0) { Mode = SpiMode.Mode0, ClockFrequency = 8_000_000 };
        var spiDevice = SpiDevice.Create(spiSettings);
        // Varsayımsal GPIO pinleri
        int dcPin = 24; 
        int resetPin = 25; 
        _oled = new Ssd1306(spiDevice, dcPin, resetPin, 128, 64); // 128x64 OLED

        _oled.SendCommand(Ssd1306Command.DisplayOff);
        _oled.SendCommand(Ssd1306Command.SetDisplayClockDivideRatio);
        _oled.SendCommand(0x80);
        _oled.SendCommand(Ssd1306Command.SetMultiplexRatio);
        _oled.SendCommand(0x3F); // 64 line
        // Diğer başlangıç komutları ...
        _oled.SendCommand(Ssd1306Command.DisplayOn);
        _oled.ClearScreen();


        // Hava Kalitesi Sensörü ve LED pinlerini ayarla
        _gpioController.OpenPin(WarningLedPin, PinMode.Output);
        _gpioController.Write(WarningLedPin, PinValue.Low);
        _gpioController.OpenPin(AirQualitySensorPin, PinMode.Input);
        _gpioController.RegisterCallbackForPinValueChangedEvent(AirQualitySensorPin, PinEventTypes.Rising | PinEventTypes.Falling, OnAirQualityChange);

        System.Console.WriteLine("Çevre Monitörü başlatıldı.");
    }

    private void OnAirQualityChange(object sender, PinValueChangedEventArgs e)
    {
        if (e.ChangeType == PinEventTypes.Rising) // Kirli hava algılandı
        {
            _gpioController.Write(WarningLedPin, PinValue.High);
            System.Console.WriteLine("HAVA KİRLİLİĞİ ALGILANDI! Uyarı LED'i AÇIK.");
        }
        else // Temiz hava (veya eşik altına düştü)
        {
            _gpioController.Write(WarningLedPin, PinValue.Low);
            System.Console.WriteLine("Hava kalitesi normale döndü. Uyarı LED'i KAPALI.");
        }
    }

    public void StartMonitoring()
    {
        while (true)
        {
            // Sensörden veri oku
            var readings = _bme280.Read();
            double temperature = readings.Temperature?.DegreesCelsius ?? double.NaN;
            double humidity = readings.Humidity?.Percent ?? double.NaN;

            System.Console.WriteLine($"Sıcaklık: {temperature:F2}°C, Nem: {humidity:F2}%");

            // Ekrana yaz (ImageSharp ve Font kullanarak)
            // Ssd1306 ekran sürücüsüne özel bir görselleştirme yöntemi olmalı.
            // Örnek olarak, bir Image nesnesi oluşturup üzerine yazabiliriz.
            // _oled.ClearScreen();
            // using (var image = new Image(Configuration.Default, 128, 64, Rgba32.Black))
            // {
            //     // Font yükle
            //     // var fontCollection = new FontCollection();
            //     // var fontFamily = fontCollection.Install("path/to/font.ttf");
            //     // var font = fontFamily.CreateFont(12, FontStyle.Regular);

            //     // image.Mutate(x => x.DrawText($"T: {temperature:F1}°C", font, Color.White, new PointF(0, 0)));
            //     // image.Mutate(x => x.DrawText($"H: {humidity:F1}%", font, Color.White, new PointF(0, 20)));

            //     // _oled.Draw(image); // Bu, Ssd1306 sürücüsünün bir metodudur
            // }
            _oled.ClearScreen();
            _oled.WriteText(1, 1, $"T: {temperature:F1}C"); // Varsayımsal WriteText metodu
            _oled.WriteText(1, 30, $"H: {humidity:F1}%");


            Thread.Sleep(5000); // Her 5 saniyede bir güncelle
        }
    }

    public void Close()
    {
        _bme280?.Dispose();
        _oled?.Dispose();
        _gpioController.ClosePin(WarningLedPin);
        _gpioController.ClosePin(AirQualitySensorPin);
        _gpioController?.Dispose();
        System.Console.WriteLine("Çevre Monitörü kapatıldı.");
    }
}

// Main programda kullanımı:
// var monitor = new EnvironmentMonitor();
// monitor.StartMonitoring(); // Bu sonsuz döngüde çalışacaktır, Ctrl+C ile durdurulmalı
// monitor.Close();

Bu soyutlandırılmış kod yapısı, BME280 sensörünü I2C üzerinden, SSD1306 OLED ekranını SPI üzerinden ve bir hava kalitesi sensörü ile uyarı LED'ini GPIO üzerinden nasıl entegre edebileceğimizi gösteriyor. Iot.Device.Bindings kütüphanesi, popüler sensör ve ekranlar için hazır sürücüler sunarak geliştirme sürecini büyük ölçüde basitleştirir. Bu sayede, donanımın düşük seviye register ayarlarıyla uğraşmak yerine, doğrudan değer okuma ve yazma gibi üst seviye işlemlere odaklanabiliriz. Gerçek bir uygulamada, ekran yazıları için SixLabors.ImageSharp gibi bir grafik kütüphanesi kullanılarak daha zengin görselleştirmeler yapılabilir ve bu görselleştirme sonuçları OLED ekrana gönderilir.

Performans, Güvenilirlik ve Mobil Entegrasyon İpuçları Nelerdir?

Gömülü sistemler geliştirirken sadece iletişimi kurmak yeterli değildir; uygulamanın performanslı, güvenilir ve gerektiğinde erişilebilir olması da büyük önem taşır. Bu bölümde, .NET ile geliştirdiğimiz gömülü uygulamaların daha sağlam ve kullanışlı olmasını sağlayacak bazı ileri düzey ipuçlarına ve püf noktalarına değineceğiz.

Gömülü Uygulamalarda Performans Optimizasyonu ve Hata Yönetimi

Gömülü sistemler genellikle kısıtlı kaynaklara (CPU gücü, bellek) sahip olduğundan, performans optimizasyonu kritik bir konudur. Aynı zamanda, donanım kaynaklı veya çevresel faktörlerden kaynaklanan hatalarla başa çıkmak için sağlam bir hata yönetimi stratejisi geliştirmek gerekir.

• Asenkron Programlama (async/await): Donanım ile iletişim genellikle I/O beklemeleri içerir. Örneğin, bir sensörden veri okumak belirli bir süre alabilir. Bu süre zarfında uygulamanın ana iş parçacığının (thread) kilitlenmesini önlemek için async/await yapısını kullanmak, uygulamanın diğer görevleri yerine getirmesine olanak tanır ve genel tepkiselliği artırır.

  
  public async Task ReadTemperatureAsync()
  {
      // Donanım okuma işlemleri genellikle blocking'dir.
      // Ancak kütüphaneler async versiyonlarını sunabilir.
      // Eğer sunmuyorsa, Thread.Task.Run kullanarak blocking çağrıyı arka plana taşıyabiliriz.
      return await Task.Run(() =>
      {
          Span readBuffer = stackalloc byte[2];
          _tmp102.Read(readBuffer); // Bu blocking bir çağrı olabilir
  
          ushort rawTemp = (ushort)((readBuffer[0] << 8) | readBuffer[1]);
          return (rawTemp >> 4) * 0.0625;
      });
  }
          

• Kaynak Yönetimi (IDisposable ve using blokları): Donanım kaynakları (GPIO pinleri, I2C/SPI cihazları) kilitli kaynaklardır ve uygulamanızın kapanması veya bir hata durumunda düzgün bir şekilde serbest bırakılmaları gerekir. IDisposable arayüzünü uygulayan sınıflar için using bloklarını kullanmak, kaynakların otomatik olarak serbest bırakılmasını sağlar ve kaynak sızıntılarını önler.

  
  using (var gpioController = new GpioController())
  {
      gpioController.OpenPin(LedPin, PinMode.Output);
      gpioController.Write(LedPin, PinValue.High);
      // İşlemler...
  } // using bloğu sonunda gpioController.Dispose() çağrılır, pinler kapatılır.
          

• Hata Yakalama Stratejileri (try-catch): Donanım arızaları, yanlış bağlantılar veya geçici iletişim sorunları nedeniyle istisnalar meydana gelebilir. Bu tür durumları try-catch blokları ile yakalayarak uygulamanın çökmesini engelleyebilir ve duruma uygun hata mesajları gösterebilir veya yeniden deneme mekanizmaları kurabiliriz.

  
  try
  {
      double temp = sensor.ReadTemperature();
      System.Console.WriteLine($"Sıcaklık: {temp}°C");
  }
  catch (System.IO.IOException ex) // Donanım kaynaklı hatalar
  {
      System.Console.WriteLine($"I2C/SPI Hatası: {ex.Message}");
      // Hata durumunda yeniden başlatma veya bildirim gönderme
  }
  catch (Exception ex)
  {
      System.Console.WriteLine($"Genel Hata: {ex.Message}");
  }
          

• Gürültü Giderme (Debouncing) for GPIO Inputs: Mekanik butonlar basıldığında kısa süreli birden fazla sinyal gönderebilirler (debounce). Bu, istenmeyen tetiklemelere yol açar. Yazılımsal veya donanımsal debouncing teknikleri kullanarak bu gürültüyü filtrelemek önemlidir. Yazılımsal olarak, bir buton basımını algıladıktan sonra kısa bir süre (örneğin 50-100 ms) bekleyerek diğer sinyalleri ignore edebiliriz.

  
  private DateTime _lastButtonPressTime = DateTime.MinValue;
  private const int DebounceDelayMs = 100;
  
  private void OnButtonPress(object sender, PinValueChangedEventArgs e)
  {
      if (e.ChangeType == PinEventTypes.Falling)
      {
          if ((DateTime.Now - _lastButtonPressTime).TotalMilliseconds > DebounceDelayMs)
          {
              _lastButtonPressTime = DateTime.Now;
              System.Console.WriteLine("Butona basıldı (debounced)!");
              ToggleLed();
          }
      }
  }
          

Gömülü Sistemler için Mobil Uyumluluk ve Uzaktan Erişim

Modern gömülü projeler genellikle sadece yerel olarak çalışmakla kalmaz, aynı zamanda uzaktan izleme ve kontrol imkanları da sunar. Eğer .NET uygulamanızın bir web arayüzü varsa (örneğin Blazor WebAssembly veya ASP.NET Core uygulaması), bu arayüzün mobil cihazlardan da erişilebilir ve kullanılabilir olması gerekir.

    
Çevre Verileri
    

        
Sıcaklık: 24.5°C
        
Nem: 55%
    

Yukarıdaki örnekte, etiketi tarayıcılara sayfanın cihaz genişliğine göre ölçeklenmesi gerektiğini söyler. CSS içindeki @media (max-width: 768px) medya sorgusu ise, ekran genişliği 768 pikselden az olduğunda belirli stil değişikliklerinin uygulanmasını sağlar. Bu sayede, uygulamanızın web arayüzü mobil cihazlarda da okunaklı ve kullanılabilir hale gelir.

Uzaktan erişim ve yönetim, gömülü sistemlerin önemli bir parçasıdır. Raspberry Pi gibi cihazlara SSH üzerinden bağlanarak komut satırından uygulamaları yönetebilir, VNC ile grafik arayüzüne erişebilir veya Azure IoT Hub, AWS IoT Core gibi bulut hizmetlerini kullanarak cihazdan veri toplayabilir ve cihazı uzaktan kontrol edebilirsiniz. .NET Core, bu tür bulut entegrasyonları için zengin kütüphaneler sunar ve gömülü cihazlarınızı bulutla entegre ederek çok daha güçlü ve geniş ölçekli IoT çözümleri geliştirmenize olanak tanır. Örneğin, sensör verilerini Azure IoT Hub'a gönderip Azure Stream Analytics ile analiz edebilir veya Azure Functions ile cihaza uzaktan komutlar gönderebilirsiniz. Bu, cihazınızın sadece yerel bir monitör olmaktan çıkıp, küresel bir IoT ekosisteminin parçası olmasını sağlar.

Sonuç ve Sıkça Sorulan Sorular

"MCP ve .NET ile İlk İletişim" serimizin bu üçüncü bölümünde, mikrodenetleyici dünyasının en yaygın iletişim protokollerinden I2C, SPI ve GPIO'yu .NET'in gücüyle nasıl ele alabileceğimizi detaylıca inceledik. Temel prensiplerden başlayarak, gerçek dünya senaryolarında sensör okuma, ekran kontrolü ve aktüatör yönetimi gibi uygulamaları adım adım ele aldık. Özellikle System.Device.Gpio ve Iot.Device.Bindings kütüphanelerinin, C# geliştiricilerine donanım dünyasına adım atarken sağladığı kolaylığı ve esnekliği vurguladık.

Performans optimizasyonu, sağlam hata yönetimi ve mobil uyumluluk gibi konulara değinerek, geliştirdiğimiz gömülü uygulamaların sadece çalışır durumda değil, aynı zamanda güvenilir, verimli ve modern beklentilere uygun olmasını sağladık. Artık .NET ile mikrodenetleyicilerle iletişim kurma konusunda geniş bir bilgi birikimine sahipsiniz. Bu bilgilerle, akıllı ev otomasyonundan endüstriyel izleme sistemlerine kadar pek çok farklı alanda kendi projelerinizi geliştirebilirsiniz. Unutmayın, donanım dünyası keşfetmeyi bekleyen sonsuz olasılıklar sunuyor ve .NET, bu keşifteki en güçlü müttefiklerinizden biri. Denemekten ve öğrenmekten asla vazgeçmeyin!

Sıkça Sorulan Sorular (SSS)

1. .NET ile gömülü sistem geliştirme için hangi donanımları önerirsiniz?

Başlangıç için Raspberry Pi (Model 3B+ veya 4), .NET Core/8 desteği ve zengin GPIO/I2C/SPI arayüzleri nedeniyle mükemmel bir seçimdir. Arduino gibi daha basit mikrodenetleyiciler için doğrudan .NET çalıştırmak mümkün olmasa da, Firmata protokolü gibi yaklaşımlarla .NET uygulamanızdan Arduino'yu kontrol edebilirsiniz. TinyCLR OS gibi özel .NET çalışma zamanları da mevcuttur.

2. System.Device.Gpio kütüphanesi sadece Raspberry Pi üzerinde mi çalışır?

Hayır, System.Device.Gpio kütüphanesi Linux tabanlı birçok tek kart bilgisayar (Orange Pi, BeagleBone Black vb.) ve hatta Windows IoT Core üzerinde çalışabilir. Kütüphane, GPIO, I2C, SPI gibi donanım arayüzleri için soyut bir katman sağlar ve temel Linux GPIO sürücüleriyle entegre olur.

3. Gömülü projelerde hata ayıklama (debugging) süreci .NET'te nasıl yapılır?

Visual Studio Code veya Visual Studio kullanarak uzaktan hata ayıklama yapabilirsiniz. Uygulamanızı Raspberry Pi'ye dağıttıktan sonra, geliştirme ortamınızdan cihaza bağlanarak kodunuzda breakpoint'ler belirleyebilir, değişken değerlerini inceleyebilir ve adım adım ilerleyebilirsiniz. Ayrıca detaylı loglama, hata ayıklama sürecini büyük ölçüde kolaylaştırır.

4. .NET ile I2C/SPI hız limitleri var mıdır ve bu limitler nasıl aşılır?

Evet, I2C ve SPI protokollerinin donanımsal ve yazılımsal olarak belirli hız limitleri vardır. I2C genellikle 100 kHz, 400 kHz veya 3.4 MHz'e kadar çıkarken, SPI daha yüksek (birkaç MHz'den onlarca MHz'e) hızlara ulaşabilir. .NET tarafında, SpiConnectionSettings.ClockFrequency gibi ayarlarla bu hızları belirleyebilirsiniz. Daha yüksek hızlar için donanımın desteklemesi ve kablo uzunluğunun kısa tutulması önemlidir. Çok yüksek bant genişliği gerektiren durumlarda, Ethernet veya USB gibi farklı iletişim yöntemleri değerlendirilebilir.