Facebook RSS Feed
 
.NET Micro Framework: Sparkfun Serial 7 Segment Kullanımı
Tarih: 15.06.2014, Platform: .NET MF 4.2, IDE: Visual Studio 2013, Level: 200

Döviz panolarında, masa saatlerinde ve hava durumu göstergelerinde sıklıkla gördüğümüz 7 segment göstergerler, ekran teknolojilerindeki gelişmelere rağmen popülerliğini koruyor. Basit görünseler de bu göstergeleri kullanmak hem geliştirici için hem de mikrodenetleyici için zahmetli bir süreç. Çünkü, 7 segment gösterge LED'leri, pin tasarrufu için gözümüzün algılayamayacağı hızda yanıp sönerek görüntüyü birkaç parçada oluşturuyor.

7 Segment göstergeleri sürmenin iki temel yöntemi var. İlki, uygulamanın çalıştığı mikrodenetleyicinin göstergeyi de sürmesi. Mikrodenetleyicinin omuzlarına fazla yük yüklemeyeceksek maliyet ve düşük komponent kullanımı nedeniyle tercih etmemiz gereken yöntem budur. Fakat, mikrodenetleyicimiz bir sürü işle meşgul olacaksa ya da çok fazla sayıda basamak sürülecekse, sürücü için ayrı bir mikrodenetleyici kullanmamız yerinde olur. Bu senaryoda, ana mikrodenetleyicinin görevi gösterilecek veriyi elde etmek / hesaplamak, diğerlerinin görevi de göstergeleri sürmek olur.

Geliştiriciler olarak şanslıyız ki, piyasada bu iş için hazırlanmış gösterge modülleri bulunuyor. Bunları kullanmak için yapmamız gereken, uygun arabirimle (seri port, I2C, SPI...) gösterilecek değeri modüle iletmek ve gerisini ona bırakmak.

-

Çoğu sürücü modülünün kullanım yöntemleri birbirine benzerlik gösterir. Yazımızda ele alacağımız modül, Sparkfun'ın ürettiği Serial 7 Segment modeli. 4 Basamaklı, decimal point ve iki nokta göstergesine sahip bu modülü Serial port, I2C ya da SPI ile yönetebiliyoruz. I2C ile donanım adresi verip 128'e kadar modülü yanyana / alt alta ekleyerek büyük göstergeler de oluşturabiliyoruz. LED'lerin parlaklığının ayarlanabilmesi ve segmentlerin tek tek kontrol edilebilmesi de diğer özellikler arasında. Modülün neler yapabileceğini artık biliyoruz, öyleyse programlamaya başlayalım!

Öngereksinimler

- Herhangi bir .NET MF geliştirme modülü
- Sparkfun Serial 7 Segment modülü
- I2C ile bağlantı sağlayacaksanız, 2 x 4K7 direnç
- İsteğe bağlı breadboard ve birkaç jumper wire

Serial Port Bağlantısı

Modüle serial port ile bağlanacaksanız, 3 kabloya ihtiyacınız olacak.
1. Geliştirme kartınızın GND pinini, modülün GND pinine,
2. Geliştirme kartınızın +5V ya da +3.3V pinini, modülün VCC pinine,
3. Geliştirme kartınızın COM1 TX pinini, modülün TX pinine bağlayın.

I2C Bağlantısı

Serial port kullanmak istemiyorsanız, ya da birden çok modül kullanacaksanız, I2C kullanmanız gerekiyor. Bu durumda, 4 bağlantı yapacağız ve I2C'nin yapısı gereği data ve clock hatlarını pull-up dirençlerine bağlayacağız.
1. Geliştirme kartınızın GND pinini, modülün GND pinine,
2. Geliştirme kartınızın +5V ya da +3.3V pinini, modülün VCC pinine,
3. Geliştirme kartınızın SD / SDA pinini, modülün SDA pinine,
4. Geliştirme kartınızın SC / SCK pinini, modülün SCK pinine bağlayın.
5. Pull-up bağlantısı için, SDA ve SCK kablolarını 4K7 dirençler ile +5V'a bağlayın. Bu işlem için breadboard kullanabilirsiniz.

Uygulama Kodları

Oluşturacağınız Micro Framework Console Application projesinin referanslarına,
- Microsoft.SPOT.Hardware.dll
- Microsoft.SPOT.Hardware.SerialPort.dll
kütüphanelerini ekleyin.

Serial7Segment sınıfı, Serial Port ya da I2C ile gösterge modülüne erişmenizi sağlayacak. İlk satırlarda yer alan define satırlarından kullanacağınız arabirime ait olanı uncomment'leyin ve diğerini comment'leyin. Bu şekilde, yalnızca kullanacağınız arabirime ait kodlar compile edilecek.

