Gelişen mikrokontrol teknolojileri ve artan bilgi birikimi sayesinde geliştirici düzeyinde daha yaygın kullanımına olanak tanımıştır. Burada elimden geldiği kadar bazı örnekler sunmaya çalışacağım... Görüleceği gibi ilk örneklerimizde çoğunlukla ASM üzerinde iken daha sonraları C üzerinde örnekler yer almaktadır. Hatta ilerleyen zamanlarda Arduino örneklerinin yer alması kaçınılmaz olacaktır.

21 Mart 2018 Çarşamba

Arduino/Genuino UNO üzerinden LM044L sürülmesi

Arduino/Genuino UNO üzerinden LM044L sürülmesi


Kullanıcı arayüzlerinin vazgeçilmez bir parçası olan LCD ekranları çoğunu o veya bu şekilde biliyoruz, karşılaşıyoruz ve kullanıyoruz. Burada elbette mikrokontrollerlara bağlanabilen modelleri işaret ettiğimizi anlamışsınızdır. Özellikle karakter LCD olarak tanımlanan ekran üzerinde sadece yazı ve rakamların gösterilebildiği modeller üzerinde duracağız

Bir rastlantı sonucu elimize geçen HITEACHI marka 4x20 LCD ekran Arduino üzerinden sürülmesi konusunu ele alacağız.  Elbette  sadece Arduino kodlaması değil, Arduino'ye eklenebilecek bir devre de konuya dahil edilmiştir.

NOT:Buradaki Arduino UNO Amerika dışındaki ürünlerin Genuino markasını almadan önce satın aldığım için üzerinde Arduino UNO yazmaktadır.

Arduino/Genuino
Arduino UNO.İster Klon deyin, ister gerçek...

 Çoğumuzun dikkatini çekmiştir, son zamanlarda yaygın olarak kullanılmaya başlanan birçok işlemcinin yanında çoğunlukla Atmel (pardon Microchip - satın almıştı) çiplerinin kullanıldığı geliştirme platformu olarak kullanılan kartlar var. Arduino (Amerika dışında Genuino markası altında pazarlanmaktadır) çeşitli ek kartlar ile kullanılarak programlama olarak hitap ettiği alan genişletilmektedir. Bu tür ek kartlara Shield olarak adlandırılmaktadır.

 Projemizde sözü edilen ek kartlardan kendi amacımıza uygun birini kullanacağız. Çünkü diğer seçeneğimiz bir yığın kablo. Elbette ben kablo yığınından hoşlanan biriyim derseniz elbette, bu yöntemi kullanmanız mümkündür. Arduino olarak kullanmayı planladığımız ürün Arduino Mega olarak bilinen ATMEGA2560 mikrokontroller çipine sahip aşağı yukarı bu serinin en üst modelidir. (Tamam biraz daha farklı bir model) Elbette gerekli değişiklikleri yaparak Arduino UNO modelini kullanabilirsiniz.

Arduino'ların en olumlu tarafı geliştirme kartı olarak ek bir programlayıcıya ihtiyaç duymaksızın seri port üzerinden (çoğu modelde modüle üzerine entegre edilmiş USB-seri dönüştürücü) bilgisayarda oluşturulan kodun Arduino modüle aktarılmasına olanak tanımaktadır. (elbette isteyen harici programlayıcıyı kullanabilir)

Arduno IDE uygulaması üzerinde oluşturduğunuz kodu bir butona tıklayarak derleyebilir ve bilgisayarınıza bağlı Arduino üzerine yükleyebilirsiniz. İşlemci üzerinde bir ön yüklemesi yapılmış bootloader kodu yer almaktadır.

Arduino IDE üzerinde programlama C kodunda yazılırken, kütüphaneleri C++  dilinde oluşturulmuştur.

Hazır Arduino  kodlarını kullanabildiğiniz gibi daha ayrıntılı işlemlerde Atmel (işlemcisi Atmel olan modellerde) işlemci register C kodlamalarını kullanabilirsiniz.


LM044L 

LCD'nin önden ve arkadan görünümü. Şimdilerde artık çipler PCB üzerine gömülmekte. Sanırım üretimi daha kolay oluyor.