[C#] Serial7Segment.cs

/**************************************
 * Sparkfun Serial 7 Segment Driver
 * For Serial Port & I2C
 * Version 1.0 @ 14.06.2014
 * Developed by Umut Erkal
 * www.uerkal.com
 **************************************/

// Kullanacağınız iletişim birimini uncomment'leyin, diğerini comment'leyin.
#define SerialPort
//#define I2C

using System.Text;

#if SerialPort
using System.IO.Ports;
#endif

#if I2C
using Microsoft.SPOT.Hardware;
#endif

namespace MFSerial7Segment
{
    public class Serial7Segment
    {
        #if SerialPort
        // Serial Port
        private static SerialPort sp;
        #endif

        #if I2C
        // I2C Cihazı ve yapılandırması
        private static I2CDevice i2cDevice;
        private static I2CDevice.Configuration i2cConfig;
        private static int transactionTimeout = 1000; // ms

        // Gösterge adresi, varsayılan olarak 0x71
        private static ushort address = 0x71;

        // İletişim hızı, en yüksek 250 Khz
        private static int clockRateKhz = 250;
        #endif

        /// <summary>
        /// Serial 7 Segment Gösterge
        /// </summary>
        public Serial7Segment()
        {
            #if SerialPort
            // Varsayılan özelliklerde serial port oluştur ve bağlan
            sp = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
            sp.Open();
            #endif

            #if I2C
            // Belirtilen özelliklerde I2C cihazı oluştur ve ayarları ata
            i2cConfig = new I2CDevice.Configuration(address, clockRateKhz);
            i2cDevice = new I2CDevice(i2cConfig);
            #endif
        }

        /// <summary>
        /// İstanilen değeri göstergeye yazar.
        /// </summary>
        /// <param name="i">Gösterilecek değer: 0 ~ 9999</param>
        public void WriteInt(int i)
        {
            // İmleci ilk pozisyona getir
            CursorControl(0);

            #if SerialPort
            sp.Write(new byte[] { (byte)(i / 1000 % 10), (byte)(i / 100 % 10),
                (byte)(i / 10 % 10), (byte)(i % 10) }, 0, 4);
            #endif

            #if I2C
            I2CWrite(new byte[] { (byte)(i / 1000 % 10), (byte)(i / 100 % 10),
                (byte)(i / 10 % 10), (byte)(i % 10) });
            #endif
        }

        /// <summary>
        /// İstanen yazıyı göstergeye yazar. (7 Segment'e uymayan karakterler gösterilmez.)
        /// </summart>
        /// <param name="i">Gösterilecek yazı.</param>
        public void WriteString(string s)
        {
            // İmleci ilk pozisyona getir
            CursorControl(0);

            #if SerialPort
            sp.Write(Encoding.UTF8.GetBytes(s), 0, 4);
            #endif

            #if I2C
            I2CWrite(Encoding.UTF8.GetBytes(s));
            #endif
        }

        /// <summary>
        /// İmleç pozisyonuna değeri yazar ve sonraki imleç pozisyonuna geçer.
        /// </summary>
        /// <param name="n">Rakam: 0 ~ 9</param>
        public void WriteSinglNumber(byte n)
        {
            #if SerialPort
            sp.Write(new byte[] { n }, 0, 1);
            #endif

            #if I2C
            I2CWrite(new byte[] { n });
            #endif
        }

        /// <summary>
        /// Göstergeyi temizler ve imleci 0 posizyonuna götürür.
        /// </summary>
        public void ClearDisplay()
        {
            #if SerialPort
            sp.Write(new byte[] { 0x76 }, 0, 1);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x76 });
            #endif
        }
        
        /// <summary>
        /// Nokta, iki nokta ve tırnak LED'lerini kontrol eder.
        /// </summary>
        /// <param name="d1point">1. Basamak noktası</param>
        /// <param name="d2point">2. Basamak noktası</param>
        /// <param name="d3point">3. Basamak noktası</param>
        /// <param name="d4point">4. Basamak noktası</param>
        /// <param name="colon">İki nokta</param>
        /// <param name="apostrophe">Tırnak işareti</param>
        public void DecimalControl(bool d1point, bool d2point, bool d3point,
            bool d4point, bool colon, bool apostrophe)
        {
            byte b = 0x00;
            if (d1point) b = (byte)(b | 0x01);
            if (d2point) b = (byte)(b | 0x02);
            if (d3point) b = (byte)(b | 0x04);
            if (d4point) b = (byte)(b | 0x08);
            if (colon) b = (byte)(b | 0x10);
            if (apostrophe) b = (byte)(b | 0x20);

            #if SerialPort
            sp.Write(new byte[] { 0x77, b }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x77, b });
            #endif
        }

        /// <summary>
        /// İmleç pozisyonunu belirler.
        /// </summary>
        /// <param name="p">İmleç pozisyonu: 0 ~ 3</param>
        public void CursorControl(byte p)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x79, p }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x79, p });
            #endif
        }

        /// <summary>
        /// Gösterge parlaklığını ayarlar.
        /// </summary>
        /// <param name="b">Parlaklık: 0 ~ 255</param>
        public void BrightnessControl(byte b)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x7A, b }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x7A, b });
            #endif
        }

        /// <summary>
        /// 1. Rakamın bölümlerini kontrol eder. (Segment kontrolü)
        /// </summary>
        /// <param name="d">Bölüm durumu: 0 ~ 127</param>
        public void Digit1Control(byte d)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x7B, d }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x7B, d });
            #endif
        }

        /// <summary>
        /// 2. Rakamın bölümlerini kontrol eder. (Segment kontrolü)
        /// </summary>
        /// <param name="d">Bölüm durumu: 0 ~ 127</param>
        public void Digit2Control(byte d)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x7C, d }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x7C, d });
            #endif
        }

        /// <summary>
        /// 3. Rakamın bölümlerini kontrol eder. (Segment kontrolü)
        /// </summary>
        /// <param name="d">Bölüm durumu: 0 ~ 127</param>
        public void Digit3Control(byte d)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x7D, d }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x7D, d });
            #endif
        }

        /// <summary>
        /// 4. Rakamın bölümlerini kontrol eder. (Segment kontrolü)
        /// </summary>
        /// <param name="d">Bölüm durumu: 0 ~ 127</param>
        public void Digit4Control(byte d)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x7E, d }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x7E, d });
            #endif
        }

        /// <summary>
        /// I2C Adresini değiştirir.
        /// </summary>
        /// <param name="a">I2C Adresi: 0 ~ 127</param>
        public void SetI2CAddress(byte a)
        {
            #if SerialPort
            sp.Write(new byte[] { 0x80, a }, 0, 2);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x80, a });
            #endif
        }

        /// <summary>
        /// Tüm ayarları sıfırlar.
        /// </summary>
        public void FactoryReset()
        {
            #if SerialPort
            sp.Write(new byte[] { 0x81 }, 0, 1);
            #endif

            #if I2C
            I2CWrite(new byte[] { 0x81 });
            #endif
        }

        #if I2C
        /// <summary>
        /// I2C Cihazına verilen parametreleri gönderir.
        /// </summary>
        /// <param name="writeBuffer">Parametreler</param>
        public void I2CWrite(byte[] writeBuffer)
        {
            // I2C Cihazı yapılandırmasını ata
            i2cDevice.Config = i2cConfig;

            // I2C Transaction oluştur
            I2CDevice.I2CTransaction[] writeXAction = new I2CDevice.I2CTransaction[]
                { I2CDevice.CreateWriteTransaction(writeBuffer) };

            lock (i2cDevice)
            {
                // Transferi gerçekleştir
                i2cDevice.Execute(writeXAction, transactionTimeout);
            }
        }
        #endif
    }
}