Değişik zamanlarda LM044L ile ilgili şemalara ve kodlara rastladığımız olmuştu. Aslında bu kadar eski olabileceğini düşünmemiştik. LM044L için söktüğümüz kart üzerinde kablo ile bağlı idi. Hali ile bu şekilde kullanımında sorun olacağını düşünerek, kabloyu söküp yerine 14'li 2.54mm erkek sıra pin taktık. Bunun nedeni LCD için (shield) olarak tasarlanan kartın üzerinde LCD'nin kolay monte edilebilmesi için 2.54mm bacak aralıklı dişi sıra pin bulunmaktadır. LM044L üzerinde HD44780 kontroller bulunmaktadır.

Bu LCD kullanırken gereken tek eleman bir trimpot veya bir dirençtir. Kontrast ayarı olarak bilinen, ekranda gösterilen karakterlerin koyuluğunu/açıklığını ayarlama işlemidir. LCD ekranın Vo bacağına uygulanan gerilimle orantılı olarak ekranın açıklık/koyuluk ayarı değişecektir.

HD44780 çipinin RW,RS, E bacaklarına ek 8 adet data hattı üzerinden kontrol edilebileceği anlamını taşır. Dolayısı ile HD44780 komut seti geçerlidir. Bu da piyasadaki bu tür LCD ekranların sürülmesinde kullanılan tekniğin aynen geçerli olduğunu gösterir.

LM044L bacak bağlantıları. Görüldüğü gibi karakter LCD7ler ile uyumludur.