Program.cs sınıfı; gösterge parlaklığı, string yazdırma ve 0'dan 9999'a kadar sayım örneklerini gösterecek.

[C#] Program.cs

using System;
using Microsoft.SPOT;
using System.Threading;

namespace MFSerial7Segment
{
    public class Program
    {
        public static void Main()
        {
            // 7 Segment instance'ı oluştur
            Serial7Segment s7s = new Serial7Segment();
            
            // Gösterge parlaklığını en yükseğe ayarla
            s7s.BrightnessControl((byte)255);

            // Göstergeyi temizle
            s7s.ClearDisplay();

            // Göstergede string yazdır
            s7s.WriteString("ABCD");

            // 5 Saniye bekle
            Thread.Sleep(5000);

            // Tırnak işaretini göster
            s7s.DecimalControl(false, false, false, false, false, true);

            // Sonsuz döngüde
            while (true)
            {
                // 0'dan 9999'a kadar
                for (int i = 0; i < 10000; i++)
                {
                    // Rakam değerini yazdır
                    s7s.WriteInt(i);

                    // 100ms bekle
                    Thread.Sleep(20);
                }
            }
        }
    }
}

Bu örnek ile basit bir sayacın nasıl yapıldığını ele aldık. Serial7Segment sınıfına eklemeler yaparak birkaç gösterge modülünün birlikte çalışmasını sağlayabilirsiniz...


Ek Dosya: Belirtilmemiş.
Okunma Sayısı: 1567

comments powered by Disqus
 
Hoşgeldiniz!
Son güncelleme: 25.12.2016
-
Yeni Teknik Yazılar
Latte Panda İncelemesi
Turta IoT HAT İncelemesi
USB Gamepad Kullanımı
GPIO Kullanımı
VEML6075 UV Sensör Kullan...
-
İlgili Gruplar
.NET MF ve Gadgeteer FB Grubu
İst. IoT & Wearables Meet-up
-
 

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.Copyright © 1999 - 2017, Umut Erkal. Bu materyal, "Creative Commons Public Licence" ile sunulmuştur.
Kaynak göstererek ve ücretsiz olarak, aynı şartlar altında paylaşabilir ve kullanabilirsiniz. | Kullanım Sözleşmesi