Besleme olarak 5Volt kullanılabilir olması projemiz için gayet iyi bir durumudur. Zira ek bir çeviriciye veya Arduino kartını 5Volt dışında bir besleme ile çalışmaya zorlamaktan kurtaracaktır. (özellikle bilgisayar üzerinden besleme gibi bir planımız varken) LCD için söylenebilecek tek şey arkaplan aydınlatmasının olmadığıdır. Özellikle güneş altında çalışacağı zaman bu bir sorun değil, hatta iyi bir şey olabilmektedir. (Çoğu durumda bazı cep telefonları güneş ışığı altında çalışamazken, arkaplan aydınlatması olmayan LCD ekranlar rahatlıkla görülebilir durumda olmaktadır. Dolayısı ile karanlıkta veya ışığın yetersiz olduğu durumlarda ek ışık kaynağını ihtiyaç olacaktır.

HD44780 işlemcisinden bahsedecek olursak;
İşlemci  data hatlarından verinin ve komutların alınıp, çözümlenip, uygun şekilde yorumlanıp, verinin ekran üzerinde görüntülenmesi  gibi LCD üzerindeki tüm işlemlerin yürütülmesi ve kontrolundan sorumludur.

Bu noktada önemli birkaç kavram üzerinde durmak gerekmektedir. Örneğin DDRAM(display Data RAM); alınan veri ve komutların geçici olarak depolandığı alandır. Ana işlem RAM'i olarak yorumlanabilir. 80 karakter alabilecek bir kapasiteye sahiptir. (ekranın 4x20 olduğu düşünülürse, ekrandaki tüm karakterleri alabilecek kapasitede olduğu görülür)

Karakter LCD'lerin en büyük özelliği veya adını aldığı yer olan karakter jeneratörü bulundurmalarıdır. Yani ekranda gösterilen a,b,c...1,2,3,,..?,=... gibi her türlü nokta ve virgülde dahil hatta boşluk bile , gibi verileri saklandığı yerdir. İşlemci DDRAM'a gelen veriye uygun karakteri karakter jeneratöründen alır ve  LCD ekran üzerinde görüntülenmesini sağlar. Bu alan CGROM-karakter jeneratörü ROM olarak tanımlanır.

Not: üretici her ne kadar karakter jeneratörü için karakter tanımlarından istenilen karakterlere göre ürün üretebileceğini belirtse de, elbette belirli bir kota için sınırları olması kaçınılmaz.

Ama LCD üzerinde her zaman istenen karakter bulunamayabilir. Örneğin Türkçe de yer alıpta başka dillerde yer almayan bazı karakterlerimiz vardır, Örneğin, ç,ş,ğ,ı,ö,ü,Ç,Ş,Ğ,İ,Ö,Ü gibi karakterler.
 Sözü edilen karakterler çoğu LCD üzerinde yer almaz. Yok diye kullanmayacak değiliz, bu iş için çözüm sınırlı olsa bile var. CGRAM-karakter jeneratörü RAM. 64 bayt büyüklüğünde bir alan karakter olarak kullanımımız için ayrılmıştır. Çok görünmesi 5x8'lik bir karakter alanı için 8 baytlık bir RAM kullanılacaktır. Dolayısı ile sadece 8 karakter kullanım alanı tanıyacaktır.

Buradaki sıkıntı elbette ş çağırıldığında ş gelmez. ş karakterin hangi ram gözesine yazılır ise o gözenin çağrılması gerekecektir. Yada programı ş çağrıldığında ş gelecek şekilde kodlamak gerekecektir.

örneğin ç akarakteri için aşağıdaki gibi bir data grubu gereklidir.
const uint8_t c_char[8] = {
  0b00000000,
  0b00000000,
  0b00001110,
  0b00010000,
  0b00010000,
  0b00010001,
  0b00001110,
  0b00000100
};

ama bu tek başına yeterli değildir.

 lcd.createChar(0, c_char);    //ç

gibi bir kodun setup fonksiyon bölümüne eklemek gereklidir. Tabii ki bu da yeterli değildir. Çünkü bu kod grubu sadece ç karakteri verilerini CGRAM 0 nolu adresten itibaren yazılmasını sağlar. Bu karakterin ekrana çağrılması için LCD başlama kodlarından sonra

lcd.write((uint8_t)0);  //ç

gibi bir kod grubuna ihtiyaç vardır. Bu kod ç karakterinin her çağrılacağı yerde kullanılabilir.

Not: Arduino kodlama ve kütüphaneleri kullanımı ile..

Şema


Devre şeması. İşin içinde arduino olunca devre oldukça basitleşti...

Kırmızı dörtgen ile gösterilen bölümdeki elemanlar kullanılmamıştır. LM35 termometre projesi için kullanılırken (LM35 yerine gerekli direnç eklenerek DS1820 'de kullanılabilir), transistör ile ilgili elemanlar arkaplan aydınlatması olan LCD'lerin arka plan aydınlatması kontrolu için kullanılmaktadır.

Trimpot LCD kontrast ayarı içindir. Devre çalıştırıldıktan sonra, ekran görüntüsünün istenen değere kadar ayarlamasını sağlar.

PCB

Altyüzdeki yollar.
üst yüzdeki malzeme yerleşimi. (kırmızı ile gösterilen elemanlar bu projede kullanılmamıştır.

Devre tasarımında PCB'nin kendimiz üretebileceğimiz bir yapıda olmasını istediğimiz için tek yüzlü olmasına özellikle dikkat ettik.

Erkek pinler n PCB'nin  bakırlı tarafına lehimlemek gerektiği için dikkatli davranmak gereklidir.

Monte edilmiş PCB'nin ön ve arkadan görünümü. Görüldüğü gibi sadece timpot ve sıra pinler monte edilmiş durumda.

Farkettiğiniz gibi besleme  sıra pinler ve karşısındaki sıra pinlerden 2'şer adet azaltılmış ve PCB boyutu kısaltılmıştır.

Malzeme Listesi
İşlemci kartı ve ekran kartı için malzeme listesi

Arduino UNO-
USB kablosu-
10k trimpotR1
2.54 mm 16'lı dişi sıra pinLCD
LM044L-
2.54 mm 6'lı erkek sıra pin2 adet
2.54 mm 8'li erkek sıra pin2 adet

Kullanımı

Kablo hariç, projede kullanılan malzemeler.

LCD konnektörü LM044L için soldaki pinden itibaren hizalanacaktır. Çünkü  LM044L üzerinde arkaplan aydınlatması olmadığı için  LCD yazan konnektörünün sağdaki iki pin boş kalacaktır.

Yapılacak işlem olarak;

  • Arduino UNO üzerine  LM044L için tasarlanan PCB'yi tak.
  •  PCB üzerine LM044L LCD ekranı tak.
  • USB kablosunu kullanarak Arduino- bilgisayar bağlantısını sağla.
  • Arduino IDE uygulamasını çalıştırarak kodlamaya giriş.
LCD'nin PCB üzerine yerleşimi. LCD bacakları kırmızı ile işaretlidir. Kalan 2 bacak arkaplan aydınlatması olan LCD'ler için arkaplan aydınlatma besleme bacaklarıdır.




Örnek 1:
Programın LCD ekran üzerindeki görünümü


//Arduino UNO üzerinde Türkçe karakterleri gösterme
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 10, 9, 8, 7, 6, 5, 4, 3, 2);
//PCB tasarımından dolayı...8 data hattı kullanımda.

const uint8_t c_char[8] = {
  0b00000000,
  0b00000000,
  0b00001110,
  0b00010000,
  0b00010000,
  0b00010001,
  0b00001110,
  0b00000100
};
const uint8_t s_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b10000,
  0b01110,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t i_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b00100,
  0b00100,
  0b00100,
  0b01110,
  0b00000
};
const uint8_t o_char[8] = {
  0b01010,
  0b00000,
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b01110,
  0b00000
};
const uint8_t u_char[8] = {
  0b01010,
  0b00000,
  0b10001,
  0b10001,
  0b10001,
  0b10011,
  0b01101,
  0b00000
};

const uint8_t g_char[8] = {
  0b01110,
  0b00000,
  0b01111,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b01110
};

const uint8_t bc_char[8] = {
  0b01110,
  0b10001,
  0b10000,
  0b10000,
  0b10000,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t bs_char[8] = {
  0b01111,
  0b10000,
  0b10000,
  0b01110,
  0b00001,
  0b00001,
  0b11110,
  0b00100
};


void setup()
{
  pinMode(11, OUTPUT);    //RW hattı bağlı olduğu için
  digitalWrite(11, LOW);  //kullanılmasa bile lojik-0.. (yazma için)
  lcd.createChar(0, c_char);    //ç
  lcd.createChar(1, g_char);    //ğ
  lcd.createChar(2, i_char);    //ı
  lcd.createChar(3, o_char);    //ö
  lcd.createChar(4, s_char);    //ş
  lcd.createChar(5, u_char);    //ü
  lcd.createChar(6, bc_char);   //Ç
  lcd.createChar(7, bs_char);   //Ş

  lcd.begin(20, 4);   //20 karakter,4 satır
  delay(1);
  lcd.setCursor(0, 0);    //ilk satır
  lcd.print("Kabil ATICI");

}
void loop()
{

  //sütun, satır)
  lcd.setCursor(0, 0);//birinci sütun, birinci satır
  lcd.print("Kabil ATICI");
  lcd.setCursor(0, 1); //birinci sütun, ikinci satır
  delay(5);
  lcd.write((uint8_t)0);  //ç
  lcd.write((uint8_t)1);  //ğ
  lcd.write((uint8_t)2);  //ı
  lcd.write((uint8_t)3);  //ö
  lcd.write((uint8_t)4);  //ş
  lcd.write((uint8_t)5);  //ü
  lcd.write((uint8_t)6);  //Ç
  lcd.write((uint8_t)7);  //Ş

}

Örnek 2:
//Raduino üzerinde Türkçe karakterleri gösterme
#include <LiquidCrystal.h>
LiquidCrystal lcd(50, 53, 9, 8, 7, 6, 5, 4, 3, 2);
//PCB tasarımından dolayı...8 data hattı kullanımda.

const uint8_t c_char[8] = {
  0b00000000,
  0b00000000,
  0b00001110,
  0b00010000,
  0b00010000,
  0b00010001,
  0b00001110,
  0b00000100
};
const uint8_t s_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b10000,
  0b01110,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t i_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b00100,
  0b00100,
  0b00100,
  0b01110,
  0b00000
};
const uint8_t o_char[8] = {
  0b01010,
  0b00000,
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b01110,
  0b00000
};
const uint8_t u_char[8] = {
  0b01010,
  0b00000,
  0b10001,
  0b10001,
  0b10001,
  0b10011,
  0b01101,
  0b00000
};

const uint8_t g_char[8] = {
  0b01110,
  0b00000,
  0b01111,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b01110
};

const uint8_t bc_char[8] = {
  0b01110,
  0b10001,
  0b10000,
  0b10000,
  0b10000,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t bs_char[8] = {
  0b01111,
  0b10000,
  0b10000,
  0b01110,
  0b00001,
  0b00001,
  0b11110,
  0b00100
};


void setup()
{
  pinMode(51, OUTPUT);    //RW hattı bağlı olduğu için
  digitalWrite(51, LOW);  //kullanılmasa bile lojik-0.. (yazma için)
  lcd.createChar(0, c_char);    //ç
  lcd.createChar(1, g_char);    //ğ
  lcd.createChar(2, i_char);    //ı
  lcd.createChar(3, o_char);    //ö
  lcd.createChar(4, s_char);    //ş
  lcd.createChar(5, u_char);    //ü
  lcd.createChar(6, bc_char);   //Ç
  lcd.createChar(7, bs_char);   //Ş

  lcd.begin(20, 4);   //20 karakter,4 satır
  delay(1);
  lcd.setCursor(0, 0);    //ilk satır
  lcd.print("Kabil ATICI");

}
void loop()
{

  //sütun, satır)
  lcd.setCursor(0, 0);//birinci sütun, birinci satır
  lcd.print("Kabil ATICI");
  lcd.setCursor(0, 1); //birinci sütun, ikinci satır
  delay(5);
  lcd.write((uint8_t)0);  //ç
  lcd.write((uint8_t)1);  //ğ
  lcd.write((uint8_t)2);  //ı
  lcd.write((uint8_t)3);  //ö
  lcd.write((uint8_t)4);  //ş
  lcd.write((uint8_t)5);  //ü
  lcd.write((uint8_t)6);  //Ç
  lcd.write((uint8_t)7);  //Ş

}
Örnek 3:
Programın LCD ekran üzerindeki görünümü
//Arduino UNO üzerinde Türkçe karakterleri gösterme
#include <LiquidCrystal.h>
//LiquidCrystal lcd(12, 10, 5, 4, 3, 2);
LiquidCrystal lcd(12, 10, 9, 8, 7, 6, 5, 4, 3, 2);

const uint8_t c_char[8] = {
  0b00000000,
  0b00000000,
  0b00001110,
  0b00010000,
  0b00010000,
  0b00010001,
  0b00001110,
  0b00000100
};
const uint8_t s_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b10000,
  0b01110,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t i_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b00100,
  0b00100,
  0b00100,
  0b01110,
  0b00000
};
const uint8_t o_char[8] = {
  0b01010,
  0b00000,
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b01110,
  0b00000
};
const uint8_t u_char[8] = {
  0b01010,
  0b00000,
  0b10001,
  0b10001,
  0b10001,
  0b10011,
  0b01101,
  0b00000
};

const uint8_t g_char[8] = {
  0b01110,
  0b00000,
  0b01111,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b01110
};

const uint8_t bc_char[8] = {
  0b01110,
  0b10001,
  0b10000,
  0b10000,
  0b10000,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t bs_char[8] = {
  0b01111,
  0b10000,
  0b10000,
  0b01110,
  0b00001,
  0b00001,
  0b11110,
  0b00100
};


void setup()
{
  pinMode(11, OUTPUT);
  digitalWrite(11, LOW);
  lcd.createChar(0, c_char);
  lcd.createChar(1, g_char);
  lcd.createChar(2, i_char);
  lcd.createChar(3, o_char);
  lcd.createChar(4, s_char);
  lcd.createChar(5, u_char);
  lcd.createChar(6, bc_char);
  lcd.createChar(7, bs_char);

  lcd.begin(20, 4);
  delay(1);
  lcd.setCursor(0, 0);
  lcd.print("Kabil ATICI");

}
void loop()
{
  //sütun, satır)
  lcd.setCursor(0, 0);//birinci sütun, birinci satır
  lcd.print("Arduino/Genuino UNO ");
  lcd.setCursor(0, 1); //birinci sütun, ikinci satır
  lcd.write((uint8_t)5);
  lcd.print("zerinden LM044L LCD");
  lcd.setCursor(0, 2);  //birinci sütun, üçüncü satır
  lcd.print("s");
  lcd.write((uint8_t)5);
  lcd.print("r");
  lcd.write((uint8_t)5);
  lcd.print("lmesi");
  lcd.setCursor(0, 3); //birinci sütun, dördüncü satır
  delay(5);
  lcd.print("19 - 03 - 2018");
  ///üçüncü satır boş...
}
Örnek 4:
Programın LCD ekran üzerindeki görünümü
//Türkçe karakterin görüntülenmesi
//Raduino üzerinden LM044L sürülmesi yazısının ekrana yazdırılması
#include <LiquidCrystal.h>
LiquidCrystal lcd(50, 53, 9, 8, 7, 6, 5, 4, 3, 2);
//PCB tasarımından dolayı...8 data hattı kullanımda.

const uint8_t c_char[8] = {
  0b00000000,
  0b00000000,
  0b00001110,
  0b00010000,
  0b00010000,
  0b00010001,
  0b00001110,
  0b00000100
};
const uint8_t s_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b10000,
  0b01110,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t i_char[8] = {
  0b00000,
  0b00000,
  0b01110,
  0b00100,
  0b00100,
  0b00100,
  0b01110,
  0b00000
};
const uint8_t o_char[8] = {
  0b01010,
  0b00000,
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b01110,
  0b00000
};
const uint8_t u_char[8] = {
  0b01010,
  0b00000,
  0b10001,
  0b10001,
  0b10001,
  0b10011,
  0b01101,
  0b00000
};

const uint8_t g_char[8] = {
  0b01110,
  0b00000,
  0b01111,
  0b10001,
  0b10001,
  0b01111,
  0b00001,
  0b01110
};

const uint8_t bc_char[8] = {
  0b01110,
  0b10001,
  0b10000,
  0b10000,
  0b10000,
  0b10001,
  0b01110,
  0b00100
};

const uint8_t bs_char[8] = {
  0b01111,
  0b10000,
  0b10000,
  0b01110,
  0b00001,
  0b00001,
  0b11110,
  0b00100
};


void setup()
{
  pinMode(51, OUTPUT);    //RW hattı bağlı olduğu için
  digitalWrite(51, LOW);  //kullanılmasa bile lojik-0.. (yazma için)
  lcd.createChar(0, c_char);    //ç
  lcd.createChar(1, g_char);    //ğ
  lcd.createChar(2, i_char);    //ı
  lcd.createChar(3, o_char);    //ö
  lcd.createChar(4, s_char);    //ş
  lcd.createChar(5, u_char);    //ü
  lcd.createChar(6, bc_char);   //Ç
  lcd.createChar(7, bs_char);   //Ş

  lcd.begin(20, 4);   //20 karakter,4 satır
  delay(1);
  lcd.setCursor(0, 0);    //ilk satır
  lcd.print("Kabil ATICI");

}
void loop()
{

  //sütun, satır)
  lcd.setCursor(0, 0);//birinci sütun, birinci satır
  lcd.print("Raduino ");
  lcd.write((uint8_t)5);
  lcd.print("zerinden");
  lcd.setCursor(0, 1);
  lcd.print("LM044L s");
  lcd.write((uint8_t)5);
  lcd.print("r");
  lcd.write((uint8_t)5);
  lcd.print("lmesi");
  lcd.setCursor(0, 3); //birinci sütun, dördüncü satır
  delay(5);
  lcd.print("19 - 03 - 2018");
}
Örnek 5:

Aşağıdaki kodun Arduino üzerine yüklendikten sonraki görünümü
Arduino kodlama işine başladığım dönemlerde kullandığım LCD kodunu Arduino'ya taşımaya çalışmıştım. Özellikle C diline geçiş döneminde , C diline öğrenmek açısından oldukça yararlı olmuştu. Özellikle kütüphane kullanılmadan gerçekleştirildiği için başka dillere kolaylıkla taşınabilir...
//8 bit lcd ekran iletişim için

#include <stdio.h>
#include <inttypes.h>
#include "Arduino.h"

int _rs_pin = 12;
int _rw_pin = 11;
int _enable_pin = 10;

int  _data_pins[] = {9, 8, 7, 6, 5, 4, 3, 2}; //dizi olarak tanımla

byte karak [48] = {
  0, 0, 12, 4, 4, 4, 14, 0, 10, 0, 17, 17, 17, 19, 13, 0, 10, 0, 15, 17,
  17, 17, 14, 0, 0, 0, 14, 16, 14, 1, 30, 4, 0, 0, 14, 16, 16, 17, 14, 4,
  30, 15, 17, 17, 15, 1, 14, 0
};
//ekran mesajları

char kabil[] = "Kabil ATICI";
char mesaj[] = "               "; //ekrana mesaj yazdıracak bellek alanı
char tarih[] = "20-03-2018";
void setup() {
  // put your setup code here, to run once:
  bacak_cik();
  pinMode(13, OUTPUT);
  digitalWrite(_rs_pin, LOW);
  digitalWrite(_enable_pin, LOW);
  digitalWrite(_rw_pin, LOW);
  LCD_basla();

  sat_yaz(1); //1. satır
  LCD_Yaz_veri(0x00);//ı
  LCD_Yaz_veri(0x01);//ü
  LCD_Yaz_veri(0x02);//ö
  LCD_Yaz_veri(0x03);//ş
  LCD_Yaz_veri(0x04);//ç
  LCD_Yaz_veri(0x05);//ğ
  
  sat_yaz(2);   //2. satır
  metni_yaz(1);

  // bu şekilde de yazılabilir..
  sat_yaz(3);   //3. satır
  LCD_Yaz_veri('B');
  LCD_Yaz_veri('o');
  LCD_Yaz_veri(0x03);//ş
  LCD_Yaz_veri(' ');
  LCD_Yaz_veri('s');
  LCD_Yaz_veri('a');
  LCD_Yaz_veri('t');
  LCD_Yaz_veri(0x00);//ı
  LCD_Yaz_veri('r');

  sat_yaz(4);//4. satır
  metni_yaz(2);
  sat_yaz(1);   //1. satır
}

void loop() {
  // put your main code here, to run repeatedly:
  delay(100);
  digitalWrite(13, HIGH);
  delay(100);
  digitalWrite(13, LOW);
}

//string'i ekrana yazdırrma
void metni_yaz(uint8_t mesno)
{
  if (mesno == 1)
  {
    for (uint8_t i = 0; i < sizeof(kabil) - 1; i++)
    {
      LCD_Yaz_veri (kabil[i]);
    }
  } else if (mesno == 2)
  {
    for (uint8_t i = 0; i < sizeof(tarih) - 1; i++)
    {
      LCD_Yaz_veri (tarih[i]);
    }
  }
}

//satır değerini belirleme
void sat_yaz(uint8_t satir)
{
  if (satir == 1) //1. satır
  {
    LCD_Yaz_komut(0x80);
  }
  if (satir == 2) //2. satır
  {
    LCD_Yaz_komut(0xC0);
  }
  if (satir == 3) //3. satır
  {
    LCD_Yaz_komut(0x94);
  }
  if (satir == 4) //4. satır
  {
    LCD_Yaz_komut(0xd4);
  }
}

void LCD_basla(void)
{
  digitalWrite(_rs_pin, LOW);
  digitalWrite(_enable_pin, LOW);
  digitalWrite(_rw_pin, LOW);
  bacak_cik();
  delayMicroseconds(5000); //lcd besleme oturması için bekle
  LCD_Yaz_komut(0x38);
  delayMicroseconds(4500); //  4.1ms bekle
  LCD_Yaz_komut(0x38);
  delayMicroseconds(150);// 100µs bekle
  LCD_Yaz_komut(0x38);
  //delayMicroseconds(50);// 100µs bekle
  LCD_Yaz_komut(0x38);

  LCD_Yaz_komut(0x0C); //cd modunu belirler...

  LCD_Yaz_komut(0x01);//lcd'si siler.(ekranını)

  ekran_sil(); //ekran silme

  LCD_Yaz_komut(0x40);
  //for (int i=0;i
  cgram_gon();
}

//ekrana boşluk karakteri yazarak silme
void ekran_sil(void)
{
  //1. satırı sil
  sat_yaz(1);
  for (int i = 0; i < 17; i++)
  {
    LCD_Yaz_veri(0x20);
  }
  //2. satırı sil
  sat_yaz(2);
  for (int i = 0; i < 17; i++)
  {
    LCD_Yaz_veri(0x20);
  }
}

//karakter RAM özel karakter gönderme
void cgram_gon(void)
{
  for (int i = 0; i < 48; i++)
  {
    LCD_Yaz_veri(karak[i]);
  }
}

//LCD port çıkış olarak ata
void bacak_cik(void)
{
  for (uint8_t i = 0; i < 8; i++) {
    pinMode(_data_pins[i], OUTPUT);
  }
  pinMode(_rs_pin , OUTPUT);
  pinMode(_enable_pin , OUTPUT);
  pinMode(_rw_pin , OUTPUT);
}

//LCD port giriş olarak ata
void bacak_gir(void)
{
  for (uint8_t i = 0; i < 8; i++) {
    pinMode(_data_pins[i], INPUT);
    // digitalWrite(_data_pins[i], HIGH);
  }
}

//komutu LCD ekrana gönderme
void LCD_Yaz_komut (uint8_t value) {
  digitalWrite(_rw_pin, LOW);
  digitalWrite(_rs_pin, LOW);
  LCD_gonder(value);
}

//veri LCD ekrana gönderme
void LCD_Yaz_veri (uint8_t value) {
  digitalWrite(_rw_pin, LOW);
  digitalWrite(_rs_pin, HIGH);
  LCD_gonder(value);
}
//veriyi LCD'ye gönder ve meşgul kontrolu yap
void LCD_gonder(uint8_t value1)
{
  int pin7durum = 0;
  for (uint8_t i = 0; i < 8; i++) {
    // pinMode(_data_pins[i], OUTPUT);
    digitalWrite(_data_pins[i], (value1 >> i) & 0x01);
  }
  delayMicroseconds(40);
  pulseEnable();
  bacak_gir();//meşguliyet kontrolu için giriş yap..
  digitalWrite(_rs_pin, LOW);
  digitalWrite(_rw_pin, HIGH);  //lcd porttan veri okuma

  while (pin7durum == HIGH)
  {
    pulseEnable();      //okuma için darbe
    pin7durum = digitalRead(_data_pins[7]); //7. biti oku
  }

  bacak_cik();  //LCD  port bacakları çıkış olarak ata
  digitalWrite(_rw_pin, LOW);

}

//LCD darbe oluştur
void pulseEnable1(void) {
  delayMicroseconds(3);
  digitalWrite(_enable_pin, LOW);
  delayMicroseconds(3);
  digitalWrite(_enable_pin, HIGH);
  delayMicroseconds(3);    // enable pulse must be >450ns
  digitalWrite(_enable_pin, LOW);
  delayMicroseconds(100);   // commands need > 37us to settle
}

void pulseEnable(void) {
  digitalWrite(_enable_pin, LOW);
  delayMicroseconds(1);
  digitalWrite(_enable_pin, HIGH);
  delayMicroseconds(1);    // enable pulse must be >450ns
  digitalWrite(_enable_pin, LOW);
  delayMicroseconds(100);   // commands need > 37us to settle
}
Sonuç LCD bir çok uygulamada kullanıcı arayüzü olarak karşımıza çıkar. Kendi uygulamanızda ilginiç kullanım alanların kolaylıkla bulabilirsiniz. Kendi öel karakterlerinizi oluşturmak isterseniz, http://arduinom.org/lcdozelkarakter.html adresindeki sayfayı kullabilirsiniz. Hatta yanında bir de örnek program kodunu üretecektir.

Hiç yorum yok:

Translate

Sayfalar

Etiketler

İzleyiciler